path: root/files/de/web/javascript/reference/global_objects/string/index.html

---
title: String
slug: Web/JavaScript/Reference/Global_Objects/String
tags:
  - ECMAScript 2015
  - JavaScript
  - Reference
  - String
translation_of: Web/JavaScript/Reference/Global_Objects/String
---
<div>{{JSRef}}</div>

<p>Das globale <strong><code>String</code></strong>-Objekt ist ein Konstruktor für Strings, auch Zeichenketten genannt.</p>

<h2 id="Syntax">Syntax</h2>

<p>String-Literale haben folgende Formen:</p>

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

<p>Strings können auch direkt mit dem globalen <code>String</code>-Objekt erzeugt werden:</p>

<pre class="syntaxbox">String(thing)</pre>

<h3 id="Parameter">Parameter</h3>

<dl>
 <dt><code>thing</code></dt>
 <dd>Alles, was in einen String umgewandelt werden kann.</dd>
</dl>

<h3 id="Template-Literale">Template-Literale</h3>

<p>Ab ECMAScript 2015 können String-Literale auch durch sogenannte <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/template_strings">Template-Literale</a> verkörpert werden:</p>

<pre class="syntaxbox">`hallo welt`
`hallo!
 welt!`
`hallo ${wer}`
escape `<a>${wer}</a>`</pre>

<dl>
</dl>

<h3 id="Escape-Notation">Escape-Notation</h3>

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

<table class="standard-table">
 <thead>
  <tr>
   <th scope="col">Code</th>
   <th scope="col">Ausgabe</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>\0</code></td>
   <td>das NULL-Zeichen</td>
  </tr>
  <tr>
   <td><code>\'</code></td>
   <td>einfaches Anführungszeichen</td>
  </tr>
  <tr>
   <td><code>\"</code></td>
   <td>doppeltes Anführungszeichen</td>
  </tr>
  <tr>
   <td><code>\\</code></td>
   <td>Rückwärtsschrägstrich (backslash)</td>
  </tr>
  <tr>
   <td><code>\n</code></td>
   <td>Zeilenumbruch (new line)</td>
  </tr>
  <tr>
   <td><code>\r</code></td>
   <td>Zeilenanfang (carriage return)</td>
  </tr>
  <tr>
   <td><code>\v</code></td>
   <td>vertikaler Tabulator</td>
  </tr>
  <tr>
   <td><code>\t</code></td>
   <td>Tabulator</td>
  </tr>
  <tr>
   <td><code>\b</code></td>
   <td>Backspace</td>
  </tr>
  <tr>
   <td><code>\f</code></td>
   <td>Seitenvorschub (form feed)</td>
  </tr>
  <tr>
   <td><code>\uXXXX</code></td>
   <td>Unicode-Codepoint</td>
  </tr>
  <tr>
   <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code></td>
   <td>Unicode-Codepoint {{experimental_inline}}</td>
  </tr>
  <tr>
   <td><code>\xXX</code></td>
   <td>Latin-1-Zeichen</td>
  </tr>
 </tbody>
</table>

<div class="note">
<p>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.</p>
</div>

<dl>
</dl>

<h3 id="Lange_String-Literale">Lange String-Literale</h3>

<p>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.</p>

<p>Es kann der <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition_()">+</a>-Operator benutzt werden, um auf folgende Weise mehrere Strings aneinanderzuhängen:</p>

<pre class="brush: js">let langerString = "Dies ist ein sehr langer String, der über " +
                 "mehrere Zeilen verteilt werden muss, weil " +
                 "sonst der Code unleserlich ist.";
</pre>

<p>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:</p>

<pre class="brush: js">let langerString = "Dies ist ein sehr langer String, der über \
mehrere Zeilen verteilt werden muss, weil \
sonst der Code unleserlich ist.";
</pre>

<p>Beide Arten erzeugen identische Strings.</p>

<h2 id="Beschreibung">Beschreibung</h2>

<p>Strings sind nützlich, um Daten in Textform zu speichern. Manche der meist benutzten String-Operationen sind es, die {{jsxref("String.length", "length")}} abzufragen, Strings mittels <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">+ und += String-Operatoren</a> zu verbinden, mit der {{jsxref("String.prototype.indexOf()", "indexOf()")}} -Methode die Existenz oder Position von Sub-Strings festzustellen oder Sub-Strings mit der {{jsxref("String.prototype.substring()", "substring()")}}-Methode zu extrahieren.</p>

<h3 id="Zeichenabfrage">Zeichenabfrage</h3>

<p>Es gibt zwei Möglichkeiten auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die {{jsxref("String.prototype.charAt()", "charAt()")}}-Methode:</p>

<pre class="brush: js">return 'Katze'.charAt(1); // gibt "a" zurück
</pre>

<p>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:</p>

<pre class="brush: js">return 'Katze'[1]; // gibt "a" zurück
</pre>

<p>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 {{jsxref("Object.defineProperty()")}} für mehr Informationen.)</p>

<h3 id="Strings_vergleichen">Strings vergleichen</h3>

<p>C-Entwicklern steht die <code>strcmp()</code>-Funktion zur Verfügung, um Strings zu vergleichen. In JavaScript können die <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Vergleichsoperatoren">kleiner-als- und größer-als-Operatoren</a> benutzt werden:</p>

<pre class="brush: js">var a = 'a';
var b = 'b';
if (a &lt; b) { // true
  console.log(a + ' ist geringer als ' + b);
} else if (a &gt; b) {
  console.log(a + ' ist größer als ' + b);
} else {
  console.log(a + ' und ' + b + ' sind gleich.');
}
</pre>

