String

Strings sind nützlich, um Daten zu halten, die in Textform dargestellt werden können. Einige der am häufigsten verwendeten Operationen mit Strings sind das Überprüfen ihrer Länge, das Erstellen und Zusammenfügen mit den + und += String-Operatoren, das Überprüfen auf das Vorhandensein oder den Ort 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-Primitives und String-Objekte teilen viele Verhaltensweisen, aber es gibt wichtige Unterschiede und Vorbehalte. Siehe "String-Primitives 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 diesem Format können Sie Ausdrücke interpolieren. Für weitere Informationen zur Syntax von String-Literalen siehe lexikalische 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 wie ein Array-ähnliches Objekt zu behandeln, wobei 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ß-/klein-schreibungssensitiv vergleichen. Eine gängige Methode zum groß-/klein-schreibungsunabhängigen Vergleich von Strings besteht darin, beide vor dem Vergleich in den gleichen Fall (Groß- oder Kleinbuchstaben) zu konvertieren.

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

Die Wahl, ob durch toUpperCase() oder toLowerCase() transformiert wird, ist meist willkürlich, und keine der beiden ist vollständig robust, wenn sie über das lateinische Alphabet hinausgeht. Zum Beispiel wird der deutsche Kleinbuchstabe ß und ss beide durch toUpperCase() in SS umgewandelt, während der türkische Buchstabe ı fälschlicherweise als ungleich zu I gemeldet wird, es sei denn, man 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 sprach-, versandssensitivere und robuste Lösung zum Testen der groß-/klein-schreibungsunabhängigen Gleichheit ist die Verwendung der Intl.Collator API oder der localeCompare()-Methode des Strings – beide haben dasselbe Interface – 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 localeCompare() Methode ermöglicht einen String-Vergleich in ähnlicher Weise wie strcmp() — sie erlaubt das Sortieren von Strings auf eine ortsspezifische Weise.

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

String-Literale (markiert durch doppelte oder einfache Anführungszeichen) und Strings, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext zurückgegeben werden (d. h., ohne das Schlüsselwort new verwendet zu haben), sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Eigenschaftslookup durchgeführt werden soll, umschließt JavaScript automatisch den String-Primitive und ruft die Methode auf oder führt das Eigenschaftslookup auf dem Wrapper-Objekt durch.

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-Primitives und String-Objekte liefern auch unterschiedliche Ergebnisse beim Einsatz von eval(). An eval übergebene Primitives werden als Quellcode behandelt; String-Objekte werden wie alle anderen Objekte behandelt, indem sie das Objekt zurückgeben. 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 beim Auftreten von String-Objekten brechen, wenn er stattdessen einen primitiven String erwartet, obwohl Autoren im Allgemeinen den Unterschied nicht beachten müssen.

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

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

