Wie prüft man, ob eine Zeichenkette "mit" einer anderen Zeichenkette beginnt?

Question

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

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

haystack.startsWith(needle) == true

Hinweis: Dies ist eine alte Frage, und wie in den Kommentaren erwähnt, führte ECMAScript 2015 (ES6) die .startsWith Methode. Zum Zeitpunkt der Erstellung dieser Aktualisierung (2015) Die Browserunterstützung ist noch lange nicht vollständig .

Answer 1

Ich wollte nur meine Meinung dazu sagen.

Ich denke, wir können das einfach so verwenden:

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

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

Answer 2

Hier ist eine kleine Verbesserung der Lösung von CMS:

if(!String.prototype.startsWith){
    String.prototype.startsWith = function (str) {
        return !this.indexOf(str);
    }
}

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

 var data = "Hello world";
 var input = 'He';
 data.startsWith(input); // true

Prüfung, ob die Funktion bereits existiert, falls ein zukünftiger Browser sie in nativem Code implementiert oder ob sie von einer anderen Bibliothek implementiert wird. Zum Beispiel implementiert die Prototype Library diese Funktion bereits.

Verwendung von ! ist etwas schneller und prägnanter als === 0 wenn auch nicht so lesenswert.

Answer 3

Besuchen Sie auch unterstrich.string.js . Es enthält eine Reihe nützlicher Methoden zum Testen und Manipulieren von Zeichenketten, darunter eine startsWith Methode. Aus den Unterlagen:

startsWith _.startsWith(string, starts)

Diese Methode prüft, ob string beginnt mit starts .

_("image.gif").startsWith("image")
=> true

Answer 4

Diese Frage habe ich mir kürzlich auch gestellt.
Es gibt mehrere mögliche Lösungen, hier sind 3 davon gültig:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0 (hinzugefügt, nachdem ich Mark Byers' Antwort )

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

Die letzte Lösung, bei der eine Schleife verwendet wird, ist mir noch nicht begegnet.
Ü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 gelangen: http://jsperf.com/startswith2/2

Frieden

ps: ecmascript 6 (harmony) führt eine native startsWith Methode für Zeichenketten.
Man denke nur daran, wie viel Zeit man hätte sparen können, wenn man daran gedacht hätte, diese dringend benötigte Methode bereits in die ursprüngliche Version aufzunehmen.

Update

Wie Steve hervorhob (der erste Kommentar zu dieser Antwort), wird die obige benutzerdefinierte Funktion einen Fehler auslösen, wenn die angegebene Präfix kürzer ist als die gesamte Zeichenkette. Er hat das behoben und eine Schleifenoptimierung hinzugefügt, die unter folgender Adresse eingesehen werden kann http://jsperf.com/startswith2/4 .

Beachten Sie, dass es 2 Schleifenoptimierungen gibt, die Steve eingebaut hat. Die erste der beiden hat eine bessere Leistung gezeigt, daher werde ich diesen Code weiter unten veröffentlichen:

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

Answer 5

Da dies so populär ist, denke ich, dass es sich lohnt, darauf hinzuweisen, dass es eine Implementierung für diese Methode in ECMA 6 gibt und dass man in Vorbereitung darauf das "offizielle" Polyfill verwenden sollte, um zukünftige Probleme und Risse zu vermeiden.

Glücklicherweise haben die Experten von Mozilla einen solchen zur Verfügung gestellt:

https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith

if (!String.prototype.startsWith) {
    String.prototype.startsWith = function(searchString, position) {
        position = position || 0;
        return this.indexOf(searchString, position) === position;
    };
}

Bitte beachten Sie, dass dies den Vorteil hat, dass es beim Übergang zu ECMA 6 einfach ignoriert wird.