endet mit JavaScript

Wie kann ich überprüfen, ob eine Zeichenfolge in JavaScript mit einem bestimmten Zeichen endet?

Beispiel: Ich habe eine Zeichenfolge

var str = "mystring#";

Ich möchte wissen, ob diese Zeichenfolge mit endet #. Wie kann ich das überprüfen?

1. Gibt es eine endsWith()Methode in JavaScript?

2. Eine Lösung, die ich habe, besteht darin, die Länge der Zeichenfolge zu nehmen, das letzte Zeichen zu erhalten und es zu überprüfen.

Ist das der beste Weg oder gibt es einen anderen Weg?

UPDATE (24. November 2015):

Diese Antwort wurde ursprünglich im Jahr 2010 (vor sechs Jahren) veröffentlicht. Bitte beachten Sie diese aufschlussreichen Kommentare:

• Shauna - Update für Googler - ECMA6 fügt diese Funktion hinzu. Der MDN-Artikel zeigt auch eine Polyfüllung. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder - Das Erstellen von Teilzeichenfolgen ist in modernen Browsern nicht teuer. Möglicherweise war es 2010, als diese Antwort veröffentlicht wurde. this.substr(-suffix.length) === suffixHeutzutage ist der einfache Ansatz in Chrome am schnellsten, in IE11 genauso wie in indexOf und in Firefox nur 4% langsamer (Fergetaboutit-Gebiet): jsperf.com/endswith-stackoverflow/14 Und auf ganzer Linie schneller, wenn das Ergebnis falsch ist: jsperf.com/endswith-stackoverflow-when-false Natürlich ist der Punkt mit ES6, der Enden hinzufügt, umstritten. :-)

URSPRÜNGLICHE ANTWORT:

Ich weiß, dass dies eine einjährige Frage ist ... aber ich brauche sie auch und sie muss browserübergreifend funktionieren, also ... die Antworten und Kommentare aller kombinieren und ein wenig vereinfachen:

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

• Erstellt keinen Teilstring
• Verwendet die native indexOfFunktion für schnellste Ergebnisse
• Überspringen Sie unnötige Vergleiche mit dem zweiten Parameter von indexOf, um fortzufahren
• Funktioniert im Internet Explorer
• KEINE Regex-Komplikationen

Wenn Sie es nicht mögen, Dinge in die Prototypen der nativen Datenstruktur zu stopfen, finden Sie hier eine eigenständige Version:

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

BEARBEITEN: Wie von @hamish in den Kommentaren erwähnt, können Sie, wenn Sie auf der sicheren Seite irren und prüfen möchten, ob bereits eine Implementierung bereitgestellt wurde, einfach eine typeofPrüfung wie folgt hinzufügen :

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

/#$/.test(str)

funktioniert in allen Browsern, erfordert kein Affen-Patching Stringund erfordert nicht das Scannen der gesamten Zeichenfolge, wie dies der lastIndexOfFall ist, wenn keine Übereinstimmung vorliegt.

Wenn Sie mit einer konstanten Zeichenfolge übereinstimmen möchten, die möglicherweise Sonderzeichen für reguläre Ausdrücke enthält, z. B. '$', können Sie Folgendes verwenden:

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

und dann können Sie es so verwenden

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

1. Leider nicht.
2. if( "mystring#".substr(-1) === "#" ) {}

Komm schon, das ist die richtige endsWithImplementierung:

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

Die Verwendung von lastIndexOferzeugt nur unnötige CPU-Schleifen, wenn keine Übereinstimmung vorliegt.

Diese Version vermeidet das Erstellen eines Teilstrings und verwendet keine regulären Ausdrücke (einige Regex-Antworten hier funktionieren; andere sind fehlerhaft):

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

