String — Klasse · JavaScript-Referenz

Signatur

String

Beschreibung

Das String-Objekt wird verwendet, um eine Zeichenfolge darzustellen und zu bearbeiten.

Strings sind nützlich, um Daten zu speichern, die in Textform dargestellt werden können. Zu den am häufigsten verwendeten Operationen auf Strings gehören das Prüfen ihrer length, das Erstellen und Verketten mit den String-Operatoren + und +=, das Prüfen der Existenz oder Position von Teilzeichenfolgen mit der Methode indexOf() oder das Extrahieren von Teilzeichenfolgen mit der Methode substring().

Strings erstellen

Strings können als Primitives aus String-Literalen oder als Objekte mit dem String()-Konstruktor erzeugt werden. String-Literale können mit einfachen oder doppelten Anführungszeichen angegeben werden, die identisch behandelt werden, oder mit dem Backtick-Zeichen. Diese letzte Form gibt ein template literal an: Mit dieser Form können Ausdrücke interpoliert werden.

Zeichenzugriff

Es gibt zwei Möglichkeiten, auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die Methode charAt(). Die andere Möglichkeit besteht darin, den String als array-like Objekt zu behandeln, wobei einzelne Zeichen einem numerischen Index entsprechen. Bei Verwendung der Klammernotation für den Zeichenzugriff schlägt der Versuch, diese Eigenschaften zu löschen oder ihnen einen Wert zuzuweisen, fehl. Die beteiligten Eigenschaften sind weder beschreibbar noch konfigurierbar.

Strings vergleichen

Verwenden Sie die Kleiner-als- und Größer-als-Operatoren zum Vergleich von Strings. Beachten Sie, dass alle Vergleichsoperatoren, einschließlich === und ==, Strings unter Berücksichtigung der Groß-/Kleinschreibung vergleichen. Eine übliche Möglichkeit, Strings ohne Berücksichtigung der Groß-/Kleinschreibung zu vergleichen, besteht darin, beide vor dem Vergleich in dieselbe Groß-/Kleinschreibung umzuwandeln.

Die Wahl, ob mit toUpperCase() oder toLowerCase() transformiert wird, ist weitgehend willkürlich, und keine der beiden ist über das lateinische Alphabet hinaus vollständig robust. Zum Beispiel werden der deutsche Kleinbuchstabe ß und ss beide von toUpperCase() zu SS transformiert, während der türkische Buchstabe ı von toLowerCase() fälschlicherweise als ungleich I gemeldet würde, sofern nicht speziell toLocaleLowerCase("tr") verwendet wird.

Eine locale-aware und robuste Lösung zum Testen der Groß-/Kleinschreibungs-unabhängigen Gleichheit ist die Verwendung der Intl.Collator-API oder der localeCompare()-Methode des Strings — sie teilen dieselbe Schnittstelle — mit der sensitivity-Option auf "accent" oder "base" gesetzt.

Die localeCompare()-Methode ermöglicht Stringvergleiche ähnlich wie strcmp() — sie erlaubt das Sortieren von Strings auf eine locale-aware Weise.

String-Primitives und String-Objekte

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

String-Literale (durch doppelte oder einfache Anführungszeichen gekennzeichnet) und Strings, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext zurückgegeben werden (also ohne das Schlüsselwort new aufgerufen), sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen wird oder eine Eigenschaftssuche erfolgt, umschließt JavaScript den String-Primitive automatisch und ruft die Methode oder die Eigenschaftssuche stattdessen auf dem Wrapper-Objekt auf.

String-Primitives und String-Objekte liefern auch unterschiedliche Ergebnisse bei Verwendung von eval(). Primitives, die an eval übergeben werden, werden als Quellcode behandelt; String-Objekte werden wie alle anderen Objekte behandelt, indem das Objekt zurückgegeben wird.

Aus diesen Gründen kann der Code brechen, wenn er auf String-Objekte trifft, während er stattdessen einen primitiven String erwartet, obwohl Autoren sich in der Regel nicht um die Unterscheidung kümmern müssen. Ein String-Objekt kann immer mit der Methode valueOf() in sein primitives Gegenstück umgewandelt werden.

String-Coercion

