String

Strings sind nützlich zum Speichern von Daten, die in Textform dargestellt werden können. Einige der meistgenutzten Operationen mit Strings sind das Überprüfen ihrer Länge, das Erstellen und Verbinden mit den + und += String-Operatoren, das Überprüfen auf das Vorhandensein oder den Standort von Teilstrings mit der Methode indexOf() oder das Extrahieren von Teilstrings mit der Methode substring().

Strings können als Primitive, aus String-Literalen oder als Objekte unter Verwendung des String()-Konstruktors erstellt werden:

const string1 = "A string primitive";
const string2 = 'Also a string primitive';
const string3 = `Yet another string primitive`;

const string4 = new String("A String object");

String-Primitiven und String-Objekte teilen sich viele Verhaltensweisen, weisen aber auch wichtige Unterschiede und Fallstricke auf. Siehe "String-Primitiven und String-Objekte" unten.

String-Literale können mit einfachen oder doppelten Anführungszeichen angegeben werden, die identisch behandelt werden, oder mit dem Backtick-Zeichen `. Diese letzte Form spezifiziert ein Template Literal: Mit dieser Form können Sie Ausdrücke interpolieren. Weitere Informationen zur Syntax von String-Literalen finden Sie in der lexikalischen Grammatik.

Es gibt zwei Möglichkeiten, auf ein individuelles Zeichen in einem String zuzugreifen. Die erste ist die Methode charAt(),

"cat".charAt(1); // gives value "a"

Die andere Möglichkeit besteht darin, den String als array-ähnliches Objekt zu behandeln, bei dem einzelne Zeichen einem numerischen Index entsprechen:

"cat"[1]; // gives value "a"

Bei der Verwendung der Klammernotation für den Zeichen-Zugriff wird der Versuch, diese Eigenschaften zu löschen oder ihnen einen Wert zuzuweisen, nicht erfolgreich sein. Die beteiligten Eigenschaften sind weder beschreibbar noch konfigurierbar. (Siehe Object.defineProperty() für weitere Informationen.)

Verwenden Sie die Kleiner-als und Größer-als Operatoren, um Strings zu vergleichen:

const a = "a";
const b = "b";
if (a < b) {
  // true
  console.log(`${a} is less than ${b}`);
} else if (a > b) {
  console.log(`${a} is greater than ${b}`);
} else {
  console.log(`${a} and ${b} are equal.`);
}

Beachten Sie, dass alle Vergleichsoperatoren, einschließlich === und ==, Strings groß-/kleinschreibungssensitiv vergleichen. Eine übliche Methode, um Strings ohne Berücksichtigung der Groß-/Kleinschreibung zu vergleichen, ist, beide in denselben Fall (groß oder klein) zu konvertieren, bevor sie verglichen werden.

function areEqualCaseInsensitive(str1, str2) {
  return str1.toUpperCase() === str2.toUpperCase();
}

Die Wahl, ob toUpperCase() oder toLowerCase() verwendet wird, ist meist willkürlich, und keine ist vollständig robust, wenn sie über das lateinische Alphabet hinaus erweitert wird. Zum Beispiel werden der deutsche Kleinbuchstabe ß und ss beide zu SS durch toUpperCase() transformiert, während der türkische Buchstabe ı fälschlicherweise als ungleich zu I durch toLowerCase() gemeldet würde, es sei denn, er verwendet speziell toLocaleLowerCase("tr").

const areEqualInUpperCase = (str1, str2) =>
  str1.toUpperCase() === str2.toUpperCase();
const areEqualInLowerCase = (str1, str2) =>
  str1.toLowerCase() === str2.toLowerCase();

areEqualInUpperCase("ß", "ss"); // true; should be false
areEqualInLowerCase("ı", "I"); // false; should be true

Eine lokale und robuste Lösung für das Testen auf Groß-/Kleinschreibungs-Unabhängigkeit ist, die Intl.Collator API oder die Methode localeCompare() des Strings zu verwenden – beide teilen die gleiche Schnittstelle – mit der sensitivity Option auf "accent" oder "base" gesetzt.

const areEqual = (str1, str2, locale = "en-US") =>
  str1.localeCompare(str2, locale, { sensitivity: "accent" }) === 0;

areEqual("ß", "ss", "de"); // false
areEqual("ı", "I", "tr"); // true

Die Methode localeCompare() ermöglicht den String-Vergleich in ähnlicher Weise wie strcmp() - sie ermöglicht das Sortieren von Strings in einer lokalen Weise.

Beachten Sie, dass JavaScript zwischen String-Objekten und primitiven Strings unterscheidet. (Dasselbe gilt für Boolean und Numbers)

String-Literale (bezeichnet durch doppelte oder einfache Anführungszeichen) und Strings, die von String-Aufrufen in einem non-konstruktiven Kontext zurückgegeben werden (also ohne Verwendung des new Schlüsselworts), sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Eigenschaftslookup ausgeführt werden soll, wird JavaScript den String-Primitiven automatisch umhüllen und die Methode auf dem Wrapper-Objekt aufrufen oder den Eigenschaftslookup darauf ausführen.

const strPrim = "foo"; // A literal is a string primitive
const strPrim2 = String(1); // Coerced into the string primitive "1"
const strPrim3 = String(true); // Coerced into the string primitive "true"
const strObj = new String(strPrim); // String with new returns a string wrapper object.

console.log(typeof strPrim); // "string"
console.log(typeof strPrim2); // "string"
console.log(typeof strPrim3); // "string"
console.log(typeof strObj); // "object"

String-Primitiven und String-Objekte geben auch verschiedene Ergebnisse bei der Verwendung von eval(). Primitiven, die an eval übergeben werden, werden als Quellcode behandelt; String-Objekte hingegen werden wie alle anderen Objekte behandelt, indem das Objekt zurückgegeben wird. Zum Beispiel:

const s1 = "2 + 2"; // creates a string primitive
const s2 = new String("2 + 2"); // creates a String object
console.log(eval(s1)); // returns the number 4
console.log(eval(s2)); // returns the string "2 + 2"

Aus diesen Gründen kann der Code fehlschlagen, wenn er auf String-Objekte trifft, wenn er stattdessen einen primitiven String erwartet, obwohl sich Autoren im Allgemeinen keine Sorgen über die Unterscheidung machen müssen.

Ein String-Objekt kann immer mit der Methode valueOf() in sein primitives Gegenstück konvertiert werden.

console.log(eval(s2.valueOf())); // returns the number 4

Viele eingebaute Operationen, die Strings erwarten, zwingen zuerst ihre Argumente zu Strings (was weitgehend der Grund dafür ist, dass String-Objekte sich ähnlich wie String-Primitiven verhalten). Der Vorgang kann wie folgt zusammengefasst werden:

• Strings werden unverändert zurückgegeben.
• undefined wird zu "undefined".
• null wird zu "null".
• true wird zu "true"; false wird zu "false".
• Zahlen werden mit dem gleichen Algorithmus wie toString(10) konvertiert.
• BigInts werden mit dem gleichen Algorithmus wie toString(10) konvertiert.
• Symbole werfen einen TypeError.
• Objekte werden zuerst in ein primitives Objekt umgewandelt, indem seine Methoden [Symbol.toPrimitive]() (mit "string" als Hinweis), toString() und valueOf() in dieser Reihenfolge aufgerufen werden. Das resultierende primitive Objekt wird dann in einen String konvertiert.

Es gibt mehrere Möglichkeiten, fast denselben Effekt in JavaScript zu erzielen.

• Template Literal: `${x}` führt genau die oben erklärten String-Konvertierungsschritte für den eingebetteten Ausdruck aus.
• Die String() Funktion: String(x) verwendet den gleichen Algorithmus zur Konvertierung von x, außer dass Symbole keinen TypeError werfen, sondern "Symbol(description)", wobei description die Beschreibung des Symbols ist.
• Die Verwendung des + Operators: "" + x zwingt seinen Operanden in ein primitives statt eines Strings, und hat für einige Objekte völlig andere Verhaltensweisen als die normale String-Konvertierung. Weitere Einzelheiten finden Sie auf der Referenzseite.

Abhängig von Ihrem Anwendungsfall möchten Sie möglicherweise `${x}` (um das eingebaute Verhalten nachzuahmen) oder String(x) (um Symbolwerte zu behandeln, ohne dass ein Fehler auftritt) verwenden, aber Sie sollten nicht "" + x verwenden.

Strings werden grundsätzlich als Sequenzen von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Codierung ist jede Code-Einheit exakt 16 Bits lang. Das bedeutet, dass maximal 2¹⁶, also 65536 mögliche Zeichen als einzelne UTF-16-Codeeinheiten darstellbar sind. Diese Zeichenmenge wird als Basic Multilingual Plane (BMP) bezeichnet und umfasst die häufigsten Zeichen wie die lateinischen, griechischen, kyrillischen Alphabete sowie viele ostasiatische Zeichen. Jede Codierungseinheit kann in einem String mit \u gefolgt von genau vier Hex-Ziffern geschrieben werden.

Jedoch ist der gesamte Unicode-Zeichensatz viel größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als Surrogate-Paare gespeichert, bei denen es sich um Paare von 16-Bit-Codierungseinheiten handelt, die ein einzelnes Zeichen darstellen. Um Mehrdeutigkeiten zu vermeiden, müssen die beiden Teile des Paares zwischen 0xD800 und 0xDFFF liegen, und diese Codeeinheiten werden nicht zum Codieren von Einzelcodeeinheit-Zeichen verwendet. (Genauer gesagt, haben führende Surrogate, auch High-Surrogate-Codeeinheiten genannt, Werte zwischen 0xD800 und 0xDBFF, während nachfolgende Surrogate, auch Low-Surrogate-Codeeinheiten genannt, Werte zwischen 0xDC00 und 0xDFFF aufweisen.) Jedes Unicode-Zeichen, das aus einer oder zwei UTF-16-Codierungseinheiten besteht, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx} geschrieben werden, wobei xxxxxx 1–6 Hex-Ziffern darstellt.

Ein "einsames Surrogat" ist eine 16-Bit-Codeeinheit, die eine der folgenden Beschreibungen erfüllt:

• Es liegt im Bereich 0xD800–0xDBFF, aber es ist die letzte Codeeinheit im String, oder die nächste Codeeinheit ist kein nachfolgendes Surrogat.
• Es liegt im Bereich 0xDC00–0xDFFF, aber es ist die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein führendes Surrogat.

Einsame Surrogate stellen kein Unicode-Zeichen dar. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt behandeln, da sie alle auf UTF-16-Codierungseinheiten basieren, sind alleinstehende Surrogate oft keine gültigen Werte, wenn sie mit anderen Systemen interagieren - zum Beispiel wird encodeURI() einen URIError für einsame Surrogate auslösen, da bei der URI-Codierung UTF-8-Codierung verwendet wird, die keine Codierung für einsame Surrogate hat. Strings, die keine einsamen Surrogate enthalten, werden als wohlgeformte Strings bezeichnet und sind sicher mit Funktionen zu verwenden, die nicht mit UTF-16 arbeiten (wie encodeURI() oder TextEncoder). Sie können überprüfen, ob ein String wohlgeformt ist mit der Methode isWellFormed(), oder einsame Surrogate mit der Methode toWellFormed() bereinigen.

Neben Unicode-Zeichen gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als Graphem-Cluster. Der häufigste Fall sind Emojis: Viele Emojis, die eine Reihe von Variationen aufweisen, werden tatsächlich durch mehrere Emojis gebildet, üblicherweise verbunden durch das <ZWJ> (U+200D)-Zeichen.

Sie müssen vorsichtig sein, auf welcher Ebene von Zeichen Sie iterieren. Zum Beispiel wird split("") nach UTF-16-Codierungseinheiten aufteilen und Surrogat-Paare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codierungseinheit. Andererseits iteriert [Symbol.iterator]() nach Unicode-Codepunkten. Das Iterieren durch Graphem-Cluster erfordert etwas benutzerdefinierten Code.

"😄".split(""); // ['\ud83d', '\ude04']; splits into two lone surrogates

// "Backhand Index Pointing Right: Dark Skin Tone"
[..."👉🏿"]; // ['👉', '🏿']
// splits into the basic "Backhand Index Pointing Right" emoji and
// the "Dark skin tone" emoji

// "Family: Man, Boy"
[..."👨‍👦"]; // [ '👨', '‍', '👦' ]
// splits into the "Man" and "Boy" emoji, joined by a ZWJ

// The United Nations flag
[..."🇺🇳"]; // [ '🇺', '🇳' ]
// splits into two "region indicator" letters "U" and "N".
// All flag emojis are formed by joining two region indicator letters

String()

Erstellt String-Objekte. Wenn als Funktion aufgerufen, gibt es primitive Werte des Typs String zurück.

String.fromCharCode()

Gibt einen String zurück, der aus der angegebenen Sequenz von Unicode-Werten erstellt wurde.

String.fromCodePoint()

Gibt einen String zurück, der aus der angegebenen Sequenz von Codepunkten erstellt wurde.

String.raw()

Gibt einen String zurück, der aus einem rohen Template-String erstellt wurde.

Diese Eigenschaften sind auf String.prototype definiert und werden von allen String-Instanzen geteilt.

String.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für String-Instanzen ist der Anfangswert der String-Konstruktor.

Diese Eigenschaften sind eigene Eigenschaften jeder String-Instanz.

length

Gibt die Länge des Strings wieder. Schreibgeschützt.

String.prototype.at()

Gibt das Zeichen (genau eine UTF-16-Codierungseinheit) am angegebenen Index zurück. Akzeptiert negative Ganzzahlen, die vom letzten String-Zeichen zurückzählen.

String.prototype.charAt()

Gibt das Zeichen (genau eine UTF-16-Codierungseinheit) an dem angegebenen Index zurück.

String.prototype.charCodeAt()

Gibt eine Zahl zurück, die den UTF-16-Codierungseinheit-Wert an dem gegebenen Index darstellt.

String.prototype.codePointAt()

Gibt eine nichtnegative Ganzzahlen-Zahl zurück, die den Codepunkt-Wert des UTF-16-codierten Codepunktes am angegebenen pos darstellt.

String.prototype.concat()

Kombiniert den Text von zwei (oder mehr) Strings und gibt einen neuen String zurück.

String.prototype.endsWith()

Bestimmt, ob ein String mit den Zeichen des Strings searchString endet.

String.prototype.includes()

Bestimmt, ob der aufrufende String searchString enthält.

String.prototype.indexOf()

Gibt den Index innerhalb dieses Strings der ersten Vorkommen von searchValue zurück, oder -1 wenn nicht gefunden.

String.prototype.isWellFormed()

Gibt einen Boolean zurück, der angibt, ob dieser String einsame Surrogate enthält.

String.prototype.lastIndexOf()

Gibt den Index innerhalb dieses Strings der letzten Vorkommen von searchValue zurück, oder -1 wenn nicht gefunden.

String.prototype.localeCompare()

Gibt eine Zahl zurück, die angibt, ob der Referenz-String compareString vor, nach oder äquivalent zu dem gegebenen String in Sortierreihenfolge steht.

String.prototype.match()

Wird verwendet, um mit einem regulären Ausdruck regexp einen String abzugleichen.

String.prototype.matchAll()

Gibt einen Iterator für alle Übereinstimmungen von regexp zurück.

String.prototype.normalize()

Gibt die Unicode-Normalisierungsform des aufrufenden Stringwerts zurück.

String.prototype.padEnd()

Füllt den aktuellen String vom Ende mit einem gegebenen String auf und gibt einen neuen String der Länge targetLength zurück.

String.prototype.padStart()

Füllt den aktuellen String vom Anfang mit einem gegebenen String auf und gibt einen neuen String der Länge targetLength zurück.

String.prototype.repeat()

Gibt einen String zurück, der aus den Elementen des Objekts besteht, die count-Mal wiederholt werden.

String.prototype.replace()

Wird verwendet, um Vorkommen von searchFor durch replaceWith zu ersetzen. searchFor kann ein String oder ein regulärer Ausdruck sein, und replaceWith kann ein String oder eine Funktion sein.

String.prototype.replaceAll()

Wird verwendet, um alle Vorkommen von searchFor durch replaceWith zu ersetzen. searchFor kann ein String oder ein regulärer Ausdruck sein, und replaceWith kann ein String oder eine Funktion sein.

String.prototype.search()

Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck regexp und dem aufrufenden String.

String.prototype.slice()

Extrahiert einen Abschnitt eines Strings und gibt einen neuen String zurück.

String.prototype.split()

Gibt ein Array von Strings zurück, das durch Aufteilen des aufrufenden Strings an den Vorkommen des Teilstrings sep erzeugt wird.

String.prototype.startsWith()

Bestimmt, ob der aufrufende String mit den Zeichen des Strings searchString beginnt.

String.prototype.substr() Veraltet

Gibt einen Teil des Strings zurück, der am angegebenen Index beginnt und sich für eine angegebene Anzahl von Zeichen danach erstreckt.

String.prototype.substring()

Gibt einen neuen String zurück, der Zeichen des aufrufenden Strings von (oder zwischen) dem angegebenen Index (oder den Indizes) enthält.

String.prototype.toLocaleLowerCase()

Die Zeichen innerhalb eines Strings werden respektvoll zur aktuellen Lokalisierung in Kleinbuchstaben umgewandelt.

Für die meisten Sprachen wird dies dasselbe zurückgeben wie toLowerCase().

String.prototype.toLocaleUpperCase()

Die Zeichen innerhalb eines Strings werden respektvoll zur aktuellen Lokalisierung in Großbuchstaben umgewandelt.

Für die meisten Sprachen wird dies dasselbe zurückgeben wie toUpperCase().

String.prototype.toLowerCase()

Gibt den aufrufenden Stringwert in Kleinbuchstaben umgewandelt zurück.

String.prototype.toString()

Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

String.prototype.toUpperCase()

Gibt den aufrufenden Stringwert in Großbuchstaben umgewandelt zurück.

String.prototype.toWellFormed()

Gibt einen String zurück, bei dem alle einsamen Surrogate dieses Strings durch das Unicode-Ersatzzeichen U+FFFD ersetzt werden.

String.prototype.trim()

Entfernt Leerzeichen vom Anfang und Ende des Strings.

String.prototype.trimEnd()

Entfernt Leerzeichen vom Ende des Strings.

String.prototype.trimStart()

Entfernt Leerzeichen vom Anfang des Strings.

String.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurück. Überschreibt die Methode Object.prototype.valueOf().

String.prototype[Symbol.iterator]()

Gibt ein neues Iterator-Objekt zurück, das über die Codepunkte eines String-Werts iteriert, wobei jeder Codepunkt als String-Wert zurückgegeben wird.

String.prototype.anchor() Veraltet

<a name="name"> (Hypertext-Ziel)

String.prototype.big() Veraltet

<big>

String.prototype.blink() Veraltet

<blink>

String.prototype.bold() Veraltet

<b>

String.prototype.fixed() Veraltet

<tt>

String.prototype.fontcolor() Veraltet

<font color="color">

String.prototype.fontsize() Veraltet

<font size="size">

String.prototype.italics() Veraltet

<i>

String.prototype.link() Veraltet

<a href="url"> (Link zu URL)

String.prototype.small() Veraltet

<small>

String.prototype.strike() Veraltet

<strike>

String.prototype.sub() Veraltet

<sub>

String.prototype.sup() Veraltet

<sup>

Beachten Sie, dass diese Methoden nicht überprüfen, ob der String selbst HTML-Tags enthält, sodass es möglich ist, ungültiges HTML zu erzeugen:

"</b>".bold(); // <b></b></b>

Das einzige Escaping, das sie durchführen, ist das Ersetzen von " im Attributwert (für anchor(), fontcolor(), fontsize(), und link()) durch ".

"foo".anchor('"Hello"'); // <a name="&quot;Hello&quot;">foo</a>

Die String() Funktion ist eine zuverlässigere Methode zur Konvertierung von Werten in Strings als das Aufrufen der toString() Methode des Werts, da die erstere auch auf null und undefined funktioniert. Zum Beispiel:

// You cannot access properties on null or undefined

const nullVar = null;
nullVar.toString(); // TypeError: Cannot read properties of null
String(nullVar); // "null"

const undefinedVar = undefined;
undefinedVar.toString(); // TypeError: Cannot read properties of undefined
String(undefinedVar); // "undefined"

• Leitfaden zu Nummern und Strings
• RegExp