insensitive - javascript string substring




Wie überprüft man, ob eine Zeichenfolge "StartsWith" eine andere Zeichenfolge? (12)

Wie würde ich das Äquivalent von C # String.StartsWith in JavaScript schreiben?

var haystack = 'hello world';
var needle = 'he';

//haystack.startsWith(needle) == true

Hinweis: Dies ist eine alte Frage, und ECMAScript 2015 (ES6) führte, wie in den Kommentaren erwähnt, die Methode .startsWith . Zum Zeitpunkt der Erstellung dieses Updates (2015) Browser-Unterstützung ist jedoch bei weitem nicht abgeschlossen .


Basierend auf den Antworten hier ist dies die Version, die ich jetzt benutze, da sie basierend auf JSPerf-Tests die beste Leistung zu liefern scheint (und soweit ich weiß, funktional vollständig ist).

if(typeof String.prototype.startsWith != 'function'){
    String.prototype.startsWith = function(str){
        if(str == null) return false;
        var i = str.length;
        if(this.length < i) return false;
        for(--i; (i >= 0) && (this[i] === str[i]); --i) continue;
        return i < 0;
    }
}

Dies basiert auf startsWith2 von hier: http://jsperf.com/startswith2/6 . Ich habe eine kleine Optimierung für eine kleine Leistungsverbesserung hinzugefügt und habe seither auch eine Überprüfung hinzugefügt, ob die Vergleichszeichenfolge null oder undefiniert ist, und sie wurde so konvertiert, dass sie mithilfe der Technik in der Antwort von CMS zum String-Prototyp hinzugefügt wird.

Beachten Sie, dass diese Implementierung nicht den Parameter "position" unterstützt, der auf dieser Mozilla Developer Network- Seite erwähnt wird, aber dies scheint ohnehin nicht Teil des ECMAScript-Vorschlags zu sein.


Beste Lösung:

function startsWith(str, word) {
    return str.lastIndexOf(word, 0) === 0;
}

startsWith("aaa", "a")
true
startsWith("aaa", "ab")
false
startsWith("abc", "abc")
true
startsWith("abc", "c")
false
startsWith("abc", "a")
true
startsWith("abc", "ba")
false
startsWith("abc", "ab")
true

Und hier ist Schluss Mit, wenn Sie das auch brauchen:

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

Für diejenigen, die es vorziehen, es in String zu prototypieren:

String.prototype.startsWith || (String.prototype.startsWith = function(word) {
    return this.lastIndexOf(word, 0) === 0;
});

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

Verwendung:

"abc".startsWith("ab")
true
"c".ensdWith("c") 
true

Die beste Lösung ist, keine Bibliotheksaufrufe mehr zu verwenden und nur zu erkennen, dass Sie mit zwei Arrays arbeiten. Eine manuelle Implementierung ist sowohl kurz als auch schneller als jede andere Lösung, die ich hier gesehen habe.

function startsWith2(str, prefix) {
    if (str.length < prefix.length)
        return false;
    for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
        continue;
    return i < 0;
}

Leistungsvergleiche (Erfolg und Misserfolg) finden Sie unter http://jsperf.com/startswith2/4 . (Stellen Sie sicher, dass Sie nach späteren Versionen suchen, die möglicherweise meine übertrumpfen.)


Eine weitere Alternative mit .lastIndexOf :

haystack.lastIndexOf(needle, 0) === 0

Dies sieht rückwärts durch haystack für ein Vorkommen von needle ab Index 0 haystack . Mit anderen Worten, es prüft nur, ob der haystack mit der needle beginnt.

Im Prinzip sollte dies Leistungsvorteile gegenüber anderen Ansätzen haben:

  • Es durchsucht nicht den gesamten haystack .
  • Es wird keine neue temporäre Zeichenfolge erstellt und dann sofort verworfen.

Ich habe gerade von dieser String-Bibliothek erfahren:

http://stringjs.com/

Fügen Sie die js-Datei ein und verwenden Sie dann die S Variable wie folgt:

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

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

npm install string

Dann wird es als S Variable benötigt:

var S = require('string');

Die Webseite hat auch Links zu alternativen String-Bibliotheken, wenn diese Ihnen nicht gefallen.


