закінчується в JavaScript

Як я можу перевірити, чи рядок закінчується певним символом у JavaScript?

Приклад: У мене є рядок

var str = "mystring#";

Я хочу знати, чи закінчується цей рядок #. Як я можу це перевірити?

1. Чи існує endsWith()метод у JavaScript?

2. Одне з моїх рішень - взяти довжину рядка і отримати останній символ і перевірити його.

Це найкращий спосіб чи є інший спосіб?

ОНОВЛЕННЯ (24 листопада 2015 р.):

Ця відповідь спочатку розміщена у 2010 році (SIX років тому), тому, будь ласка, врахуйте ці проникливі коментарі:

• Shauna - оновлення для Googlers - схоже, ECMA6 додає цю функцію. У статті MDN також показаний полів. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ 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 додає кінціWith, то справа суперечлива. :-)

ОРИГІНАЛЬНИЙ ВІДПОВІДЬ:

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

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

EDIT: Як зазначає @hamish у коментарях, якщо ви хочете помилитися з безпечної сторони і перевірити, чи реалізація вже надана, ви можете просто додати typeofчек так:

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

/#$/.test(str)

буде працювати у всіх браузерах, не потребує виправлення мавп Stringта не потребує сканування всієї рядка, як lastIndexOfце робиться, коли немає відповідності.

Якщо ви хочете відповідати постійній рядку, яка може містити спеціальні символи регулярного виразу, наприклад '$', ви можете використовувати наступне:

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

і тоді ви можете використовувати це так

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

1. На жаль ні.
2. if( "mystring#".substr(-1) === "#" ) {}

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

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

за допомогою lastIndexOfпросто створює непотрібні петлі процесора, якщо немає відповідності.

Ця версія уникає створення підрядків і не використовує регулярні вирази (деякі відповіді на регулярні висловлювання спрацьовують; інші зламані):

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

Якщо для вас важлива продуктивність, варто перевірити, чи є lastIndexOf дійсно швидше, ніж створити підрядку чи ні. (Це може залежати від двигуна JS, який ви використовуєте ...) Це може бути швидше у відповідній справі, і коли рядок невеликий - але коли рядок є величезним, йому потрібно оглянути все це навіть хоча нас насправді не хвилює :(

Перевірка одного символу, пошук довжини, а потім використання charAt, мабуть, найкращий спосіб.

Не бачив відповідності з sliceметодом. Тож я просто залишаю його тут:

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

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

не працює в тому випадку, коли початкова довжина рядка на одну меншу довжини рядка пошуку і рядок пошуку не знайдено:

lastIndexOf повертає -1, тоді ви додаєте довжину рядка пошуку і вам залишається початкова довжина рядка.

Можливе виправлення

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

Від 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

Технічні умови

6-е видання специфікації мови ECMAScript (ECMA-262)

Сумісність браузера

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

- Або -

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

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? давай ...

Ще одна швидка альтернатива, яка працювала як шарм для мене, використовуючи регулярний вираз:

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

Якщо ви використовуєте lodash :

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

Якщо лодаш не використовується, ви можете позичити його джерело .

Я щойно дізнався про цю бібліотеку рядків:

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

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

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

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

Минуло багато років на це питання. Дозвольте додати важливе оновлення для користувачів, які хочуть використати відповідь на найбільш голосовані чакрити.

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

Перегляньте це тут: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Отже, настійно рекомендується додати перевірку на наявність власної реалізації, як зазначено у відповіді.

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

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

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

@ chakrit прийнята відповідь - це надійний спосіб зробити це самостійно. Якщо ви шукаєте пакетне рішення, рекомендую поглянути на underscore.string , як вказував @mlunoe. Використовуючи underscore.string, кодом буде:

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

якщо ви не хочете використовувати 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.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)/));

Зрештою, довгі підрахунки відповідей, я знайшов цей фрагмент коду простим і зрозумілим!

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

Це реалізація цілейWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

Це реалізація endsWith:

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

Це ґрунтується на прийнятій відповіді @ 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);
        }
    };
}

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

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

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

Я знайшов краще рішення, ніж моє. Дякую всім.

Для кофескрипту

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