Viele eingebaute Operationen, die Strings erwarten, bringen ihre Argumente zuerst in Strings um (was größtenteils der Grund ist, warum String-Objekte sich ähnlich wie String-Primitives 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 demselben Algorithmus wie toString(10) konvertiert.
• BigInts werden mit demselben Algorithmus wie toString(10) konvertiert.
• Symbole werfen einen TypeError.
• Objekte werden zunächst in ein Primitive umgewandelt durch Aufruf ihrer [Symbol.toPrimitive]() (mit "string" als Hinweis), toString() und valueOf()-Methoden, in dieser Reihenfolge. Das resultierende Primitive wird dann in einen String konvertiert.

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

• Template Literal: `${x}` führt genau die im obigen Abschnitt beschriebenen Schritte der String-Konvertierung für den eingebetteten Ausdruck aus.
• Die String()-Funktion: String(x) verwendet denselben Algorithmus, um x zu konvertieren, mit der Ausnahme, dass Symbole keinen TypeError werfen, sondern "Symbol(description)" zurückgeben, wobei description die Beschreibung des Symbols ist.
• Die Verwendung des + Operators: "" + x zwingt seinen Operand zu einem primitiven Wert anstelle eines Strings und hat für einige Objekte völlig unterschiedliche Verhaltensweisen gegenüber der normalen String-Konvertierung. Siehe die Referenzseite für weitere Details.

Abhängig von Ihrem Anwendungsfall möchten Sie möglicherweise `${x}` (zur Nachahmung des eingebauten Verhaltens) oder String(x) (zur Behandlung von Symbolwerten ohne Fehlermeldung) verwenden, aber Sie sollten "" + x nicht verwenden.

Strings werden im Wesentlichen als Sequenzen von UTF-16-Einheiten dargestellt. Bei der UTF-16-Codierung ist jede Einheit genau 16 Bit lang. Dies bedeutet, dass maximal 2¹⁶, oder 65536 mögliche Zeichen als einzelne UTF-16-Einheiten darstellbar sind. Diese Zeichensatz wird als Basic Multilingual Plane (BMP) bezeichnet und umfasst die am häufigsten verwendeten Zeichen wie die lateinischen, griechischen, kyrillischen Alphabete sowie viele ostasiatische Zeichen. Jede Einheit kann in einem String mit \u gefolgt von genau vier Hexadezimalziffern geschrieben werden.

Allerdings ist der gesamte Unicode-Zeichensatz 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-Einheiten 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 verwendet, um Zeichen mit einer einzigen Codeeinheit zu codieren. (Genauer sind führende Surrogate, auch als hochsurrogierte Codeeinheiten bekannt, haben Werte zwischen 0xD800 und 0xDBFF, während nachfolgende Surrogate, auch als tiefsurrogierte Codeeinheiten bekannt, Werte zwischen 0xDC00 und 0xDFFF haben. Jede Unicode-Zeichen, bestehend aus einer oder zwei UTF-16-Einheiten, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx} geschrieben werden, wobei xxxxxx 1–6 Hexadezimalziffern repräsentiert.

Ein "verwaistes Surrogat" ist eine 16-Bit-Codeeinheit, die eine der unten beschriebenen Bedingungen erfüllt:

• Es befindet sich im Bereich 0xD800–0xDBFF, inklusive (d.h. eine führende Surrogate), aber es ist die letzte Codeeinheit im String oder die nächste Codeeinheit ist keine tiefsurrogierte.
• Es befindet sich im Bereich 0xDC00–0xDFFF, inklusive (d.h. eine tiefsurrogierte), aber es ist die erste Codeeinheit im String oder die vorherige Codeeinheit ist keine hochsurrogierte.

Verwaiste Surrogate stellen kein Unicode-Zeichen dar. Obwohl die meisten in JavaScript integrierten Methoden sie korrekt behandeln, weil sie alle auf UTF-16-Einheiten basieren, sind verwaiste Surrogate oft keine gültigen Werte bei der Interaktion mit anderen Systemen — zum Beispiel wirft encodeURI() für verwaiste Surrogate einen URIError, weil die URI-Kodierung UTF-8-Codierung verwendet, die keine Kodierung für verwaiste Surrogate hat. Strings, die keine verwaisten Surrogate enthalten, werden als wohlgeformt bezeichnet und sind sicher in Funktionen verwendet werden, die nicht mit UTF-16 umgehen (wie encodeURI() oder TextEncoder). Sie können überprüfen, ob ein String wohlgeformt ist, mit der Methode isWellFormed(), oder verwaiste Surrogate mit der Methode toWellFormed() sanieren.

Neben Unicode-Zeichen gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als Graphemschreibgruppen. Der häufigste Fall sind Emojis: Viele Emojis, die eine Reihe von Varianten haben, werden tatsächlich von mehreren Emojis gebildet, die gewöhnlich durch das Zeichen <ZWJ> (U+200D) verbunden werden.

Sie müssen vorsichtig sein, auf welcher Ebene der Zeichen Sie iterieren. Beispielsweise wird split("") nach UTF-16-Einheiten aufteilen und Surrogatpaare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Einheit. Andererseits iteriert [Symbol.iterator]() über Unicode-Codepunkte. Das Durchlaufen von Graphemschreibgruppen erfordert einige kundenspezifische 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 sie als Funktion aufgerufen wird, gibt sie primitive Werte des Typs String zurück.

String.fromCharCode()

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

String.fromCodePoint()

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

String.raw()

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

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

String.prototype.constructor

Die Konstrukturfunktion, 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 an. Schreibgeschützt.

String.prototype.at()

Gibt das Zeichen (genau eine UTF-16-Einheit) am angegebenen Index zurück. Akzeptiert negative ganze Zahlen, die vom letzten Zeichen im String zurück zählen.

String.prototype.charAt()

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

String.prototype.charCodeAt()

Gibt eine Zahl zurück, die dem UTF-16-Wert der Einheit am angegebenen Index entspricht.

String.prototype.codePointAt()

Gibt eine nicht-negative ganze Zahl zurück, die dem Codepunkt-Wert des UTF-16-codierten Zeichens entspricht, das beim angegebenen pos beginnt.

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 booleschen Wert zurück, der anzeigt, ob dieser String verwaiste 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 anzeigt, ob der Referenz-String compareString vor, nach oder gleich dem angegebenen String in der Sortierreihenfolge liegt.

String.prototype.match()

Wird verwendet, um den regulären Ausdruck regexp gegen einen String abzugleichen.

String.prototype.matchAll()

Gibt einen Iterator aller Übereinstimmungen von regexp zurück.

String.prototype.normalize()

Gibt die Unicode-Normalisierungsform des aufrufenden String-Werts zurück.

String.prototype.padEnd()

Füllt den aktuellen String von hinten mit einem angegebenen 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 angegebenen 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 wurden.

String.prototype.replace()

Wird verwendet, um Vorkommen von searchFor mit 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 mit 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()

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 Aufteilen des aufrufenden Strings bei Vorkommen des Substrings sep gefüllt ist.

String.prototype.startsWith()

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

String.prototype.substr() Veraltet

Gibt einen Abschnitt des Strings zurück, beginnend beim angegebenen Index und sich für eine angegebene Anzahl von Zeichen erstreckend.

String.prototype.substring()

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

String.prototype.toLocaleLowerCase()

Die Zeichen innerhalb eines Strings werden unter Berücksichtigung der aktuellen Spracheinstellung in Kleinbuchstaben umgewandelt.

Für die meisten Sprachen gibt dies dasselbe zurück wie toLowerCase().

String.prototype.toLocaleUpperCase()

Die Zeichen innerhalb eines Strings werden unter Berücksichtigung der aktuellen Spracheinstellung in Großbuchstaben umgewandelt.

Für die meisten Sprachen gibt dies dasselbe zurück wie toUpperCase().

String.prototype.toLowerCase()

Gibt den aufrufenden String-Wert 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 String-Wert in Großbuchstaben umgewandelt zurück.

String.prototype.toWellFormed()

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

String.prototype.trim()

Schneidet Leerzeichen vom Anfang und Ende des Strings ab.

String.prototype.trimEnd()

Schneidet Leerzeichen vom Ende des Strings ab.

String.prototype.trimStart()

Schneidet Leerzeichen vom Anfang des Strings ab.

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 Iteratorobjekt zurück, das über die Codepunkte eines String-Werts iteriert und jeden Codepunkt 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 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, daher ist es möglich, ungültiges HTML zu erzeugen:

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

Die einzige Entschärfung, die 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 Umwandlung von Werten in Strings als der Aufruf der toString()-Methode des Werts, da die erstere auch bei null und undefined verwendet werden kann. 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"

• Textformatierung Leitfaden
• RegExp