Frage endsWith in 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 endet #. Wie kann ich es überprüfen?

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

  2. Eine Lösung, die ich habe, ist, nehmen Sie die Länge der Zeichenfolge und das letzte Zeichen und überprüfen Sie es.

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


1014
2017-11-11 11:15


Ursprung


Antworten:


UPDATE (24. November 2015):

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


ORIGINAL ANTWORT:

Ich weiß, das ist eine ein Jahr alte Frage ... aber ich brauche das auch und ich brauche es, um browserübergreifend zu arbeiten, also ... die Antwort und die Kommentare von allen kombinieren und es ein wenig vereinfachen:

String.prototype.endsWith = function(suffix) {
    return this.indexOf(suffix, this.length - suffix.length) !== -1;
};
  • Erstellt keine Teilzeichenfolge
  • Verwendet natives indexOf Funktion für schnellste Ergebnisse
  • Überspringe unnötige Vergleiche mit dem zweiten Parameter von indexOf um vorwärts zu springen
  • Funktioniert im Internet Explorer
  • KEINE Regex-Komplikationen

Wenn Sie nicht möchten, dass die Prototypen der nativen Datenstruktur gefüllt werden, gibt es 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 bleiben und prüfen möchten, ob bereits eine Implementierung bereitgestellt wurde, einfach ein hinzufügen typeof check wie folgt:

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

1703
2018-03-30 19:40



/#$/.test(str)

funktioniert auf allen Browsern, benötigt kein Affe-Patching String, und erfordert nicht das Scannen der gesamten Zeichenfolge als lastIndexOf wenn es keine Übereinstimmung gibt.

Wenn Sie eine konstante Zeichenfolge mit Sonderzeichen für reguläre Ausdrücke wie z '$', dann können Sie Folgendes verwenden:

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

und dann kannst du es so benutzen

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

285
2018-03-24 20:32



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

82
2017-11-11 11:20



Komm schon, das ist richtig endsWith Implementierung:

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

verwenden lastIndexOf erstellt nur unnötige CPU-Schleifen, wenn keine Übereinstimmung vorhanden ist.


66
2017-09-27 08:34



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

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

Wenn Leistung für Sie wichtig ist, wäre es sinnvoll zu testen, ob lastIndexOf ist tatsächlich schneller als das Erstellen einer Teilzeichenfolge oder nicht. (Es kann gut von der JS-Engine abhängen, die Sie verwenden ...) Es kann im passenden Fall schneller sein und wenn die Zeichenkette klein ist - aber wenn die Zeichenkette riesig ist, muss sie sogar durch die ganze Sache zurückschauen obwohl es uns nicht wirklich interessiert :(

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


55
2017-11-11 11:58



Sehe nicht an mit slice Methode. Also ich lass es einfach hier:

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

23
2018-06-09 07:17



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

funktioniert nicht, wenn die ursprüngliche Zeichenfolgenlänge um eins kleiner ist als die Suchzeichenfolgenlänge und die Suchzeichenfolge nicht gefunden wird:

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

Eine mögliche Lösung ist

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

17
2018-03-04 15:58



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

Zusammenfassung

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

Syntax

str.endsWith(searchString [, position]);

Parameter

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

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

Beschreibung

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

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

Browser compatibility


13
2018-03-05 14:57



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

8
2017-10-17 10:55