Ich habe mich kürzlich dieselbe Frage gestellt.
Es gibt mehrere mögliche Lösungen, hier sind 3 gültige:

  • s.indexOf(starter) === 0
  • s.substr(0,starter.length) === starter
  • s.lastIndexOf(starter, 0) === 0 (hinzugefügt nach der answer Mark Byers)
  • mit einer Schleife:

    function startsWith(s,starter) {
      for (var i = 0,cur_c; i < starter.length; i++) {
        cur_c = starter[i];
        if (s[i] !== starter[i]) {
          return false;
        }
      }
      return true;
    }
    

Ich bin nicht auf die letzte Lösung gestoßen, die eine Schleife benutzt.
Überraschenderweise übertrifft diese Lösung die ersten 3 um ein Vielfaches.
Hier ist der Jsperf-Test, den ich durchgeführt habe, um zu dieser Schlussfolgerung zu kommen: http://jsperf.com/startswith2/2

Frieden

ps: ecmascript 6 (harmony) führt eine native startsWith Methode für Strings ein.
Denken Sie nur daran, wie viel Zeit eingespart worden wäre, wenn Sie daran gedacht hätten, diese dringend benötigte Methode in die ursprüngliche Version aufzunehmen.

Aktualisieren

Wie Steve bemerkte (der erste Kommentar zu dieser Antwort), wird die obige benutzerdefinierte Funktion einen Fehler ausgeben, wenn das angegebene Präfix kürzer ist als die gesamte Zeichenfolge. Er hat das behoben und eine Loop-Optimierung hinzugefügt, die unter http://jsperf.com/startswith2/4 eingesehen werden kann.

Beachten Sie, dass es 2 Optimierungen von Schleifen gibt, die Steve miteinbezog, die erste der beiden zeigte eine bessere Leistung, daher werde ich diesen Code unten posten:

function startsWith2(str, prefix) {
  if (str.length < prefix.length)
    return false;
  for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
    continue;
  return i < 0;
}

Ich wollte nur meine Meinung dazu sagen.

Ich denke, wir können es einfach so benutzen:

var haystack = 'hello world';
var needle = 'he';

if (haystack.indexOf(needle) == 0) {
  // Code if string starts with this substring
}

Ohne eine .test , benutze einfach die .test Methode von .test :

/^He/.test('Hello world')

Um dies mit einer dynamischen Zeichenfolge anstelle einer fest codierten Zeichenfolge zu tun (vorausgesetzt, die Zeichenfolge enthält keine regulären Steuerzeichen):

new RegExp('^' + needle).test(haystack)

Sie sollten auschecken Gibt es eine RegExp.escape-Funktion in Javascript? Wenn die Möglichkeit besteht, dass Regexp-Steuerzeichen in der Zeichenfolge angezeigt werden.


Sie können die .startsWith -Methode von ECMAScript 6 verwenden, sie wird jedoch noch nicht von allen Browsern unterstützt . Sie sollten ein Shim / Polyfill verwenden, um es in Browsern hinzuzufügen, die es nicht unterstützen. Das Erstellen einer Implementierung, die allen in der Spezifikation angegebenen Details entspricht, ist ein wenig kompliziert und die in dieser Antwort definierte Version reicht nicht aus. Wenn du eine treue Unterlegscheibe willst, benutze entweder:

Sobald Sie die Methode geändert haben (oder wenn Sie nur Browser und JavaScript-Engines unterstützen, die bereits über diese Methode verfügen), können Sie sie wie folgt verwenden:

"Hello World!".startsWith("He"); // true

var haystack = "Hello world";
var prefix = 'orl';
haystack.startsWith(prefix); // false

Wenn Sie mit startsWith() und endsWith() , müssen Sie auf führende Leerzeichen achten. Hier ist ein komplettes Beispiel:

var str1 = " Your String Value Here.!! "; // Starts & ends with spaces    
if (str1.startsWith("Your")) { }  // returns FALSE due to the leading spaces…
if (str1.endsWith("Here.!!")) { } // returns FALSE due to trailing spaces…

var str2 = str1.trim(); // Removes all spaces (and other white-space) from start and end of `str1`.
if (str2.startsWith("Your")) { }  // returns TRUE
if (str2.endsWith("Here.!!")) { } // returns TRUE

data.substring(0, input.length) === input

var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
    return true;
else
    return false;






startswith