String

Beschreibung

Strings sind ntzlich, um Daten zu halten, die in Textform dargestellt werden knnen. Zu den am hufigsten verwendeten Operationen mit Strings gehrt das berprfen ihrer Lnge, das Erstellen und Verketten mit den + und += string operators, das berprfen der Existenz oder der Position von Teilstrings mit der indexOf()-Methode oder das Extrahieren von Teilstrings mit der substring()-Methode.

Erstellen von Strings

Strings knnen als Primitive, aus Zeichenfolgenliteralen 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-Primitive und String-Objekte teilen viele Verhaltensweisen, weisen jedoch auch wichtige Unterschiede und Einschrnkungen auf. Siehe "String-Primitive und String-Objekte" unten.

Zeichenfolgenliterale knnen mit einfachen oder doppelten Anfhrungszeichen angegeben werden, die identisch behandelt werden, oder mit dem Backtick-Zeichen `. Letztere Form gibt ein Template Literal an: Mit dieser Form knnen Sie Ausdrcke interpolieren. Weitere Informationen zur Syntax von Zeichenfolgenliteralen finden Sie im lexikalischen Grammatik.

Zeichen-Zugriff

Es gibt zwei Mglichkeiten, auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die charAt()-Methode:

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

Die andere Mglichkeit besteht darin, den String als ein arrayhnliches Objekt zu behandeln, wobei einzelne Zeichen einem numerischen Index entsprechen:

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

Wenn Sie die Klammer-Notation fr den Zeichen-Zugriff verwenden, wird der Versuch, diese Eigenschaften zu lschen oder einen Wert zuzuweisen, nicht erfolgreich sein. Die betreffenden Eigenschaften sind weder beschreibbar noch konfigurierbar. (Siehe Object.defineProperty() fr weitere Informationen.)

Vergleichen von Strings

Verwenden Sie die Kleiner- und Grer-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, einschlielich === und ==, Strings case-sensitiv vergleichen. Ein gebruchlicher Weg, um Strings case-insensitiv zu vergleichen, besteht darin, beide in denselben Fall (gro oder klein) zu konvertieren, bevor Sie sie vergleichen.

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

Die Wahl, ob sie durch toUpperCase() oder toLowerCase() transformieren, ist meist willkrlich, und keine davon ist vollstndig robust, wenn sie ber das lateinische Alphabet hinausgeht. Zum Beispiel werden der deutsche Kleinbuchstabe und ss beide zu SS durch toUpperCase() transformiert, whrend der trkische Buchstabe flschlicherweise als ungleich zu I durch toLowerCase() gemeldet werden wrde, 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 lnderabhngige und robuste Lsung fr die Prfung der case-insensitiven Gleichheit besteht darin, die Intl.Collator-API oder die localeCompare()-Methode des Strings zu verwenden sie 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 localeCompare()-Methode ermglicht den Zeichenfolgenvergleich in hnlicher Weise wie strcmp() sie ermglicht das Sortieren von Strings auf eine landesspezifische Weise.

String-Primitive und String-Objekte

Beachten Sie, dass JavaScript zwischen String-Objekten und primitiven Zeichenfolgen-Werten unterscheidet. (Dasselbe gilt fr Boolean und Numbers).

Zeichenfolgenliterale (durch doppelte oder einfache Anfhrungszeichen definiert) und Strings, die aus String-Aufrufen in einem Nicht-Konstruktor-Kontext zurckgegeben werden (das heit, ohne Verwendung des new-Schlsselworts aufgerufen), sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Eigenschafts-Lookup durchgefhrt wird, wird JavaScript automatisch das String-Primitive umhllen und die Methode aufrufen oder das Eigenschafts-Lookup am Wrapper-Objekt durchfhren.

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-Primitive und String-Objekte geben auch unterschiedliche Ergebnisse zurck, wenn eval() verwendet wird. Primitive, die an eval bergeben werden, werden als Quellcode behandelt; String-Objekte werden wie alle anderen Objekte behandelt, indem das Objekt zurckgegeben 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 Grnden kann der Code brechen, wenn er auf String-Objekte trifft, obwohl er stattdessen eine primitive Zeichenfolge erwartet, obwohl sich Autoren im Allgemeinen keine Sorgen ber die Unterscheidung machen mssen.

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

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

String-Coercion

Viele eingebaute Operationen, die Strings erwarten, zwingen ihre Argumente erst zu Strings (was weitgehend der Grund ist, warum sich String-Objekte hnlich wie String-Primitive verhalten). Die Operation kann wie folgt zusammengefasst werden:

• Strings werden unverndert zurckgegeben.
• 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 eine Primitive konvertiert, indem ihre [Symbol.toPrimitive]() (mit "string" als Hinweis), toString(), und valueOf()-Methoden, in dieser Reihenfolge, aufgerufen werden. Die resultierende Primitive wird dann in einen String umgewandelt.

Es gibt mehrere Mglichkeiten, nahezu den gleichen Effekt in JavaScript zu erzielen.

• Template Literal: `${x}` fhrt genau die String-Coercion-Schritte fr den eingebetteten Ausdruck aus, die oben erklrt wurden.
• Die String()-Funktion: String(x) verwendet den gleichen Algorithmus, um x zu konvertieren, auer dass Symbole keinen TypeError werfen, sondern "Symbol(description)" zurckgeben, wobei description die Beschreibung des Symbols ist.
• Die Verwendung des + operators: "" + x zwingt seine Operanden zu einer Primitiven anstatt zu einem String zu werden, und hat fr einige Objekte vllig andere Verhaltensweisen als die normale String-Coercion. Siehe die Referenzseite fr weitere Details.

Je nach Anwendungsfall mchten Sie mglicherweise `${x}` (um das eingebautes Verhalten nachzuahmen) oder String(x) (um Symbolwerte ohne Fehlerbehandlung zu handhaben) verwenden, aber Sie sollten nicht "" + x verwenden.

UTF-16-Zeichen, Unicode-Codepunkte und Graphem-Clustern

Strings werden grundstzlich als Sequenzen von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Codierung ist jede Code-Einheit genau 16 Bit lang. Das bedeutet, dass es maximal 216, oder 65536 mgliche Zeichen gibt, die als einzelne UTF-16-Codeeinheiten darstellbar sind. Diese Zeichensatz wird als Basic Multilingual Plane (BMP) bezeichnet und umfasst die hufigsten Zeichen wie die lateinischen, griechischen, kyrillischen Alphabete sowie viele ostasiatische Zeichen. Jede Code-Einheit kann mit \u gefolgt von genau vier Hexadezimalzahlen in einem String geschrieben werden.

Das gesamte Unicode-Zeichenarsenal ist jedoch wesentlich grer als 65536. Die zustzlichen Zeichen werden in UTF-16 als Surrogatpaare gespeichert, die Paare von 16-Bit-Codeeinheiten sind, die ein einzelnes Zeichen darstellen. Um Mehrdeutigkeiten zu vermeiden, mssen die beiden Teile des Paares zwischen 0xD800 und 0xDFFF liegen, und diese Codeeinheiten werden nicht verwendet, um Zeichen mit einer einzigen Codeeinheit zu kodieren. (Genauer gesagt, fhrende Surrogate, auch als High-Surrogate-Codes bezeichnet, haben Werte zwischen 0xD800 und 0xDBFF, whrend abschlieende Surrogate, auch als Low-Surrogate-Codes bezeichnet, Werte zwischen 0xDC00 und 0xDFFF haben.) Jedes Unicode-Zeichen, bestehend aus einem oder zwei UTF-16-Codeeinheiten, wird ebenfalls als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann mit \u{xxxxxx} in einem String geschrieben werden, wobei xxxxxx 16 Hex-Ziffern reprsentiert.

Ein "alleiniges Surrogat" ist eine 16-Bit-Codeeinheit, die eine der folgenden Beschreibungen erfllt:

• Es liegt im Bereich 0xD8000xDBFF, ist aber die letzte Codeeinheit im String, oder die nchste Codeeinheit ist kein abschlieender Surrogat.
• Es liegt im Bereich 0xDC000xDFFF, ist aber die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein fhrender Surrogat.

Alleinstehende Surrogate stellen kein Unicode-Zeichen dar. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt behandeln, da sie alle basierend auf UTF-16-Codeeinheiten arbeiten, sind alleinstehende Surrogate meistens keine gltigen Werte, wenn sie mit anderen Systemen interagierenzum Beispiel, encodeURI() wird einen URIError fr alleinstehende Surrogate werfen, da die URI-Codierung UTF-8-Codierung verwendet, die keine Codierung fr alleinstehende Surrogate hat. Strings, die keine alleinstehenden Surrogate enthalten, werden als wohlgeformte Strings bezeichnet und sind sicher, mit Funktionen verwendet zu werden, die nicht mit UTF-16 arbeiten (wie encodeURI() oder TextEncoder). Sie knnen mit der isWellFormed()-Methode berprfen, ob ein String wohlgeformt ist, oder alleinstehende Surrogate mit der toWellFormed()-Methode bereinigen.

ber die Unicode-Zeichen hinaus gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als ein Graphem-Cluster. Der hufigste Fall sind Emojis: Viele Emojis, die eine Reihe von Variationen haben, werden tatschlich durch mehrere Emojis gebildet, die in der Regel durch das <ZWJ> (U+200D) Zeichen verbunden werden.

Sie mssen darauf achten, auf welcher Ebene der Zeichen Sie iterieren. Zum Beispiel wird split("") nach UTF-16-Codeeinheiten aufteilen und Surrogatpaare trennen. Zeichenfolgenindizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert [Symbol.iterator]() nach Unicode-Codepunkten. Die Iteration durch Graphem-Cluster erfordert ein benutzerdefiniertes Skript.

"".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

Konstruktor

String()

Erstellt String-Objekte. Wenn es als Funktion aufgerufen wird, gibt es primitive Werte vom Typ String zurck.

Statische Methoden

String.fromCharCode()

Gibt eine Zeichenfolge zurck, die durch die angegebene Sequenz von Unicode-Werten erstellt wurde.

String.fromCodePoint()

Gibt eine Zeichenfolge zurck, die durch die angegebene Sequenz von Codepunkten erstellt wurde.

String.raw()

Gibt eine Zeichenfolge zurck, die aus einem rohen Template-String erstellt wurde.

Instanz-Eigenschaften

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

String.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Fr String-Instanzen ist der anfngliche Wert der String-Konstruktor.

Diese Eigenschaften sind eigene Eigenschaften jeder String-Instanz.

length

Reflektiert die Lnge des Strings. Nur lesbar.

Instanz-Methoden

String.prototype.at()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurck. Akzeptiert negative Ganzzahlen, die vom letzten Zeichen der Zeichenfolge zurckzhlen.

String.prototype.charAt()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurck.

String.prototype.charCodeAt()

Gibt eine Zahl zurck, die den Wert der UTF-16-Codeeinheit an dem angegebenen Index darstellt.

String.prototype.codePointAt()

Gibt eine nichtnegative Ganzzahl zurck, die den Codepunktwert des UTF-16 kodierten Codepunkts darstellt, beginnend an der angegebenen Position pos.

String.prototype.concat()

Kombiniert den Text von zwei (oder mehr) Zeichenfolgen und gibt eine neue Zeichenfolge zurck.

String.prototype.endsWith()

Bestimmt, ob eine Zeichenfolge mit den Zeichen der Zeichenfolge searchString endet.

String.prototype.includes()

Bestimmt, ob die aufrufende Zeichenfolge searchString enthlt.

String.prototype.indexOf()

Gibt den Index innerhalb dieser Zeichenfolge der ersten Vorkommen von searchValue zurck, oder -1, wenn nicht gefunden.

String.prototype.isWellFormed()

Gibt einen boolean-Wert zurck, der angibt, ob diese Zeichenfolge keine alleinstehenden Surrogate enthlt.

String.prototype.lastIndexOf()

Gibt den Index innerhalb dieser Zeichenfolge der letzten Vorkommen von searchValue zurck, oder -1, wenn nicht gefunden.

String.prototype.localeCompare()

Gibt eine Zahl zurck, die angibt, ob die Referenzzeichenfolge compareString vor, nach oder gleich der angegebenen Zeichenfolge in der Sortierreihenfolge kommt.

String.prototype.match()

Wird verwendet, um den regulren Ausdruck regexp mit einer Zeichenfolge zu vergleichen.

String.prototype.matchAll()

Gibt einen Iterator fr alle Treffer von regexp zurck.

String.prototype.normalize()

Gibt die Unicode-Normalisierungsform des aufgerufenen Zeichenfolgenwertes zurck.

String.prototype.padEnd()

Fllt die aktuelle Zeichenfolge vom Ende mit einer angegebenen Zeichenfolge auf und gibt eine neue Zeichenfolge der Lnge targetLength zurck.

String.prototype.padStart()

Fllt die aktuelle Zeichenfolge vom Anfang mit einer angegebenen Zeichenfolge auf und gibt eine neue Zeichenfolge der Lnge targetLength zurck.

String.prototype.repeat()

Gibt eine Zeichenfolge bestehend aus den Elementen des Objekts zurck, die count mal wiederholt werden.

String.prototype.replace()

Wird verwendet, um Vorkommen von searchFor durch replaceWith zu ersetzen. searchFor kann eine Zeichenfolge oder ein regulrer Ausdruck sein, und replaceWith kann eine Zeichenfolge oder Funktion sein.

String.prototype.replaceAll()

Wird verwendet, um alle Vorkommen von searchFor durch replaceWith zu ersetzen. searchFor kann eine Zeichenfolge oder ein regulrer Ausdruck sein, und replaceWith kann eine Zeichenfolge oder Funktion sein.

String.prototype.search()

Suchen Sie nach einem Treffer zwischen einem regulren Ausdruck regexp und der aufgerufenen Zeichenfolge.

String.prototype.slice()

Extrahiert einen Abschnitt einer Zeichenfolge und gibt eine neue Zeichenfolge zurck.

String.prototype.split()

Gibt ein Array von Zeichenfolgen zurck, das durch das Trennen der aufgerufenen Zeichenfolge an Vorkommen der Teilzeichenfolge sep befllt wird.

String.prototype.startsWith()

Bestimmt, ob die aufgerufene Zeichenfolge mit den Zeichen der Zeichenfolge searchString beginnt.

String.prototype.substr()

Gibt einen Teil der Zeichenfolge zurck, der am angegebenen Index beginnt und fr eine bestimmte Anzahl von Zeichen danach fortgesetzt wird.

String.prototype.substring()

Gibt eine neue Zeichenfolge zurck, die aus den Zeichen der aufgerufenen Zeichenfolge von (oder zwischen) dem angegebenen Index (oder Indizes) besteht.

String.prototype.toLocaleLowerCase()

Die Zeichen innerhalb einer Zeichenfolge werden unter Bercksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben umgewandelt.

Fr die meisten Sprachen entspricht dies der toLowerCase().

String.prototype.toLocaleUpperCase()

Die Zeichen innerhalb einer Zeichenfolge werden unter Bercksichtigung des aktuellen Gebietsschemas in Grobuchstaben umgewandelt.

Fr die meisten Sprachen entspricht dies der toUpperCase().

String.prototype.toLowerCase()

Gibt den aufgerufenen Zeichenfolgenwert in Kleinbuchstaben umgewandelt zurck.

String.prototype.toString()

Gibt eine Zeichenfolge zurck, die das angegebene Objekt darstellt. berschreibt die Object.prototype.toString()-Methode.

String.prototype.toUpperCase()

Gibt den aufgerufenen Zeichenfolgenwert in Grobuchstaben umgewandelt zurck.

String.prototype.toWellFormed()

Gibt eine Zeichenfolge zurck, bei der alle alleinstehenden Surrogate der aktuellen Zeichenfolge durch das Unicode-Ersatzzeichen U+FFFD ersetzt werden.

String.prototype.trim()

Entfernt Leerzeichen vom Anfang und Ende der Zeichenfolge.

String.prototype.trimEnd()

Entfernt Leerzeichen vom Ende der Zeichenfolge.

String.prototype.trimStart()

Entfernt Leerzeichen vom Anfang der Zeichenfolge.

String.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurck. berschreibt die Object.prototype.valueOf()-Methode.

String.prototype[Symbol.iterator]()

Gibt ein neues Iterator-Objekt zurck, das ber die Codepunkte eines String-Werts iteriert und jeden Codepunkt als String-Wert zurckgibt.

HTML-Wrapper-Methoden

String.prototype.anchor()

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

String.prototype.big()

<big>

String.prototype.blink()

<blink>

String.prototype.bold()

<b>

String.prototype.fixed()

<tt>

String.prototype.fontcolor()

<font color="color">

String.prototype.fontsize()

<font size="size">

String.prototype.italics()

<i>

String.prototype.link()

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

String.prototype.small()

<small>

String.prototype.strike()

<strike>

String.prototype.sub()

<sub>

String.prototype.sup()

<sup>

Beachten Sie, dass diese Methoden nicht berprfen, ob die Zeichenfolge selbst HTML-Tags enthlt, sodass es mglich ist, ungltiges HTML zu erstellen:

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

Das einzige Escaping, das sie durchfhren, besteht darin, " im Attributwert (fr anchor(), fontcolor(), fontsize() und link()) mit " zu ersetzen.

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

Beispiele

String-Konvertierung

Die String()-Funktion ist eine zuverlssigere Methode, um Werte in Zeichenfolgen umzuwandeln, als die toString()-Methode des Werts aufzurufen, da erstere 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"

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Zahlen und Strings-Leitfaden
• RegExp