Viele eingebaute Operationen, die Strings erwarten, konvertieren ihre Argumente zunächst in Strings (was weitgehend erklärt, warum sich String-Objekte ä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.
Symbols werfen einen TypeError.
Objekte werden zunächst in ein Primitive konvertiert, indem ihre Methoden [Symbol.toPrimitive]() (mit "string" als Hint), toString() und valueOf() in dieser Reihenfolge aufgerufen werden. Das resultierende Primitive wird dann in einen String konvertiert.

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

Template literal: `${x}` führt genau die oben erläuterten String-Coercion-Schritte für den eingebetteten Ausdruck aus.
Die Funktion String(): String(x) verwendet denselben Algorithmus zum Konvertieren von x, außer dass Symbols keinen TypeError werfen, sondern "Symbol(description)" zurückgeben, wobei description die description des Symbols ist.
Verwendung des +-Operators: "" + x konvertiert seinen Operanden in ein Primitive statt in einen String und hat für einige Objekte völlig andere Verhaltensweisen als die normale String-Coercion.

Abhängig vom Anwendungsfall möchten Sie möglicherweise `${x}` (um das eingebaute Verhalten nachzuahmen) oder String(x) (um Symbol-Werte ohne Fehler zu behandeln) verwenden, aber Sie sollten "" + x nicht verwenden.

UTF-16-Zeichen, Unicode-Codepunkte und Grapheme-Cluster

Strings werden grundsätzlich als Folgen von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Codierung ist jede Codeeinheit exakt 16 Bit lang. Das bedeutet, dass es maximal 2^16 oder 65536 mögliche Zeichen gibt, die als einzelne UTF-16-Codeeinheiten darstellbar sind. Dieser Zeichensatz wird als basic multilingual plane (BMP) bezeichnet und umfasst die häufigsten Zeichen wie das lateinische, griechische und kyrillische Alphabet sowie viele ostasiatische Zeichen. Jede Codeeinheit kann in einem String mit \u gefolgt von genau vier Hex-Ziffern geschrieben werden.

Der gesamte Unicode-Zeichensatz ist jedoch viel, viel größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als surrogate pairs gespeichert, das sind Paare von 16-Bit-Codeeinheiten, die ein einzelnes Zeichen repräsentieren. Zur Vermeidung von Mehrdeutigkeiten müssen die beiden Teile des Paares zwischen 0xD800 und 0xDFFF liegen, und diese Codeeinheiten werden nicht zur Codierung von Einzel-Codeeinheit-Zeichen verwendet. (Genauer gesagt haben leading surrogates, auch high-surrogate code units genannt, Werte zwischen 0xD800 und 0xDBFF einschließlich, während trailing surrogates, auch low-surrogate code units 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-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx} geschrieben werden, wobei xxxxxx 1–6 Hex-Ziffern darstellt.

Ein „lone surrogate" ist eine 16-Bit-Codeeinheit, die einer der folgenden Beschreibungen entspricht:

Sie liegt im Bereich 0xD800–0xDBFF einschließlich (d.h. ist ein leading surrogate), ist aber die letzte Codeeinheit im String, oder die nächste Codeeinheit ist kein trailing surrogate.
Sie liegt im Bereich 0xDC00–0xDFFF einschließlich (d.h. ist ein trailing surrogate), ist aber die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein leading surrogate.

Lone surrogates repräsentieren kein Unicode-Zeichen. Obwohl die meisten JavaScript-Builtins sie korrekt behandeln, da sie alle auf Basis von UTF-16-Codeeinheiten arbeiten, sind lone surrogates oft keine gültigen Werte bei der Interaktion mit anderen Systemen — zum Beispiel wirft encodeURI() einen URIError für lone surrogates, da die URI-Codierung UTF-8-Codierung verwendet, die keine Codierung für lone surrogates hat. Strings, die keine lone surrogates enthalten, werden well-formed Strings genannt und können sicher mit Funktionen verwendet werden, die nicht mit UTF-16 arbeiten (wie encodeURI() oder TextEncoder). Sie können mit der Methode isWellFormed() prüfen, ob ein String well-formed ist, oder lone surrogates mit der Methode toWellFormed() bereinigen.

Zusätzlich zu Unicode-Zeichen gibt es bestimmte Folgen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als grapheme cluster. Der häufigste Fall sind Emojis: Viele Emojis mit einer Reihe von Variationen werden tatsächlich aus mehreren Emojis gebildet, die üblicherweise durch das <ZWJ>-Zeichen (U+200D) verbunden sind.

Sie müssen darauf achten, auf welcher Zeichenebene Sie iterieren. Zum Beispiel splittet split("") nach UTF-16-Codeeinheiten und trennt surrogate pairs. String-Indizes beziehen sich ebenfalls auf den Index jeder UTF-16-Codeeinheit. Auf der anderen Seite iteriert [Symbol.iterator]() nach Unicode-Codepunkten. Das Iterieren durch grapheme cluster erfordert etwas benutzerdefinierten Code.

Parameter

Name	Typ	Default	Beschreibung
$value	any		Der Wert, der in eine Zeichenkette umgewandelt werden soll. Ohne Argument gibt `String()` einen leeren String zurück.

Rückgabewert

Typ

string | String

Beschreibung

Als Funktion (String(value)) wird ein primitiver String zurückgegeben. Als Konstruktor (new String(value)) wird ein String-Objekt zurückgegeben.

Beispiele

Strings als Primitives erstellen

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

String als Objekt erstellen

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

Zeichenzugriff mit charAt()

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

Zeichenzugriff mit Klammernotation

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

Strings 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.`);
}

Case-insensitiver Vergleich

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

Grenzen des einfachen Case-Vergleichs

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

Locale-aware Vergleich mit localeCompare()

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

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

String-Primitives vs. String-Objekte

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"

eval() mit Primitive vs. Objekt

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"

Konvertierung mit valueOf()

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

Iteration über verschiedene Zeichenebenen

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

Ungültiges HTML durch HTML-Wrapper-Methoden

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

Escaping in anchor()

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

String-Konvertierung

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

// Wichtig · Fallstricke

Sie sollten String selten als Konstruktor verwenden. Die HTML-Wrapper-Methoden (anchor(), big(), blink(), bold(), fixed(), fontcolor(), fontsize(), italics(), link(), small(), strike(), sub(), sup()) sind deprecated und sollten vermieden werden. Sie basieren auf einem sehr alten HTML-Standard, erzeugen häufig deprecated oder nicht-standardisierten Markup und führen String-Konkatenation ohne Validierung oder Sanitisierung durch, was bei direkter Einfügung mittels innerHTML ein potenzielles Sicherheitsrisiko darstellt. Verwenden Sie stattdessen DOM-APIs wie document.createElement().

Siehe auch

RegExp Number Boolean

← Vorheriger Eintrag SharedArrayBuffer Nächster Eintrag → SuppressedError