String

Strings sind nützlich, um Daten zu speichern, die in Textform dargestellt werden können. Zu den am häufigsten verwendeten Operationen an Strings gehören das Überprüfen ihrer Länge, das Erstellen und Verbinden mit den + und += Zeichenoperatoren, die Überprüfung auf das Vorhandensein oder die Position 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 viele Verhaltensweisen, weisen jedoch andere wichtige Unterschiede und Vorbehalte auf. Siehe "String-Primitiven und String-Objekte" unten.

String-Literale können mit einfachen oder doppelten Anführungszeichen angegeben werden, die gleich behandelt werden, oder unter Verwendung des Backticks `. 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 einzelnes Zeichen in einem String zuzugreifen. Die erste ist die charAt()-Methode:

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

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

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

Wenn Sie die Klammernotation für den Zeichen-Zugriff verwenden, wird es nicht gelingen, diesen Eigenschaften einen Wert zu löschen oder zuzuweisen. Die beteiligten Eigenschaften sind weder beschreibbar noch konfigurierbar. (Siehe Object.defineProperty() für weitere Informationen.)

Verwenden Sie die Größer- und Kleiner-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 case-sensitiv vergleichen. Eine übliche Methode, um Strings case-insensitiv zu vergleichen, besteht darin, beide vor dem Vergleich in denselben Fall (groß oder klein) zu konvertieren.

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

Die Entscheidung, ob toUpperCase() oder toLowerCase() verwendet werden soll, ist weitgehend willkürlich, da keine vollständig robust ist, wenn man über das lateinische Alphabet hinausgeht. Zum Beispiel wird der deutsche Kleinbuchstabe ß und ss von toUpperCase() in SS umgewandelt, während der türkische Buchstabe ı fälschlicherweise als ungleich zu I von toLowerCase() gemeldet würde, es sei denn, es wird speziell toLocaleLowerCase("tr") verwendet.

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 locale-bewusste und robuste Lösung zum Testen auf case-insensitive Gleichheit ist die Verwendung der Intl.Collator-API oder der localeCompare()-Methode des Strings — sie teilen dieselbe Schnittstelle — mit der Option sensitivity, die auf "accent" oder "base" gesetzt ist.

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

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

Die localeCompare()-Methode ermöglicht den Zeichenfolgenvergleich ähnlich wie strcmp() — sie erlaubt das Sortieren von Strings in einer lokalisierungsbewussten Weise.

Beachten Sie, dass JavaScript zwischen String-Objekten und primitiven String-Werten unterscheidet. (Das Gleiche gilt für Boolean und Zahlen.)

String-Literale (gekennzeichnet durch doppelte oder einfache Anführungszeichen) und Strings, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext (d. h. ohne Verwendung des new-Schlüsselworts) zurückgegeben werden, sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Eigenschaftslookup durchgeführt werden soll, wird JavaScript automatisch den String-Primitiven umwickeln und die Methode auf dem Wrapper-Objekt aufrufen oder das Eigenschaftslookup dort durchfü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 liefern auch unterschiedliche Ergebnisse bei der Verwendung von eval(). Primitive, die an eval übergeben werden, werden als Quellcode behandelt; String-Objekte 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 brechen, wenn er String-Objekte antrifft, wenn er stattdessen einen primitiven String erwartet, obwohl die Entwickler im Allgemeinen nicht über den Unterschied besorgt sein 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 größtenteils der Grund ist, warum String-Objekte ähnlich wie String-Primitiven verhalten). Die Operation 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) umgewandelt.
• BigInts werden mit dem gleichen Algorithmus wie toString(10) umgewandelt.
• Symbole werfen einen TypeError.
• Objekte werden zuerst in ein primitives Element umgewandelt, indem ihre Methoden [Symbol.toPrimitive]() (mit "string" als Hinweis), toString() und valueOf() in dieser Reihenfolge aufgerufen werden. Das resultierende Primitive wird dann in einen String umgewandelt.

Es gibt mehrere Möglichkeiten, nahezu den gleichen Effekt in JavaScript zu erzielen.

• Template Literal: `${x}` führt genau die String-Konvertierungsschritte aus, die oben für den eingebetteten Ausdruck erklärt wurden.
• Die String() Funktion: String(x) verwendet den gleichen Algorithmus, um x zu konvertieren, außer dass Symbole keinen TypeError werfen, sondern "Symbol(description)" zurückgeben, wobei description die Beschreibung des Symbols ist.
• Verwenden Sie den + Operator: "" + x zwingt seinen Operanden zu einem primitiven statt zu einem String, und hat für einige Objekte ganz andere Verhaltensweisen als die normale String-Konvertierung. Siehe seine Referenzseite für weitere Details.

Je nach Anwendungsfall möchten Sie möglicherweise `${x}` verwenden (um das eingebaute Verhalten nachzuahmen) oder String(x) (um Symbolwerte ohne Fehlermeldung zu verarbeiten), aber Sie sollten "" + x nicht verwenden.

Strings werden grundsätzlich als Sequenzen von UTF-16-Codeeinheiten dargestellt. Bei der UTF-16-Codierung ist jede Codeeinheit genau 16 Bit lang. Das bedeutet, dass maximal 2¹⁶ oder 65536 mögliche Zeichen als einzelne UTF-16-Codeeinheiten darstellbar sind. Diese Zeichenmenge wird Basic Multilingual Plane (BMP) genannt und umfasst die gebräuchlichsten Zeichen wie das lateinische, griechische und kyrillische Alphabet sowie viele ostasiatische Zeichen. Jede Codeeinheit kann in einem String mit \u gefolgt von genau vier Hexadezimalziffern geschrieben werden.

Das gesamte Unicode-Zeichenset ist jedoch viel, viel größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als Surrogatpaare gespeichert, bei denen es sich um Paare von 16-Bit-Codeeinheiten handelt, die ein einzelnes Zeichen darstellen. Um Mehrdeutigkeit zu vermeiden, müssen die beiden Teile des Paares zwischen 0xD800 und 0xDFFF liegen, und diese Codeeinheiten werden nicht zur Codierung von Einzelcodeeinheiten verwendet. (Genauer gesagt, führende Surrogate, auch hohe Surrogate genannt, haben Werte zwischen 0xD800 und 0xDBFF, einschließlich, während nachfolgende Surrogate, auch niedrige Surrogate genannt, Werte zwischen 0xDC00 und 0xDFFF, einschließlich, haben.) Jedes Unicode-Zeichen, das aus einer oder zwei UTF-16-Codeeinheiten besteht, wird auch als Unicode-Codierung bezeichnet. Jede Unicode-Codierung kann in einem String mit \u{xxxxxx} geschrieben werden, wobei xxxxxx 1–6 Hexadezimalziffern darstellt.

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

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

Einzelne Surrogate repräsentieren kein Unicode-Zeichen. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt behandeln, weil sie alle auf UTF-16-Codeeinheiten arbeiten, sind einzelne Surrogate oft keine gültigen Werte, wenn sie mit anderen Systemen interagieren — zum Beispiel wird encodeURI() für einzelne Surrogate einen URIError auslösen, weil die URI-Codierung UTF-8-Codierung verwendet, die keine Codierung für einzelne Surrogate hat. Strings, die keine einzelnen Surrogate enthalten, werden wohlgeformte Strings genannt und sind sicher bei Funktionen zu verwenden, die nicht mit UTF-16 arbeiten (wie encodeURI() oder TextEncoder). Sie können mit der Methode isWellFormed() prüfen, ob ein String wohlgeformt ist, oder einzelne Surrogate mit der Methode toWellFormed() sanieren.

Zusätzlich zu 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 Vielzahl von Variationen haben, bestehen tatsächlich aus mehreren Emojis, die normalerweise durch das Zeichen <ZWJ> (U+200D) verbunden sind.

Sie müssen vorsichtig sein, auf welcher Ebene der Zeichen Sie iterieren. Zum Beispiel wird split("") nach UTF-16-Codeeinheiten aufteilen und Surrogatpaare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert [Symbol.iterator]() nach Unicode-Codierungen. Das Iterieren durch Graphem-Cluster erfordert einige benutzerdefinierte 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 es als Funktion aufgerufen wird, gibt es primitive Werte vom Typ String zurück.

String.fromCharCode()

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

String.fromCodePoint()

Gibt einen String zurück, der mithilfe der angegebenen Sequenz von Codierungen 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 gemeinsam genutzt.

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. Nur lesbar.

String.prototype.at()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück. Akzeptiert negative Ganzzahlen, die rückwärts vom letzten Zeichen des Strings zählen.

String.prototype.charAt()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück.

String.prototype.charCodeAt()

Gibt eine Zahl zurück, die der Wert der UTF-16-Codeeinheit am angegebenen Index ist.

String.prototype.codePointAt()

Gibt eine nichtnegative Ganzzahl zurück, die der Codierung des UTF-16-codierten Zeichens entspricht, das an der angegebenen Pos startet.

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 des ersten Vorkommens von searchValue innerhalb dieses Strings zurück oder -1, wenn nicht gefunden.

String.prototype.isWellFormed()

Gibt einen booleschen Wert zurück, der angibt, ob dieser String irgendwelche einzelnen Surrogate enthält.

String.prototype.lastIndexOf()

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

String.prototype.localeCompare()

Gibt eine Zahl zurück, die angibt, ob der Referenzstring compareString vor, nach oder gleich dem gegebenen String in der Sortierreihenfolge kommt.

String.prototype.match()

Wird verwendet, um den regulären Ausdruck regexp mit einem 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 Stringwertes zurück.

String.prototype.padEnd()

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

String.prototype.padStart()

Füllt den aktuellen String von vorne 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 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 regulärer Ausdruck sein, und replaceWith kann ein String oder eine Funktion sein.

String.prototype.search()

Sucht 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 das Aufteilen des aufrufenden Strings bei Vorkommen des Substrings sep gefüllt 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 über eine bestimmte Anzahl von Zeichen erstreckt.

String.prototype.substring()

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

String.prototype.toLocaleLowerCase()

Die Zeichen innerhalb eines Strings werden in Kleinbuchstaben umgewandelt, wobei die aktuelle Lokale berücksichtigt wird.

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

String.prototype.toLocaleUpperCase()

Die Zeichen innerhalb eines Strings werden in Großbuchstaben umgewandelt, wobei die aktuelle Lokale berücksichtigt wird.

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

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 einzelnen Surrogate dieses Strings durch das Unicode-Ersatzzeichen U+FFFD ersetzt werden.

String.prototype.trim()

Trimmt Leerzeichen vom Anfang und Ende des Strings.

String.prototype.trimEnd()

Trimmt Leerzeichen vom Ende des Strings.

String.prototype.trimStart()

Trimmt 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 Codierungen eines String-Wertes iteriert und jede Codierung als String-Wert zurückgibt.

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 zur 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 erstellen:

"</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, um Werte in Strings zu konvertieren, als das Aufrufen der toString()-Methode des Wertes, da die erstgenannte auch funktioniert, wenn sie auf null und undefined verwendet wird. 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"

• Zahlen und Strings Leitfaden
• RegExp