EndWith в JavaScript

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

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

-- Или же --

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

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

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

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

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

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

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

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

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

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

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

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

/#$/.test(str)

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

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

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

а затем вы можете использовать это так

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

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

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

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

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

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

• Шона -

Update for Googlers - Looks like ECMA6 adds this function. The MDN article also shows a polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• T.J. Краудер -

Creating substrings isn't expensive on modern browsers; it may well have been in 2010 when this answer was posted. These days, the simple this.substr(-suffix.length) === suffix approach is fastest on Chrome, the same on IE11 as indexOf, and only 4% slower (fergetaboutit territory) on Firefox: jsperf.com/endswith-stackoverflow/14 And faster across the board when the result is false: jsperf.com/endswith-stackoverflow-when-falseOf course, with ES6 adding endsWith, the point is moot. :-)

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

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

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;
    };
}

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

если вы не хотите использовать 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;
}

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

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

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)/));

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;
}

Не знаю как вы, но:

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

Почему именно регулярные выражения? Зачем возиться с прототипом? substr? да брось...

Это основано на принятом ответе @ 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.info(value, (this.indexOf(value, this.length - value.length) !== -1));
                return this.indexOf(value, this.length - value.length) !== -1;
            }, this);
        }
    };
}

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

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. Он проходит тесты

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

С сайта developer.mozilla.org String.prototype.endsWith ()

Резюме

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

Синтаксис

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)

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

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

http://stringjs.com/

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

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

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

npm install string

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

var S = require('string');

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

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

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

  return false;
}

Для coffeescript

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Не увидел подхода с методом slice. Так что я просто оставлю это здесь:

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

Пост 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;
}

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

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

Это реализация endsWith:

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

Это реализация endWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }