Das globale String-Objekt ist ein Konstruktor für Strings, auch Zeichenketten genannt.

Syntax

String-Literale haben folgende Formen:

'string-text'
"string-text"
"中文 español deutsch English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"

Strings können auch direkt mit dem globalen String-Objekt erzeugt werden:

String(thing)

Parameter

thing
Alles, was in einen String umgewandelt werden kann.

Template-Literale

Ab ECMAScript 2015 können String-Literale auch durch sogenannte Template-Literale verkörpert werden:

`hallo welt`
`hallo!
 welt!`
`hallo ${wer}`
escape `${wer}`

Escape-Notation

Neben gewöhnlichen, druckbaren Zeichen gibt es Sonderzeichen, die mittels Escape-Notation kodiert werden können:

Code Ausgabe
\0 das NULL-Zeichen
\' einfaches Anführungszeichen
\" doppeltes Anführungszeichen
\\ Rückwärtsschrägstrich (backslash)
\n Zeilenumbruch (new line)
\r Zeilenanfang (carriage return)
\v vertikaler Tabulator
\t Tabulator
\b Backspace
\f Seitenvorschub (form feed)
\uXXXX Unicode-Codepoint
\u{X} ... \u{XXXXXX} Unicode-Codepoint
\xXX Latin-1-Zeichen

Im Gegensatz zu einigen anderen Sprachen unterscheidet JavaScript nicht zwischen mit einfachen und doppelten Anführungszeichen versehenen Strings; deswegen funktionieren die obigen Escape-Sequenzen in Strings, die entweder mit einfachen oder doppelten Anführungszeichen erstellt wurden.

Lange String-Literale

Manchmal enthält der Programm-Code Strings, die sehr lang sind. Anstatt endlose Zeilen zu bewirken, die vielleicht am Rand des Editors umbrechen, kann ein String ausdrücklich in mehrere Zeilen im Quell-Code eingepasst werden, ohne seinen Inhalt zu beeinflussen. Es gibt zwei Arten, um das zu tun.

Es kann der +-Operator benutzt werden, um auf folgende Weise mehrere Strings aneinanderzuhängen:

let langerString = "Dies ist ein sehr langer String, der über " +
                 "mehrere Zeilen verteilt werden muss, weil " +
                 "sonst der Code unleserlich ist.";

