endsWith w JavaScript

/#$/.test(str)

Będzie działać na wszystkich przeglądarkach, nie wymaga łatania małp String i nie wymaga skanowania całego ciągu znaków, jak to robi lastIndexOf, gdy nie ma dopasowania.

Jeśli chcesz dopasować stały ciąg znaków, który może zawierać specjalne znaki wyrażenia regularnego, takie jak '$', możesz użyć następującego wzoru:

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

I wtedy możesz go użyć w ten sposób

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

Niestety nie.
1. if( "mystring#".substr(-1) === "#" ) {}

Dalej, to jest poprawna endsWith implementacja:

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

Użycie lastIndexOf po prostu tworzy niepotrzebne pętle procesora, jeśli nie ma dopasowania.

Ta wersja unika tworzenia podłańcucha i nie używa wyrażeń regularnych (niektóre odpowiedzi regex tutaj będą działać, inne są uszkodzone):

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

Jeśli wydajność jest dla ciebie ważna, warto sprawdzić, czy lastIndexOf jest rzeczywiście szybsza niż tworzenie podłańcucha, czy nie. (Może to zależeć od używanego silnika JS...) Może być szybszy w przypadku dopasowania, a gdy ciąg jest mały - ale gdy ciąg jest ogromny, musi spojrzeć wstecz przez całość nawet choć nas to nie obchodzi: (

Do sprawdzania pojedynczego znaku, znalezienie długości, a następnie użycie {[2] } jest prawdopodobnie najlepszym sposobem.

Nie widziałem apporach z slice metodą. Więc zostawiam to tutaj:

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

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

Nie działa w przypadku, gdy oryginalna długość ciągu jest o jedną mniejszą od długości szukanego ciągu i szukany ciąg nie został znaleziony:

Lastindexof zwraca -1, następnie dodajesz długość szukanego ciągu i zostaje Ci oryginalna Długość łańcucha.

Możliwa poprawka to

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

Od developer.mozilla.org String.prototyp.endsWith()

Podsumowanie

Metoda endsWith() określa, czy łańcuch znaków kończy się znakami innego łańcucha, zwracając odpowiednio true lub false.

Składnia

str.endsWith(searchString [, position]);

Parametry

• SearchString : Znaki, które mają być wyszukane na końcu tego ciągu.

• Pozycja : Szukaj w tym łańcuchu tak, jakby ten łańcuch był tylko tym long; domyślnie rzeczywista długość tego łańcucha jest zaciśnięta w zakresie ustalonym przez długość tego łańcucha.

Opis

Ta metoda pozwala określić, czy łańcuch znaków kończy się innym łańcuchem.

Przykłady

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

Dane techniczne

Specyfikacja języka ECMAScript 6th Edition (ECMA-262)

Zgodność przeglądarki

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

-- lub --

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

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

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

Mam nadzieję, że to pomoże

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…

Tradycyjny sposób

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

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

Nie wiem jak ty, ale:

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

Dlaczego wyrażenia regularne? Po co mieszać z prototypem? substr? chodź...

Kolejna szybka alternatywa, która działała jak urok dla mnie, używając regex:

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

Jeśli używasz lodash :

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

Właśnie dowiedziałem się o tej bibliotece ciągów:

Http://stringjs.com/

Dołącz plik js, a następnie użyj zmiennej S w następujący sposób:

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

Można go również użyć w NodeJS, instalując go:

npm install string

Następnie wymagając jej jako zmiennej S:

var S = require('string');

Strona zawiera również linki do alternatywnych bibliotek ciągów, jeśli ta nie podoba ci się.

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

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

  return false;
}

Tak wiele rzeczy dla tak małego problemu, wystarczy użyć tego wyrażenia regularnego

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

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

To było wiele lat na to pytanie. Dodam ważną aktualizację dla użytkowników, którzy chcą skorzystać z najczęściej głosowanych odpowiedzi.

Funkcje 'endsWith' są już dodane do JavaScript jako część ECMAScript 6 (experimental technology)

Poleć tutaj: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Dlatego zaleca się dodanie sprawdzania istnienia natywnej implementacji, jak wspomniano w odpowiedź.

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

Sposobem na przyszłościowe zabezpieczenie i / lub zapobieganie nadpisywaniu istniejącego prototypu byłoby sprawdzenie, czy został on już dodany do prototypu Łańcuchowego. Oto moje podejście do nie-regex wysoko oceniona wersja.

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

@ Chakrit ' s accepted answer is a solid way to do it yourself. Jeśli jednak szukasz spakowanego rozwiązania, polecam zajrzeć do podkreślenia .string , Jak zauważył @mlunoe. Używanie podkreślenia.string, kod będzie:

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

Po tych wszystkich długich odpowiedziach, znalazłem ten kawałek kodu prosty i łatwy do zrozumienia!

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

Jeśli nie chcesz używać lasIndexOf lub substr, to dlaczego nie spojrzeć na łańcuch w jego naturalnym stanie (np. tablica)

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

Lub jako samodzielna Funkcja

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

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

Jest to implementacja endsWith:

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

Opiera się to na zaakceptowanej odpowiedzi @ charkit, pozwalającej na przekazanie tablicy łańcuchów lub łańcuchów jako argumentu.

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

Wymaga to podkreślenia-ale prawdopodobnie można go dostosować, aby usunąć zależność podkreślenia.

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

Korzyści:

• Ta wersja nie jest tylko ponownym użyciem indexOf.
• Najlepszy występ na długich strunach. Oto Test prędkości http://jsperf.com/starts-ends-with/4
• W Pełni kompatybilny ze specyfikacją ecmascript. Przechodzi testy

Nie używaj wyrażeń regularnych. Są powolne nawet w szybkich językach. Wystarczy napisać funkcję, która sprawdza koniec łańcucha znaków. Ta Biblioteka ma ładne przykłady: groundjs / util.js . Uważaj na dodawanie funkcji do ciągu znaków.prototyp. Ten kod ma ładne przykłady jak to zrobić: groundjs / prototype.js Ogólnie rzecz biorąc, jest to ładna biblioteka na poziomie językowym: groundjs Możesz również spojrzeć na lodash

Wszystkie z nich są bardzo przydatnymi przykładami. Dodanie String.prototype.endsWith = function(str) pomoże nam po prostu wywołać metodę, aby sprawdzić, czy nasz łańcuch znaków kończy się na niej, czy nie, również regexp to zrobi.

Dla coffeescript

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