String

Strings sind nützlich, um Daten zu halten, die in Textform dargestellt werden können. Einige der am häufigsten verwendeten Operationen an Strings sind das Überprüfen ihrer Länge, das Erstellen und Konkatenieren von ihnen mithilfe der + und += String-Operatoren, das Überprüfen auf das Vorhandensein oder den Standort von Teilstrings mit der indexOf()-Methode oder das Extrahieren von Teilstrings mit der substring()-Methode.

Strings können als Primitiven, aus String-Literalen oder als Objekte mithilfe 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, haben jedoch andere wichtige Unterschiede und Vorbehalte. 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 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"

Beim Verwenden von Klammernotation für den Zeichenzugriff wird der Versuch, diesen Eigenschaften einen Wert zu löschen oder 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 streng fallsensitiv vergleichen. Eine übliche Methode, um Strings ohne Berücksichtigung der Groß- und Kleinschreibung zu vergleichen, besteht darin, beide vorher in den gleichen Fall (Groß- oder Kleinschreibung) zu konvertieren.

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

Die Entscheidung, ob mit toUpperCase() oder toLowerCase() transformiert wird, ist meist willkürlich, und keine der beiden 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() berichtet würde, es sei denn, er wird speziell mit 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 lokalsensible und robuste Lösung für den test auf Fallinsensitive Gleichheit bietet die Intl.Collator API oder die localeCompare() Methode des Strings – beide teilen das gleiche 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 den Stringvergleich ähnlich wie strcmp() – sie erlaubt das Sortieren von Strings in einer lokalsensiblen Art und Weise.

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

String-Literale (gekennzeichnet durch doppelte oder einfache Anführungszeichen) und Strings, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext zurückgegeben werden (also aufgerufen, ohne das new Schlüsselwort zu verwenden), sind primitive Strings. In Kontexten, in denen eine Methode aufgerufen oder eine Eigenschaftsabfrage für einen primitiven String durchgeführt werden soll, wird JavaScript automatisch das String-Primitiv umwickeln und die Methode aufrufen oder die Eigenschaftsabfrage am Wrapper-Objekt 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 String-Objekte auf {primitive} Strings treffen sollen, auch wenn Autoren im Allgemeinen nicht auf die Unterscheidung achten müssen.

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

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

Viele eingebaute Operationen, die Strings erwarten, zwingen ihre Argumente zunächst zu Strings (was weitgehend der Grund dafür ist, dass String-Objekte ähnlich wie String-Primitiven funktionieren). 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) konvertiert.
• BigInts werden mit dem gleichen Algorithmus wie toString(10) konvertiert.
• Symbole werfen einen TypeError.
• Objekte werden zunächst in ein Primärwert konvertiert, indem ihre [Symbol.toPrimitive]() (mit "string" als Hinweis), toString() und valueOf() Methoden in dieser Reihenfolge aufgerufen werden. Das resultierende Primärwert wird dann in einen String konvertiert.

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

• Template Literal: `${x}` macht genau die oben erklärten String-Coercion-Schritte für den eingebetteten Ausdruck.
• Die String()-Funktion: String(x) verwendet den gleichen Algorithmus zur Konvertierung von x, außer dass Symbole keinen TypeError werfen, sondern "Symbol(description)" zurückgeben, wobei description die Beschreibung des Symbols ist.
• Verwendung des + Operators: "" + x zwingt seine Operanden auf ein Primärwert anstatt auf einen String, und hat für einige Objekte ein völlig anderes Verhalten als die normale String-Coercion. Siehe die Referenzseite für weitere Details.

Abhängig von Ihrem Anwendungsfall möchten Sie vielleicht `${x}` (um das eingebaute Verhalten nachzuahmen) oder String(x) verwenden (um Symbolwerte ohne Fehlerbehandlung zu verarbeiten), sollten aber nicht "" + x verwenden.

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

Das gesamte Unicode-Zeichensatz ist jedoch viel, viel größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als Surrogat-Paare gespeichert, bei denen es sich um Paare von 16-Bit-Codeeinheiten 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 zur Kodierung einzelner Codeeinheiten verwendet. (Genauer gesagt haben führende Surrogate, auch Hochsurrogate genannt, Werte zwischen 0xD800 und 0xDBFF, einschließlich, während nachfolgende Surrogate, auch Niedrigsurrogate genannt, Werte zwischen 0xDC00 und 0xDFFF, einschließlich, haben.) Jedes Unicode-Zeichen, das aus ein oder zwei UTF-16-Codeeinheiten besteht, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx} angegeben werden, wobei xxxxxx 1–6 Hexadezimalwerte darstellt.

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

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