<p>Ein ähnliches Ergebnis kann durch die {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}-Methode erzielt werden, die von <code>String</code>-Instanzen übernommen wird.</p>

<h3 id="Unterscheidung_von_String-Primitives_und_String-Objekten">Unterscheidung von String-Primitives und <code>String</code>-Objekten</h3>

<p>Es ist zu betonen, dass JavaScript zwischen <code>String</code>-Objekten und primitiven String-Werten unterscheidet. (Das selbe gilt für {{jsxref("Boolean")}} und {{jsxref("Global_Objects/Number", "Numbers")}}.)</p>

<p>String-Literale (definiert mit doppelten oder einfachen Anführungszeichen) und Strings, die von<code> String</code>-Aufrufen in einem Nicht-Konstruktor-Kontext (z. B. ohne das {{jsxref("Operators/new", "new")}}-Schlüsselwort zu benutzen) zurückgegeben werden, sind String-Primitives. JavaScript wandelt automatisch Primitives zu <code>String</code>-Objekten um, so dass es möglich ist <code>String</code>-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.</p>

<pre class="brush: js">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"
</pre>

<p>String-Primitives und <code>String</code>-Objekte führen auch bei der Nutzung von {{jsxref("Global_Objects/eval", "eval()")}} zu unterschiedlichen Ergebnissen. An <code>eval</code> übergebene Primitives werden als Quell-Code behandelt; bei <code>String</code>-Objekten wird wie bei allen anderen Objekten das Objekt zurückgegeben. Zum Beispiel:</p>

<pre class="brush: js">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
</pre>

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

<p>Ein <code>String</code>-Objekt kann mit der {{jsxref("String.prototype.valueOf()", "valueOf()")}}-Methode immer zu seiner Primitive-Entsprechung konvertiert werden.</p>

<pre class="brush: js">console.log(eval(s2.valueOf())); // gibt die Zahl 4 zurück
</pre>

<div class="note"><strong>Bemerkung:</strong> Für ein weiteres mögliches Herantreten an Strings in JavaScript sollte der Artikel über <a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — eine C-ähnliche Representation von Strings basierend auf typisierten Arrays</a> gelesen werden.</div>

<h2 id="Eigenschaften">Eigenschaften</h2>

<dl>
 <dt>{{jsxref("String.prototype")}}</dt>
 <dd>Ermöglicht das Hinzufügen von Eigenschaften zu einem <code>String</code>-Objekt.</dd>
</dl>

<h2 id="Methoden">Methoden</h2>

<dl>
 <dt>{{jsxref("String.fromCharCode()")}}</dt>
 <dd>Gibt einen String zurück, der auf Basis der angegebenen Folge von Unicode-Werten erstellt wurde.</dd>
 <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt>
 <dd>Gibt einen String zurück, der auf Basis der angegebenen Folge von Code-Points erstellt wurde.</dd>
 <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt>
 <dd>Gibt einen String zurück, der auf Basis eines Raw-Template-Strings erstellt wurde.</dd>
</dl>

<h2 id="Generische_String-Methoden">Generische <code>String</code>-Methoden</h2>

<div class="warning">
<p><strong>Generische String-Methoden sind nicht Teil des Standards und werden in naher Zukunft entfernt</strong>.</p>
</div>

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

<pre class="brush: js">var num = 15;
console.log(String.replace(num, /5/, '2'));
</pre>

<p>Über die Auflösung von generischen String-Methoden: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_string_generics">Warning: String.x is deprecated; use String.prototype.x instead</a>.</p>

<p>{{jsxref("Global_Objects/Array", "Generics", "#Array_generic_methods", 1)}} stehen auch bei {{jsxref("Array")}}-Methoden zur Verfügung.</p>

<h2 id="String-Instanzen"><code>String</code>-Instanzen</h2>

<h3 id="Eigenschaften_2">Eigenschaften</h3>

<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div>

<h3 id="Methoden_2">Methoden</h3>

<h4 id="Nicht_HTML-bezogene_Methoden">Nicht HTML-bezogene Methoden</h4>

<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div>

<h4 id="HTML-Wrapper-Methoden">HTML-Wrapper-Methoden</h4>

<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div>

<h2 id="Beispiele">Beispiele</h2>

<h3 id="String-Konvertierung">String-Konvertierung</h3>

<p>Es ist möglich, <code>String</code> als eine "sicherere" {{jsxref("String.prototype.toString()", "toString()")}}-Alternative zu benutzen, auch, wenn es gewöhnlich weiterhin das zugrundeliegende <code>toString()</code> aufruft. Es funktioniert auch für {{jsxref("null")}}, {{jsxref("undefined")}} und {{jsxref("Symbol", "symbols")}}. Zum Beispiel:</p>

<pre class="brush: js">var ausgabeStrings = [];
for (var i = 0, n = eingabeWerte.length; i &lt; n; ++i) {
  ausgabeStrings.push(String(eingabeWerte[i]));
}
</pre>

<h2 id="Spezifikationen">Spezifikationen</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Spezifikation</th>
   <th scope="col">Status</th>
   <th scope="col">Anmerkung</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Anfängliche Definition</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-string-objects', 'String')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2>

<p>{{Compat("javascript.builtins.String.String")}}</p>

<h2 id="Siehe_außerdem">Siehe außerdem</h2>

<ul>
 <li>{{domxref("DOMString")}}</li>
 <li><a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — eine C-ähnliche Representation von Strings basierend auf typisierten Arrays</a></li>
 <li><a href="/en-US/docs/Web/API/DOMString/Binary">Binäre Strings</a></li>
</ul>