MDN will be in maintenance mode on Thursday September 21st, starting at 10 AM Pacific / 5 PM UTC, for about 1 hour.

Diese Übersetzung ist unvollständig. Bitte helfen Sie, diesen Artikel aus dem Englischen zu übersetzen.

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()
Returns a string created by using the specified sequence of Unicode values.
String.fromCodePoint()
Returns a string created by using the specified sequence of code points.
String.raw()
Returns a string created from a raw template string.

String generic methods

String generics are non-standard, deprecated and will get removed near future. Note that you can not rely on them cross-browser without using the shim that is provided below.

The String instance methods are also available in Firefox as of JavaScript 1.6 (not part of the ECMAScript standard) on the String object for applying String methods to any object:

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

Generics are also available on Array methods.

The following is a shim to provide support to non-supporting browsers:

/*globals define*/
// Assumes all supplied String instance methods already present
// (one may use shims for these if not available)
(function() {
  'use strict';

  var i,
    // We could also build the array of methods with the following, but the
    //   getOwnPropertyNames() method is non-shimable:
    // Object.getOwnPropertyNames(String).filter(function(methodName) {
    //   return typeof String[methodName] === 'function';
    // });
    methods = [
      'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
      'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
      'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
      'toLocaleUpperCase', 'localeCompare', 'match', 'search',
      'replace', 'split', 'substr', 'concat', 'slice'
    ],
    methodCount = methods.length,
    assignStringGeneric = function(methodName) {
      var method = String.prototype[methodName];
      String[methodName] = function(arg1) {
        return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
      };
    };

  for (i = 0; i < methodCount; i++) {
    assignStringGeneric(methods[i]);
  }
}());

String instances

Properties

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.

Methods

Methods unrelated to HTML

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 methods

Examples

String conversion

It's possible to use String as a "safer" toString() alternative, as although it still normally calls the underlying toString(), it also works for null and undefined. For example:

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

Specifications

Specification Status Comment
ECMAScript 1st Edition (ECMA-262) Standard Initial 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 compatibility

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support 1 (Ja) (Ja) (Ja) (Ja)
\u{XXXXXX} (Ja) 40 (40) ? ? (Ja)
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Ja) (Ja) (Ja) (Ja) (Ja) (Ja)
\u{XXXXXX} ? ? 40.0 (40) ? ? ?

See also

Schlagwörter des Dokuments und Mitwirkende

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