Oder der Rückwärtsschrägstrich ("\") wird am Ende jeder Zeile benutzt, um anzugeben, dass der String in der nächsten Zeile weitergeht. Es sollte sichergestellt werden, dass nach dem Rückwärtsschrägstrich (backslash) kein Leer- oder ein anderes Zeichen (außer ein Zeilenumbruch) steht oder als Einrückung dient; sonst funktioniert es nicht. Diese Form sieht wie folgt aus:

let langerString = "Dies ist ein sehr langer String, der über \
mehrere Zeilen verteilt werden muss, weil \
sonst der Code unleserlich ist.";

Beide Arten erzeugen identische Strings.

Beschreibung

Strings sind nützlich, um Daten in Textform zu speichern. Manche der meist benutzten String-Operationen sind es, die length abzufragen, Strings mittels + und += String-Operatoren zu verbinden, mit der indexOf() -Methode die Existenz oder Position von Sub-Strings festzustellen oder Sub-Strings mit der substring()-Methode zu extrahieren.

Zeichenabfrage

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

return 'Katze'.charAt(1); // gibt "a" zurück

Die andere Möglichkeit (eingeführt in ECMAScript 5) ist, den String als ein Array-ähnliches Objekt zu behandlen, in dem einzelne Zeichen zu einem numerischen Index gehören:

return 'Katze'[1]; // gibt "a" zurück

Bei einen Zeichenzugriff mittels Klammernotation ist es nicht möglich, einen Wert zu löschen oder zuzuweisen. Die entsprechenden Eigenschaften sind weder überschreibbar noch konfigurierbar. (Siehe Object.defineProperty() für mehr Informationen.)

Strings vergleichen

C-Entwicklern steht die strcmp()-Funktion zur Verfügung, um Strings zu vergleichen. In JavaScript können die kleiner-als- und größer-als-Operatoren benutzt werden:

var a = 'a';
var b = 'b';
if (a < b) { // true
  console.log(a + ' ist geringer als ' + b);
} else if (a > b) {
  console.log(a + ' ist größer als ' + b);
} else {
  console.log(a + ' und ' + b + ' sind gleich.');
}

Ein ähnliches Ergebnis kann durch die localeCompare()-Methode erzielt werden, die von String-Instanzen übernommen wird.

Unterscheidung von String-Primitives und String-Objekten

Es ist zu betonen, dass JavaScript zwischen String-Objekten und primitiven String-Werten unterscheidet. (Das selbe gilt für Boolean und Numbers.)

String-Literale (definiert mit doppelten oder einfachen Anführungszeichen) und Strings, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext (z. B. ohne das new-Schlüsselwort zu benutzen) zurückgegeben werden, sind String-Primitives. JavaScript wandelt automatisch Primitives zu String-Objekten um, so dass es möglich ist String-Objekt-Methoden für String-Primitives zu nutzen. In Kontexten, in denen eine Methode auf ein String-Primitive bezogen aufgerufen oder eine Eigenschaft eines solchen abgefragt wird, sorgt JavaScript dafür, dass das String-Primitive wie ein Objekt behandelt wird.

var s_prim = 'foo';
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Loggt "string"
console.log(typeof s_obj);  // Loggt "object"

String-Primitives und String-Objekte führen auch bei der Nutzung von eval() zu unterschiedlichen Ergebnissen. An eval übergebene Primitives werden als Quell-Code behandelt; bei String-Objekten wird wie bei allen anderen Objekten das Objekt zurückgegeben. Zum Beispiel:

var s1 = '2 + 2';             // erzeugt ein String-Primitive
var s2 = new String('2 + 2'); // erzeugt ein String-Objekt
console.log(eval(s1));        // gibt die Zahl 4 zurück
console.log(eval(s2));        // gibt den String "2 + 2" zurück

Aus diesen Gründen kann Code aufhören zu funktionieren, wenn er String-Objekte bemerkt, obwohl ein String-Primitive erwartet wird. Trotzdem brauchen sich Autoren normalerweise nicht um diesen Unterschied zu kümmern.

Ein String-Objekt kann mit der valueOf()-Methode immer zu seiner Primitive-Entsprechung konvertiert werden.

console.log(eval(s2.valueOf())); // gibt die Zahl 4 zurück
Bemerkung: Für ein weiteres mögliches Herantreten an Strings in JavaScript sollte der Artikel über StringView — eine C-ähnliche Representation von Strings basierend auf typisierten Arrays gelesen werden.

Eigenschaften

String.prototype
Ermöglicht das Hinzufügen von Eigenschaften zu einem String-Objekt.

Methoden

String.fromCharCode()
Gibt einen String zurück, der auf Basis der angegebenen Folge von Unicode-Werten erstellt wurde.
String.fromCodePoint()
Gibt einen String zurück, der auf Basis der angegebenen Folge von Code-Points erstellt wurde.
String.raw()
Gibt einen String zurück, der auf Basis eines Raw-Template-Strings erstellt wurde.

Generische String-Methoden

Generische String-Methoden sind nicht Teil des Standards und werden in naher Zukunft entfernt.

Die String-Instanzmethoden stehen nach JavaScript 1.6 (nicht Teil des ECMAScript-Standards) auch in Firefox beim String-Objekt zur Verfügung, um String-Methoden auf ein beliebiges Objekt anzuwenden:

var num = 15;
console.log(String.replace(num, /5/, '2'));

Über die Auflösung von generischen String-Methoden: Warning: String.x is deprecated; use String.prototype.x instead.

Generics stehen auch bei Array-Methoden zur Verfügung.

String-Instanzen

Eigenschaften

String.prototype.constructor
Specifies the function that creates an object's prototype.
String.prototype.length
Reflects the length of the string.
N
Used to access the character in the Nth position where N is a positive integer between 0 and one less than the value of length. These properties are read-only.

Methoden

Nicht HTML-bezogene Methoden

String.prototype.charAt()
Returns the character at the specified index.
String.prototype.charCodeAt()
Returns a number indicating the Unicode value of the character at the given index.
String.prototype.codePointAt()
Returns a non-negative integer that is the UTF-16 encoded code point value at the given position.
String.prototype.concat()
Combines the text of two strings and returns a new string.
String.prototype.includes()
Determines whether one string may be found within another string.
String.prototype.endsWith()
Determines whether a string ends with the characters of another string.
String.prototype.indexOf()
Returns the index within the calling String object of the first occurrence of the specified value, or -1 if not found.
String.prototype.lastIndexOf()
Returns the index within the calling String object of the last occurrence of the specified value, or -1 if not found.
String.prototype.localeCompare()
Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
String.prototype.match()
Used to match a regular expression against a string.
String.prototype.normalize()
Returns the Unicode Normalization Form of the calling string value.
String.prototype.padEnd()
Pads the current string from the end with a given string to create a new string from a given length.
String.prototype.padStart()
Pads the current string from the start with a given string to create a new string from a given length.
String.prototype.quote()
Wraps the string in double quotes (""").
String.prototype.repeat()
Returns a string consisting of the elements of the object repeated the given times.
String.prototype.replace()
Used to find a match between a regular expression and a string, and to replace the matched substring with a new substring.
String.prototype.search()
Executes the search for a match between a regular expression and a specified string.
String.prototype.slice()
Extracts a section of a string and returns a new string.
String.prototype.split()
Splits a String object into an array of strings by separating the string into substrings.
String.prototype.startsWith()
Determines whether a string begins with the characters of another string.
String.prototype.substr()
Returns the characters in a string beginning at the specified location through the specified number of characters.
String.prototype.substring()
Returns the characters in a string between two indexes into the string.
String.prototype.toLocaleLowerCase()
The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as toLowerCase().
String.prototype.toLocaleUpperCase()
The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as toUpperCase().
String.prototype.toLowerCase()
Returns the calling string value converted to lower case.
String.prototype.toSource()
Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.
String.prototype.toString()
Returns a string representing the specified object. Overrides the Object.prototype.toString() method.
String.prototype.toUpperCase()
Returns the calling string value converted to uppercase.
String.prototype.trim()
Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.
String.prototype.trimLeft()
Trims whitespace from the left side of the string.
String.prototype.trimRight()
Trims whitespace from the right side of the string.
String.prototype.valueOf()
Returns the primitive value of the specified object. Overrides the Object.prototype.valueOf() method.
String.prototype[@@iterator]()
Returns a new Iterator object that iterates over the code points of a String value, returning each code point as a String value.

HTML-Wrapper-Methoden

Beispiele

String-Konvertierung

Es ist möglich, String als eine "sicherere" toString()-Alternative zu benutzen, auch, wenn es gewöhnlich weiterhin das zugrundeliegende toString() aufruft. Es funktioniert auch für null, undefined und symbols. Zum Beispiel:

var ausgabeStrings = [];
for (var i = 0, n = eingabeWerte.length; i < n; ++i) {
  ausgabeStrings.push(String(eingabeWerte[i]));
}

Spezifikationen

Spezifikation Status Anmerkung
ECMAScript 1st Edition (ECMA-262) Standard Anfängliche Definition
ECMAScript 5.1 (ECMA-262)
Die Definition von 'String' in dieser Spezifikation.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'String' in dieser Spezifikation.
Standard  
ECMAScript Latest Draft (ECMA-262)
Die Definition von 'String' in dieser Spezifikation.
Lebender Standard  

Browser-Kompatibilität

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Grundlegende Unterstützung Ja Ja Ja Ja Ja Ja
Unicode code point escapes \u{xxxxxx} Ja ?40 ? Ja Ja
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidIE mobileOpera AndroidiOS Safari
Grundlegende Unterstützung Ja Ja Ja Ja Ja Ja Ja
Unicode code point escapes \u{xxxxxx} Ja Ja ? Ja ? Ja Ja

Siehe außerdem

Schlagwörter des Dokuments und Mitwirkende

 Mitwirkende an dieser Seite: posoppis, schlagi123, fscholz
 Zuletzt aktualisiert von: posoppis,