Einsame Surrogate repräsentieren kein Unicode-Zeichen. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt handhaben, da sie alle auf UTF-16-Codeeinheiten basieren, sind einsame Surrogate oft keine gültigen Werte beim Interagieren mit anderen Systemen – zum Beispiel wird encodeURI() einen URIError für einsame Surrogate auslösen, da die URI-Kodierung die UTF-8-Codierung verwendet, die keine Kodierung für einsame Surrogate hat. Strings, die keine einsamen Surrogate enthalten, werden als wohlgeformte Strings bezeichnet und können sicher mit 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 isWellFormed()-Methode oder einsame Surrogate mit der toWellFormed()-Methode bereinigen.

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

Sie müssen vorsichtig sein, auf welcher Ebene Sie Zeichen iterieren. Zum Beispiel wird [split("")](/de/docs/Web/JavaScript/Reference/Global_Objects/String/split) nach UTF-16-Codeeinheiten splitten und Surrogat-Paare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert [Symbol.iterator]() nach Unicode-Codepunkten. Das Iterieren durch Graphem-Cluster erfordert einige benutzerdefinierte Codes.

"😄".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. Wird es als Funktion aufgerufen, gibt es primitive Werte des Typs String zurück.

String.fromCharCode()

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

String.fromCodePoint()

Gibt einen String zurück, der mit der angegebenen Sequenz von Code-Punkten erstellt wurde.

String.raw()

Gibt einen String zurück, der aus einer rohen Template-Zeichenkette 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 wieder. Nur lesbar.

• String.prototype.at()
  • : Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen index zurück. Akzeptiert negative ganze Zahlen, die vom letzten Zeichen des Strings zurück 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 den Wert der UTF-16-Codeeinheit am angegebenen index darstellt.
• String.prototype.codePointAt()
  • : Gibt eine Nicht-negativ-Ganzzahl zurück, die den Codepunktwert des UTF-16-kodierten Codepunkts darstellt, der an der 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 des ersten Vorkommens von searchValue innerhalb dieses Strings zurück oder -1, wenn nicht gefunden.
• String.prototype.isWellFormed()
  • : Gibt einen Boolean zurück, der anzeigt, ob dieser String einsame 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 anzeigt, ob der Vergleichsstring compareString in der Sortierreihenfolge vor, nach oder gleich dem gegebenen String kommt.
• String.prototype.match()
  • : Wird verwendet, um regulären Ausdruck regexp gegen einen String zu vergleichen.
• String.prototype.matchAll()
  • : Gibt einen Iterator aller Übereinstimmungen von regexp zurück.
• String.prototype.normalize()
  • : Gibt die Unicode-Normalform des aufrufenden String-Werts zurück.
• String.prototype.padEnd()
  • : Füllt den aktuellen String von Ende mit einem gegebenen String und gibt einen neuen String von der Länge targetLength zurück.
• String.prototype.padStart()
  • : Füllt den aktuellen String von Anfang mit einem gegebenen String und gibt einen neuen String von 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 entsteht, indem der aufrufende String an den Vorkommen des Substrings sep aufgeteilt 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 eine gegebene Anzahl von Zeichen danach umfasst.
• String.prototype.substring()
  • : Gibt einen neuen String zurück, der Zeichen des aufrufenden Strings von (oder zwischen) angegebenen Index (oder Indizes) enthält.
• String.prototype.toLocaleLowerCase()
  • : Die Zeichen innerhalb eines Strings werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben konvertiert.

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

• String.prototype.toLocaleUpperCase()
  • : Die Zeichen innerhalb eines Strings werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben konvertiert.

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

• String.prototype.toLowerCase()
  • : Gibt den aufrufenden String-Wert, umgewandelt in Kleinbuchstaben, 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, umgewandelt in Großbuchstaben, zurück.
• String.prototype.toWellFormed()
  • : Gibt einen String zurück, bei dem alle einsamen Surrogate dieses Strings mit dem Unicode-Ersatzzeichen U+FFFD ersetzt wurden.
• String.prototype.trim()
  • : Schneidet Leerzeichen vom Beginn und Ende des Strings ab.
• String.prototype.trimEnd()
  • : Schneidet Leerzeichen vom Ende des Strings ab.
• String.prototype.trimStart()
  • : Schneidet Leerzeichen vom Beginn des Strings ab.
• String.prototype.valueOf()
  • : Gibt den primären 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-Wertes 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, sodass es möglich ist, ungültiges HTML zu erzeugen:

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

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

"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 die toString()-Methode des Wertes zu verwenden, da erstere auch für 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"

• Zahlen und Zeichenketten Leitfaden
• RegExp