EndWith в JavaScript

Ответ 1

ОБНОВЛЕНИЕ (24 ноября 2015 г.):

Этот ответ изначально размещен в 2010 году (ШЕСТЬ лет назад). Поэтому, пожалуйста, обратите внимание на эти проницательные комментарии:

• Shauna - Обновление для гуглеров - похоже, что ECMA6 добавляет эту функцию. Статья MDN также показывает polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• T.J. Crowder - создание подстрок не дорого для современных браузеров; возможно, это было в 2010 году, когда был опубликован этот ответ. В наши дни простой подход this.substr(-suffix.length) === suffix самый быстрый в Chrome, тот же, что и в IE11, как indexOf, и только на 4% медленнее (fergetaboutit) на Firefox: jsperf.com/endswith-stackoverflow/14 И быстрее по телу, когда результат ложный: jsperf.com/endswith-stackoverflow-when-false Конечно, с добавлением ES6 концов. С точка спорная.: -)

ОРИГИНАЛЬНЫЙ ОТВЕТ:

Я знаю, что это вопрос на год... но мне это тоже нужно, и мне нужно, чтобы он работал в кросс-браузере, поэтому... , объединяющий всех ответов и комментариев и немного упрощающий:

String.prototype.endsWith = function(suffix) {
    return this.indexOf(suffix, this.length - suffix.length) !== -1;
};

• Не создает подстроку
• Использует встроенную функцию indexOf для достижения самых быстрых результатов
• Пропустить ненужные сравнения, используя второй параметр indexOf, чтобы пропустить вперед
• Работает в Internet Explorer
• НЕТ Регулярные осложнения

Кроме того, если вам не нравятся набивные вещи в прототипах собственных данных, вот отдельная версия:

function endsWith(str, suffix) {
    return str.indexOf(suffix, str.length - suffix.length) !== -1;
}

РЕДАКТИРОВАТЬ: Как отмечалось в комментариях @hamish, если вы хотите ошибиться в безопасности и проверить, была ли реализована реализация, вы можете просто добавить проверку typeof так:

if (typeof String.prototype.endsWith !== 'function') {
    String.prototype.endsWith = function(suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

Ответ 2

/#$/.test(str)

будет работать во всех браузерах, не требует патчей обезьяны String и не требует сканирования всей строки, как lastIndexOf, когда нет совпадения.

Если вы хотите совместить константную строку, которая может содержать специальные символы регулярного выражения, например '$', вы можете использовать следующее:

function makeSuffixRegExp(suffix, caseInsensitive) {
  return new RegExp(
      String(suffix).replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&") + "$",
      caseInsensitive ? "i" : "");
}

а затем вы можете использовать его следующим образом

makeSuffixRegExp("a[complicated]*suffix*").test(str)

Ответ 3

• К сожалению, нет.
• if( "mystring#".substr(-1) === "#" ) {}

Ответ 4

Давай, это правильная реализация endsWith:

String.prototype.endsWith = function (s) {
  return this.length >= s.length && this.substr(this.length - s.length) == s;
}

с помощью lastIndexOf просто создает ненужные циклы ЦП, если нет совпадения.

Ответ 5

Эта версия избегает создания подстроки и не использует регулярные выражения (некоторые ответы на регулярные выражения здесь будут работать, другие будут разбиты):

String.prototype.endsWith = function(str)
{
    var lastIndex = this.lastIndexOf(str);
    return (lastIndex !== -1) && (lastIndex + str.length === this.length);
}

Если производительность важна для вас, было бы целесообразно проверить, действительно ли lastIndexOf быстрее, чем создание подстроки или нет. (Это может сильно зависеть от используемого вами механизма JS...) В случае совпадения может быть быстрее, а когда строка мала - но когда строка огромна, ей нужно оглянуться назад, хотя нам все равно: (

Для проверки одного символа поиск длины, а затем с помощью charAt, вероятно, лучший способ.

Ответ 6

Не видел apporach с методом slice. Поэтому я просто оставлю это здесь:

function endsWith(str, suffix) {
    return str.slice(-suffix.length) === suffix
}

Ответ 7

return this.lastIndexOf(str) + str.length == this.length;

не работает в случае, когда длина исходной строки меньше, чем длина строки поиска, и строка поиска не найдена:

lastIndexOf возвращает -1, затем вы добавляете длину строки поиска, и вы остаетесь с исходной длиной строки.

Возможное исправление

return this.length >= str.length && this.lastIndexOf(str) + str.length == this.length

Ответ 8

От developer.mozilla.org String.prototype.endsWith()

Резюме

Метод endsWith() определяет, заканчивается ли строка символами другой строки, возвращая true или false соответственно.

Синтаксис

str.endsWith(searchString [, position]);

Параметры

• searchString: Символы, которые нужно найти в конце этой строки.

• позиция: Искать внутри этой строки, как если бы эта строка была только такой длинной; по умолчанию используется эта фактическая длина строки, зажатая в пределах диапазона, установленного этой длиной строки.

Описание

Этот метод позволяет определить, заканчивается ли строка с другой строкой.

Примеры

var str = "To be, or not to be, that is the question.";

alert( str.endsWith("question.") );  // true
alert( str.endsWith("to be") );      // false
alert( str.endsWith("to be", 19) );  // true

Технические характеристики

Спецификация языка ECMAScript 6-е издание (ECMA-262)

Совместимость с браузером

Ответ 9

String.prototype.endsWith = function(str) 
{return (this.match(str+"$")==str)}

String.prototype.startsWith = function(str) 
{return (this.match("^"+str)==str)}

Я надеюсь, что это поможет

var myStr = "  Earth is a beautiful planet  ";
var myStr2 = myStr.trim();  
//=="Earth is a beautiful planet";

if (myStr2.startsWith("Earth")) // returns TRUE

if (myStr2.endsWith("planet")) // returns TRUE

if (myStr.startsWith("Earth")) 
// returns FALSE due to the leading spaces…

if (myStr.endsWith("planet")) 
// returns FALSE due to trailing spaces…

традиционный способ

function strStartsWith(str, prefix) {
    return str.indexOf(prefix) === 0;
}

function strEndsWith(str, suffix) {
    return str.match(suffix+"$")==suffix;
}

Ответ 10

if( ("mystring#").substr(-1,1) == '#' )

- Или -

if( ("mystring#").match(/#$/) )

Ответ 11

Я не знаю о вас, но:

var s = "mystring#";
s.length >= 1 && s[s.length - 1] == '#'; // will do the thing!

Почему регулярные выражения? Зачем возиться с прототипом? зиЬзЬг? c'mon...

Ответ 12

Я только что узнал об этой строковой библиотеке:

http://stringjs.com/

Включите js файл, а затем используйте переменную S следующим образом:

S('hi there').endsWith('hi there')

Его также можно использовать в NodeJS, установив его:

npm install string

Затем требуя его как переменную S:

var S = require('string');

На веб-странице также есть ссылки на альтернативные библиотеки строк, если это не ваше воображение.

Ответ 13

Если вы используете lodash:

_.endsWith('abc', 'c'); // true

Если вы не используете lodash, вы можете заимствовать его из источника.

Ответ 14

function strEndsWith(str,suffix) {
  var reguex= new RegExp(suffix+'$');

  if (str.match(reguex)!=null)
      return true;

  return false;
}

Ответ 15

Так много всего для такой маленькой проблемы, просто используйте это регулярное выражение

var str = "mystring#";
var regex = /^.*#$/

if (regex.test(str)){
  //if it has a trailing '#'
}

Ответ 16

Прошло много лет для этого вопроса. Позвольте мне добавить важное обновление для пользователей, которые хотят использовать наиболее проголосованный ответ чакры.

'endsWith' уже добавлены в JavaScript как часть ECMAScript 6 (экспериментальная технология)

См. здесь: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Поэтому настоятельно рекомендуется добавить проверку существования встроенной реализации, как указано в ответе.

Ответ 17

Еще одна быстрая альтернатива, которая работала как прелесть для меня, с помощью regex:

// Would be equivalent to:
// "Hello World!".endsWith("World!")
"Hello World!".match("World!$") != null

Ответ 18

Способ будущего доказательства и/или предотвращения перезаписи существующего прототипа будет проверкой проверки, чтобы убедиться, что он уже добавлен в прототип String. Здесь я использую высокорейтинговую версию без регулярных выражений.

if (typeof String.endsWith !== 'function') {
    String.prototype.endsWith = function (suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

Ответ 19

Принятый ответ @chakrit - это надежный способ сделать это самостоятельно. Если, однако, вы ищете пакетное решение, я рекомендую взглянуть на underscore.string, как отметил @mlunoe. Используя команду underscore.string, код будет выглядеть следующим образом:

function endsWithHash(str) {
  return _.str.endsWith(str, '#');
}

Ответ 20

function check(str)
{
    var lastIndex = str.lastIndexOf('/');
    return (lastIndex != -1) && (lastIndex  == (str.length - 1));
}

Ответ 21

если вы не хотите использовать lasIndexOf или substr, то почему бы просто не взглянуть на строку в ее естественном состоянии (т.е. на массив)

String.prototype.endsWith = function(suffix) {
    if (this[this.length - 1] == suffix) return true;
    return false;
}

или как отдельная функция

function strEndsWith(str,suffix) {
    if (str[str.length - 1] == suffix) return true;
    return false;
}

Ответ 22

String.prototype.endWith = function (a) {
    var isExp = a.constructor.name === "RegExp",
    val = this;
    if (isExp === false) {
        a = escape(a);
        val = escape(val);
    } else
        a = a.toString().replace(/(^\/)|(\/$)/g, "");
    return eval("/" + a + "$/.test(val)");
}

// example
var str = "Hello";
alert(str.endWith("lo"));
alert(str.endWith(/l(o|a)/));

Ответ 23

все они являются очень полезными примерами. Добавление String.prototype.endsWith = function(str) поможет нам просто вызвать метод, чтобы проверить, заканчивается ли наша строка с ним или нет, также regexp также сделает это.

Я нашел лучшее решение, чем мое. Спасибо всем.

Ответ 24

Это основано на принятом ответе @charkit, разрешающем либо массив строк, либо строку, переданную в качестве аргумента.

if (typeof String.prototype.endsWith === 'undefined') {
    String.prototype.endsWith = function(suffix) {
        if (typeof suffix === 'String') {
            return this.indexOf(suffix, this.length - suffix.length) !== -1;
        }else if(suffix instanceof Array){
            return _.find(suffix, function(value){
                console.log(value, (this.indexOf(value, this.length - value.length) !== -1));
                return this.indexOf(value, this.length - value.length) !== -1;
            }, this);
        }
    };
}

Для этого требуется underscorejs - но, возможно, его можно настроить для удаления зависимостей подчеркивания.

Ответ 25

if(typeof String.prototype.endsWith !== "function") {
    /**
     * String.prototype.endsWith
     * Check if given string locate at the end of current string
     * @param {string} substring substring to locate in the current string.
     * @param {number=} position end the endsWith check at that position
     * @return {boolean}
     *
     * @edition ECMA-262 6th Edition, 15.5.4.23
     */
    String.prototype.endsWith = function(substring, position) {
        substring = String(substring);

        var subLen = substring.length | 0;

        if( !subLen )return true;//Empty string

        var strLen = this.length;

        if( position === void 0 )position = strLen;
        else position = position | 0;

        if( position < 1 )return false;

        var fromIndex = (strLen < position ? strLen : position) - subLen;

        return (fromIndex >= 0 || subLen === -fromIndex)
            && (
                position === 0
                // if position not at the and of the string, we can optimise search substring
                //  by checking first symbol of substring exists in search position in current string
                || this.charCodeAt(fromIndex) === substring.charCodeAt(0)//fast false
            )
            && this.indexOf(substring, fromIndex) === fromIndex
        ;
    };
}

Преимущества:

• Эта версия не просто повторно использует indexOf.
• Наибольшая производительность при длинных строках. Вот тест скорости http://jsperf.com/starts-ends-with/4
• Полностью совместим с спецификацией ecmascript. Он передает tests

Ответ 26

Не используйте регулярные выражения. Они медленны даже на быстрых языках. Просто напишите функцию, которая проверяет конец строки. Эта библиотека имеет приятные примеры: groundjs/util.js. Будьте осторожны, добавив функцию в String.prototype. В этом коде есть хорошие примеры того, как это сделать: groundjs/prototype.js В общем, это хорошая библиотека на уровне языка: groundjs Вы также можете взглянуть на lodash

Ответ 27

Для coffeescript

String::endsWith = (suffix) ->
  -1 != @indexOf suffix, @length - suffix.length

Ответ 28

7-летняя публика, но я не смог понять несколько лучших сообщений, потому что они сложны. Итак, я написал собственное решение:

function strEndsWith(str, endwith)
{
    var lastIndex = url.lastIndexOf(endsWith);
    var result = false;
    if (lastIndex > 0 && (lastIndex + "registerc".length) == url.length)
    {
        result = true;
    }
    return result;
}

Ответ 29

После того, как эти длинные ответы, я нашел этот фрагмент кода простым и понятным!

function end(str, target) {
  return str.substr(-target.length) == target;
}