Wenn Ihnen die Leistung wichtig ist, sollten Sie testen, ob sie lastIndexOftatsächlich schneller ist als das Erstellen eines Teilstrings. (Es kann durchaus von der JS-Engine abhängen, die Sie verwenden ...) Im passenden Fall kann es durchaus schneller sein, und wenn die Zeichenfolge klein ist - aber wenn die Zeichenfolge groß ist, muss sie sogar das Ganze noch einmal durchsehen obwohl es uns eigentlich egal ist :(

Um ein einzelnes Zeichen zu überprüfen, charAtist es wahrscheinlich der beste Weg , die Länge zu finden und dann zu verwenden .

Ansatz mit sliceMethode nicht gesehen. Also lasse ich es einfach hier:

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

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

funktioniert nicht in dem Fall, in dem die ursprüngliche Zeichenfolgenlänge um eins kleiner als die Länge der Suchzeichenfolge ist und die Suchzeichenfolge nicht gefunden wird:

lastIndexOf gibt -1 zurück, dann fügen Sie die Länge der Suchzeichenfolge hinzu und die Länge der ursprünglichen Zeichenfolge bleibt erhalten.

Eine mögliche Lösung ist

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

Von developer.mozilla.org String.prototype.endsWith ()

Zusammenfassung

Die endsWith()Methode bestimmt, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge endet, und gibt je nach Bedarf true oder false zurück.

Syntax

str.endsWith(searchString [, position]);

Parameter

• searchString : Die Zeichen, nach denen am Ende dieser Zeichenfolge gesucht werden soll.

• Position : Suchen Sie in dieser Zeichenfolge, als wäre diese Zeichenfolge nur so lang. Der Standardwert ist die tatsächliche Länge dieser Zeichenfolge, die innerhalb des durch die Länge dieser Zeichenfolge festgelegten Bereichs geklemmt wird.

Beschreibung

Mit dieser Methode können Sie bestimmen, ob eine Zeichenfolge mit einer anderen Zeichenfolge endet oder nicht.

Beispiele

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

Spezifikationen

ECMAScript-Sprachspezifikation 6. Ausgabe (ECMA-262)

Browser-Kompatibilität

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

-- Oder --

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

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

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

ich hoffe das hilft

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…

der traditionelle Weg

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

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

Ich weiß nichts über dich, aber:

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

Warum reguläre Ausdrücke? Warum mit dem Prototyp herumspielen? substr? Komm schon...

Nur eine weitere schnelle Alternative, die mit Regex wie ein Zauber für mich funktioniert hat:

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

Wenn Sie lodash verwenden :

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

Wenn Sie lodash nicht verwenden, können Sie es von seiner Quelle ausleihen .

Ich habe gerade von dieser String-Bibliothek erfahren:

http://stringjs.com/

Fügen Sie die js-Datei ein und verwenden Sie die SVariable wie folgt :

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

Es kann auch in NodeJS verwendet werden, indem es installiert wird:

npm install string

Dann benötigen Sie es als SVariable:

var S = require('string');

Die Webseite enthält auch Links zu alternativen Zeichenfolgenbibliotheken, falls Sie dies nicht möchten.

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

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

  return false;
}

So viele Dinge für ein so kleines Problem, verwenden Sie einfach diesen regulären Ausdruck

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

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

Es ist viele Jahre her für diese Frage. Lassen Sie mich ein wichtiges Update für die Benutzer hinzufügen, die die Antwort des am meisten bewerteten Chakrits verwenden möchten.

Die Funktionen 'Enden mit' wurden bereits als Teil von ECMAScript 6 (experimentelle Technologie) zu JavaScript hinzugefügt.

Verweisen Sie hier: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Daher wird dringend empfohlen, die in der Antwort erwähnte Überprüfung auf das Vorhandensein einer nativen Implementierung hinzuzufügen.

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

Eine Möglichkeit zur Zukunftssicherung und / oder zum Verhindern des Überschreibens eines vorhandenen Prototyps wäre eine Testprüfung, um festzustellen, ob dieser bereits zum String-Prototyp hinzugefügt wurde. Hier ist meine Sicht auf die hoch bewertete Version ohne Regex.

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

Die akzeptierte Antwort von @ chakrit ist eine solide Möglichkeit, dies selbst zu tun. Wenn Sie jedoch nach einer Paketlösung suchen, empfehlen wir Ihnen, einen Blick auf underscore.string zu werfen, wie @mlunoe hervorhob. Bei Verwendung von underscore.string lautet der Code:

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

Wenn Sie lasIndexOf oder substr nicht verwenden möchten, sehen Sie sich den String einfach in seinem natürlichen Zustand an (z. B. ein Array).

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

oder als eigenständige Funktion

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

Nach all den langen Antworten fand ich diesen Code einfach und leicht zu verstehen!

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

Dies ist die Implementierung von EndsWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

Dies ist die Implementierung von endsWith:

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

Dies baut auf der akzeptierten Antwort von @ charkit auf, sodass entweder ein Array von Zeichenfolgen oder eine Zeichenfolge als Argument übergeben werden kann.

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

Dies erfordert Unterstriche - kann aber wahrscheinlich angepasst werden, um die Unterstrichabhängigkeit zu entfernen.

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

Leistungen:

• Diese Version verwendet indexOf nicht nur wieder.
• Größte Leistung auf langen Saiten. Hier ist ein Geschwindigkeitstest http://jsperf.com/starts-ends-with/4
• Voll kompatibel mit der Ecmascript-Spezifikation. Es besteht die Tests

Verwenden Sie keine regulären Ausdrücke. Sie sind selbst in schnellen Sprachen langsam. Schreiben Sie einfach eine Funktion, die das Ende einer Zeichenfolge überprüft. Diese Bibliothek hat schöne Beispiele: groundjs / util.js . Seien Sie vorsichtig, wenn Sie String.prototype eine Funktion hinzufügen. Dieser Code enthält nette Beispiele dafür: groundjs / prototype.js Im Allgemeinen ist dies eine nette Bibliothek auf Sprachebene : groundjs Sie können sich auch lodash ansehen

Alle von ihnen sind sehr nützliche Beispiele. HinzufügenString.prototype.endsWith = function(str) hilft uns, die Methode einfach aufzurufen, um zu überprüfen, ob unsere Zeichenfolge damit endet oder nicht. Nun, Regexp wird es auch tun.

Ich habe eine bessere Lösung gefunden als meine. Vielen Dank an alle.

Für Coffeescript

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