String

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

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

Browser-Kompatibilit├Ąt

BCD tables only load in the browser

Siehe au├čerdem