diff options
Diffstat (limited to 'files/de/web/javascript/reference/global_objects/string')
25 files changed, 4126 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/global_objects/string/charat/index.html b/files/de/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..815eb59bba --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,305 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>charAt()</code></strong>-Methode gibt das Zeichen an einer bestimmten Stelle eines Strings wieder.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.charAt(<var>index</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Eine Zahl zwischen 0 und <code>str.length-1</code>. Ist kein <code>index</code> gegeben, ist dieser automatisch 0.</dd> +</dl> + +<h3 id="Wiedergegebener_Wert">Wiedergegebener Wert</h3> + +<p>Ein String, der das Zeichen an der angegebenen <code>index</code>-Stelle wiedergibt. Wenn <code>index</code> außerhalb der Reichweite liegt, wird ein leerer String zurückgegeben.<br> + </p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Zeichen in einem String werden von links nach rechts indexiert. Der Index des ersten Zeichens ist 0, der Index des letzten Zeichens eines Strings namens <code>stringName</code> ist<code> stringName.length - 1</code>.</p> + +<p>Wenn kein Index bereitgestellt wird, ist dieser standardmäßig 0.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Wiedergabe_von_Zeichen_an_verschiedenen_Stellen_eines_Strings">Wiedergabe von Zeichen an verschiedenen Stellen eines Strings</h3> + +<p>Das folgende Beispiel gibt Zeichen an verschiedenen Orten im String "<code>Brave new world</code>" wieder:</p> + +<pre class="brush: js">var anyString = 'Brave new world'; +console.log("Das Zeichen bei Index 0 ist '" + anyString.charAt() + "'"); +// kein Index definiert, 0 als Standard genutzt + +console.log("Das Zeichen bei Index 0 ist '" + anyString.charAt(0) + "'"); +console.log("Das Zeichen bei Index 1 ist '" + anyString.charAt(1) + "'"); +console.log("Das Zeichen bei Index 2 ist '" + anyString.charAt(2) + "'"); +console.log("Das Zeichen bei Index 3 ist '" + anyString.charAt(3) + "'"); +console.log("Das Zeichen bei Index 4 ist '" + anyString.charAt(4) + "'"); +console.log("Das Zeichen bei Index 999 ist '" + anyString.charAt(999) + "'"); +</pre> + +<p>Diese Zeilen geben folgendes wieder:</p> + +<pre class="brush: js">Das Zeichen bei Index 0 ist 'B' +Das Zeichen bei Index 0 ist 'B' +Das Zeichen bei Index 1 ist 'r' +Das Zeichen bei Index 2 ist 'a' +Das Zeichen bei Index 3 ist 'v' +Das Zeichen bei Index 4 ist 'e' +Das Zeichen bei Index 999 ist '' +</pre> + +<h3 id="Erhalten_von_vollständigen_Zeichen">Erhalten von vollständigen Zeichen</h3> + +<p>Der folgende Code versichert, dass der Gebrauch eines String-Loops immer das vollständige Zeichen wiedergibt - auch wenn der String Zeichen enthält, die nicht auf der mehrsprachigen Basisebene (MBE) vorhanden sind.</p> + +<pre class="brush: js">var str = 'A \uD87E\uDC04 Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich +for (var i = 0, chr; i < str.length; i++) { + if ((chr = getWholeChar(str, i)) === false) { + continue; + } + // Übernehme diese Zeile zu Beginn jedes Loops, + // gib den kompletten String und Iterator an + // und gebe eine Variable wieder, die das individuelle Zeichen wiederspiegelt. + + console.log(chr); +} + +function getWholeChar(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return str.charAt(i); + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return str.charAt(i) + str.charAt(i + 1); + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // We can pass over low surrogates now as the second component + // in a pair which we have already processed + return false; +} +</pre> + +<p>In einer ECMAScript 2016-Umgebung, welche destruktive Benennung erlaubt, ist eine bündigere und zu gewissem Grad flexiblere Alternative möglich, da es automatisch eine Erhöhung der entsprechenden Variable vornimmt (wenn das Zeichen<br> + ein Ersatzpaar ist).</p> + +<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich +for (var i = 0, chr; i < str.length; i++) { + [chr, i] = getWholeCharAndI(str, i); + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning an array with the individual character + // and 'i' value (only changed if a surrogate pair) + // Übernehme diese Zeile zu Beginn jedes Loops, + // gib den kompletten String und Iterator an + // und gebe einen Array wieder, der die individuellen Zeichen und 'i'-Wert wiederspiegelt + // (nur geändert, wenn Ersatzpaar). + + console.log(chr); +} + +function getWholeCharAndI(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position nicht gefunden + } + if (code < 0xD800 || code > 0xDFFF) { + return [str.charAt(i), i]; // Normales Zeichen, 'i' bleibt gleich + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return [str.charAt(i) + str.charAt(i + 1), i + 1]; + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private surrogates + // as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // Return the next character instead (and increment) + return [str.charAt(i + 1), i + 1]; +} +</pre> + +<h3 id="Korrigiere_charAt()_um_Zeichen_der_nicht_mehrsprachigen_Basisebene_(MBE)_zu_unterstützen">Korrigiere <code>charAt()</code>, um Zeichen der nicht mehrsprachigen Basisebene (MBE) zu unterstützen</h3> + +<p><br> + Das obige Beispiel dürfte häufiger für diejenigen hilfreich sein, die nicht MBE-Zeichen unterstützen möchten (da man nicht wissen muss, wo nicht MBE-Zeichen vorkommen). Falls man wünscht (durch Angabe eines Indexwerts) die Ersatzpaare innerhalb eines Strings als Einzelcharakter zu behandeln, kann man folgendes nutzen:</p> + +<pre class="brush: js">function fixedCharAt(str, idx) { + var ret = ''; + str += ''; + var end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } else { + break; + } + } + + if (idx >= end || idx < 0) { + return ''; + } + + ret += str.charAt(idx); + + if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) { + // Gehe eins weiter, da eins der Zeichen Teil eines Ersatzpaares ist + ret += str.charAt(idx + 1); + } + return ret; +} +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>erste Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Standardunterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome für Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td> Standardunterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/concat/index.html b/files/de/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..548135330f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>concat()</code></strong> Methode vereint den Text von einem oder mehreren Strings und gibt einen neuen String zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.concat(<var>string2</var>[, <var>string3</var>, ..., <var>stringN</var>])</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Strings die zu einem neuen String vereint werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der die Texte der Strings hintereinander enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>concat()</code> Funktion kombiniert die Texte von einem oder mehreren Strings und gibt einen neuen String zurück. Das ändern des Textes eines Strings hat keine Auswirkungen auf die anderen Strings.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_concat()">Einsatz von <code>concat()</code></h3> + +<p>Das folgende Beispiel kombiniert Strings in einen neuen String.</p> + +<pre class="brush: js">var hello = 'Hello, '; +console.log(hello.concat('Kevin', ' have a nice day.')); + +/* Hello, Kevin have a nice day. */ +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Es wird ausdrücklich empfohlen {{jsxref("Operators/Assignment_Operators", "Zuweisungsoperatoren", "", 1)}} (<code>+</code>, <code>+=</code>) statt der <code>concat()</code> Methode zu benutzen. Sie hierfür diesen <a href="http://jsperf.com/concat-vs-plus-vs-join">Performancetest</a>.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Assignment operators", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/endswith/index.html b/files/de/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..73f37a9692 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,148 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/endsWith +tags: + - JavaScript + - Méthode + - Prototyp + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>endsWith()</code></strong> bestimmt, ob ein String das Ende eines anderen Strings ist, und liefert entsprechend true oder false zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.endsWith(<var>suchString</var>[, <var>position</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>suchString</code></dt> + <dd>Der String, nach dem am Ende von str gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Durchsucht str, als wäre es nur <strong>position</strong> Zeichen lang. Standardmäßig wird die Länge von str benutzt, wird automatisch auf die Länge von str gebracht, falls diese überschritten wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><code>Falls suchString das Ende von str ist, wird </code><strong><code>true</code></strong> zurückgeliefert, andernfalls wird <strong><code>false</code></strong> zurückgeliefert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode bestimmt, ob ein String das Ende eines anderen Strings ist. Die Methode unterscheidet zwischen Groß- und Kleinschreibung.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_endsWith()">Benutzung von <code>endsWith()</code></h3> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; + +console.log(str.endsWith('question.')); // true +console.log(str.endsWith('to be')); // false +console.log(str.endsWith('to be', 19)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode wurde der ECMAScript6-Spezifikation hinzugefügt und könnte noch nicht in allen JavaScript-Implementierungen verfügbar sein. Mithilfe des folgenden Code-Stücks kann die Methode auch bei fehlender Implementierung genutzt werden:</p> + +<pre class="brush: js">if (!String.prototype.endsWith) { + String.prototype.endsWith = function(searchString, position) { + var subjectString = this.toString(); + if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) { + position = subjectString.length; + } + position -= searchString.length; + var lastIndex = subjectString.indexOf(searchString, position); + return lastIndex !== -1 && lastIndex === position; + }; +} +</pre> + +<h2 id="Spezifikation">Spezifikation</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatChrome("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..1ddc144e28 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,134 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<div>{{JSRef}}</div> + +<p>Die statische Methode <strong><code>String.fromCharCode()</code></strong> gibt einen String zurück, der mit der angegebenen Folge von Unicode-Zeichen erstellt wurde.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Eine Folge von Zahlen als Unicode-Werte. Der Wertebreich liegt zwischen 0 und 65535 (0xFFFF). Zahlen, welche größer als 0xFFFF sind werden gekürzt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der die den Unicode-Werten zugeordneten Zeichen enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode gibt einen String zurück und kein {{jsxref("String")}} Objekt.</p> + +<p>Da <code>fromCharCode()</code> eine statische Methode von {{jsxref("String")}} ist, wird sie immer als <code>String.fromCharCode() </code>angewandt und nicht als Methode eines {{jsxref("String")}} Objekts, das erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_fromCharCode()">Verwendung von <code>fromCharCode()</code></h3> + +<pre>String.fromCharCode(65, 66, 67); // gibt "ABC" zurück +String.fromCharCode(0x2014); // gibt "—" zurück +String.fromCharCode(0x12014); // gibt auch "—" zurück. Die Ziffer 1 wird weggekürzt und ignoriert.</pre> + +<h2 id="Verwendung_mit_höheren_Werten">Verwendung mit höheren Werten</h2> + +<p>Die meisten Unicode-Werte können mit einer 16-bit-Nummer dargestellt werden (wie in den Anfängen der JavaScript-Standardisierung erwartet) und <code>fromCharCode()</code> kann verwendet werden, um ein einzelnes Zeichen für die meisten gängigen Werde (d.h. UCS-2 Werte, die ein Subset von UTF-16 mit den am häufigsten vorkommenden Zeichen bilden) darzustellen. Um jedoch ALLE gültigen Unicode-Werte (bis zu 21 bits) darzustellen, ist <code>fromCharCode()</code> allein nicht ausreichend. Da die höheren Code Point Zeichen zwei "Ersatznummern" (mit niedrigerem Wert) verwenden, um ein einzelnes Zeichen darzustellen, kann {{jsxref("String.fromCodePoint()")}} (Teil des ES2015 Standards) verwendet werden, um ein solches Paar und damit auch diese Zeichen mit höheren Werten darzustellen.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Erstdefinition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/includes/index.html b/files/de/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..ee3aa6564c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,131 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/String/includes +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>includes()-</strong></code>Methode gibt an, ob ein String innerhalb eines anderen Strings gefunden wird und gibt dabei <code>true</code> oder <code>false</code> wieder.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>Ein String, der innerhalb eines anderen Strings gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Die Position innerhalb des besuchten Strings durch <code>searchString</code>; Standard ist 0.</dd> +</dl> + +<h3 id="Wertwiedergabe">Wertwiedergabe</h3> + +<p><strong><code>true</code></strong>, wenn der String den gesuchten String enthält, andernfalls <strong><code>false</code></strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode lässt dich feststellen, ob ein String einen anderen String beinhaltet.</p> + +<h3 id="Achtung_auf_Groß-_Kleinschreibung">Achtung auf Groß-, Kleinschreibung</h3> + +<p>Bei der <code>includes()</code>-Methode muss auf Groß- und Kleinschreibung geachtet werden.<br> + Zum Beispiel gibt die folgende Darstellung <code>false</code> aus:</p> + +<pre class="brush: js">'Blue Whale'.includes('blue'); // gibt false wieder +</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_includes">Einsatz von <code>includes()</code></h3> + +<pre class="brush: js">var str = 'Sein oder nicht sein, das ist hier die Frage.'; + +console.log(str.includes('Sein')); // true +console.log(str.includes('Frage')); // true +console.log(str.includes('nicht da')); // false +console.log(str.includes('Sein', 1)); // false +console.log(str.includes('SEIN')); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode wurde den ECMAScript 6 Spezifikationen hinzugefügt und könnte nicht in allen JavaScript-Umgebunden vorhanden sein. Jedoch kann man diesen Polyfill nutzen:</p> + +<pre class="brush: js">if (!String.prototype.includes) { + String.prototype.includes = function(search, start) { + 'use strict'; + if (typeof start !== 'number') { + start = 0; + } + + if (start + search.length > this.length) { + return false; + } else { + return this.indexOf(search, start) !== -1; + } + }; +} + +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikationen</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>erste Definition</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.includes")}}</p> + +<h2 id="String.prototype.contains">String.prototype.contains</h2> + +<p>In Firefox 18 - 39 hieß diese Methode <code>contains()</code>. Es wurde zu <code>includes()</code> ({{bug(1102219)}}) wegen folgender Gründe umbenannt:<br> + <br> + Es wurde gemeldet, dass manche Webseiten, die MooTools 1.2 nutzen mit Firefox 17 nicht mehr funktionieren. Diese Version von MooTools kontrolliert, ob <code>String.prototype.contains()</code> existiert und, wenn nicht, fügt es seine eigene Funktion hinzu.<br> + Mit der Einführung dieser Funktion in Firefox 17 wurde das Verhalten dieser Kontrolle geändert, sodass auf MooTools <code>String.prototype.contains()</code> basierender Code funktionsunfähig wurde.<br> + Aufgrund dessen wurde die Implementierung in Firefox 17 <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8">abgeschaltet </a>und <code>String.prototype.contains()</code> war in Firefox 18 nutzbar. Ermöglicht wurde dies durch die <a href="http://mootools.net/blog/2013/02/19/mootools-1-2-6-released">Veröffentlichung von MooTools Version 1.2.6.</a></p> + +<p>MooTools 1.3 erzwingt die Nutzung der eigenen Version von <code>String.prototype.contains()</code>, demnach sollten Webseiten, die abhängig davon sind, weiterhin funktionieren. Beachte jedoch, dass sich die <a href="http://mootools.net/core/docs/1.3.2/Types/String#String-method:-contains">MooTools 1.3 Signatur </a>von der ECMAScript 6 Signatur für diese Methode unterscheidet.</p> + +<p>Später änderte <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ die Signatur, um sie dem ES2015 Standard anzupassen.</a></p> + +<p><br> + In Firefox 48 wurde <code>String.prototype.contains()</code> entfernt. Nutze lediglich <code>String.prototype.includes()</code>.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.endsWith()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/index.html b/files/de/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..35faef0223 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,310 @@ +--- +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 < 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.'); +} +</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 < 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> diff --git a/files/de/web/javascript/reference/global_objects/string/indexof/index.html b/files/de/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..dc36abfae8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,200 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/indexOf +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>indexOf()</code></strong> Methode gibt den Index der Zeichenkette innerhalb des aufrufenden {{jsxref("Global_Objects/String", "String")}} Objekts des ersten Vorkommnis des angegebenen Wertes beginnend bei <code>fromIndex</code> zurück. Gibt -1 zurück, wenn der Wert nicht gefunden wurde.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.indexOf(<var>searchValue</var>[, <var>fromIndex</var>]</code>)</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Ein String der den zu suchenden Wert repräsentiert.</dd> + <dt><code>fromIndex</code> {{optional_inline}}</dt> + <dd>Der Index, von dem angefangen wird vorwärts im String zu suchen. Der Standardwert ist 0, so dass der ganze String durchsucht wird. Wenn <code>fromIndex < 0</code> ist, wird der ganze String durchsucht. Wenn <code>fromIndex >= str.length</code> ist, wird der String nicht durchsucht und -1 wird zurückgegeben. Die Ausnahme ist, wenn für <code>searchValue</code> ein leeren String eingesetzt wird, dann wird <code>str.length</code> zurückgegeben.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Index des ersten Vorkommens des gesuchten Wertes; <strong>-1</strong> wenn der Wert nicht gefunden wurde.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die Zeichen in einem String sind von links nach rechts nummeriert. Der Index des ersten Zeichens ist 0, und der Index des letzten Zeichens eines Strings mit Namen <code>stringName</code><code> </code>ist <code>stringName.length - 1</code>.</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue'); // returns 0 +'Blue Whale'.indexOf('Blute'); // returns -1 +'Blue Whale'.indexOf('Whale', 0); // returns 5 +'Blue Whale'.indexOf('Whale', 5); // returns 5 +'Blue Whale'.indexOf('', 9); // returns 9 +'Blue Whale'.indexOf('', 10); // returns 10 +'Blue Whale'.indexOf('', 11); // returns 10 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity">Groß- und Kleinschreibung</h3> + +<p>Die <code>indexOf()</code> Methode unterscheidet zwischen Groß- und Kleinschreibung. Zum Beispiel gibt die folgende Zeile -1 zurück:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('blue'); // returns -1 +</pre> + +<h3 id="Vorkommnisse_prüfen">Vorkommnisse prüfen</h3> + +<p>Zu beachten ist, dass '0' nicht zu <code>true</code> und '-1' nicht zu <code>false</code> ausgewertet wird. Deswegen ist der korrekte weg zum überprüfen, ob ein String in einem anderen String existiert, der folgende:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue') != -1; // true +'Blue Whale'.indexOf('Bloe') != -1; // false +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Einsatz von <code>indexOf()</code> <code>und lastIndexOf()</code></h3> + +<p>Die folgenden Beispiele benutzen <code>indexOf()</code> und {{jsxref("String.prototype.lastIndexOf()", "lastIndexOf()")}}, um Werte im String <code>"Brave new world"</code> zu finden.</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log('The index of the first w from the beginning is ' + anyString.indexOf('w')); +// Displays 8 +console.log('The index of the first w from the end is ' + anyString.lastIndexOf('w')); +// Displays 10 + +console.log('The index of "new" from the beginning is ' + anyString.indexOf('new')); +// Displays 6 +console.log('The index of "new" from the end is ' + anyString.lastIndexOf('new')); +// Displays 6 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity"><code>indexOf()</code> und Groß- und Kleinschreibung</h3> + +<p>Das folgende Beispiel definiert zwei Strings. Die Variablen enthalten den selben String, außer dass der zweite String Großbuchstaben enthält. Die erste {{domxref("console.log()")}} Methode zeigt 19. Da die <code>indexOf()</code> Methode Groß- und Kleinschreibung unterscheidet, wird der String<code>"cheddar"</code> im String <code>myCapString</code> nicht gefunden. Deshalb gibt die zweite <code>console.log()</code> Methode -1 zurück.</p> + +<pre class="brush: js">var myString = 'brie, pepper jack, cheddar'; +var myCapString = 'Brie, Pepper Jack, Cheddar'; + +console.log('myString.indexOf("cheddar") is ' + myString.indexOf('cheddar')); +// Displays 19 +console.log('myCapString.indexOf("cheddar") is ' + myCapString.indexOf('cheddar')); +// Displays -1 +</pre> + +<h3 id="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Einsatz von <code>indexOf()</code>, um das Vorkommen eines Buchstaben in einem String zu zählen</h3> + +<p>Das folgende Beispiel setzt <code>count</code> auf die Anzahl der Vorkommnisse des Buchstaben <code>e</code> in dem String <code>str</code>:</p> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; +var count = 0; +var pos = str.indexOf('e'); + +while (pos != -1) { + count++; + pos = str.indexOf('e', pos + 1); +} + +console.log(count); // displays 4 +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..b6c6f3a548 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,148 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Zusammenfassung</h2> + +<p>Die <strong><code>lastIndexOf()</code></strong> Methode gibt den Index des letzten Vorkommnisses des angegebenen Wertes innerhalb des aufrufenden {{jsxref("Global_Objects/String", "Strings")}} Objekts zurück, oder -1, wenn der Wert nicht gefunden wurde. Der aufrufende String wird rückwärts durchsucht, beginnend beim <code>fromIndex</code>. </p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Ein String mit dem Wert, nach dem gesucht werden soll.</dd> + <dt><code>fromIndex</code></dt> + <dd>Optional. Die Position im aufrufenden String, ab der gesucht rückwärts werden soll. The Position wird gezählt von links nach rechts. Gesucht wird von dieser Position ab nach links. Diese kann jeden Integerwert annehmen. Der Standartwert ist <code>str.length</code>. Wenn der Wert negativ ist, wird 0 verwendet. Wenn <code>fromIndex > str.length</code>, wird <code>str.length </code>statt <code>fromIndex</code> benutzt.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Zeichen in einem String werden von links nach rechts gezählt. Der Index des ersten Zeichens ist 0, der Index des letzten Zeichens ist <code>stringName.length - 1</code>.</p> + +<pre class="brush: js">'canal'.lastIndexOf('a'); // returns 3 +'canal'.lastIndexOf('a', 2); // returns 1 +'canal'.lastIndexOf('a', 0); // returns -1 +'canal'.lastIndexOf('x'); // returns -1 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity">Groß- und Kleinschreibung</h3> + +<p>Die <code>lastIndexOf() </code>Methode unterscheidet zwischen Groß- und Kleinschreibung. Der folgende Ausdruck gibt zum Beispiel <code>-1</code> zurück.</p> + +<pre class="brush: js">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // returns -1 +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Beispiel: Benutzung von <code>indexOf()</code> und <code>lastIndexOf()</code></h3> + +<p>Das folgende Beispiel verwendet {{jsxref("String.prototype.indexOf()", "indexOf()")}} und <code>lastIndexOf(),</code> um Werte im String <code>"Brave new world" zu finden</code>.</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log('The index of the first w from the beginning is ' + anyString.indexOf('w')); +// Displays 8 +console.log('The index of the first w from the end is ' + anyString.lastIndexOf('w')); +// Displays 10 + +console.log('The index of "new" from the beginning is ' + anyString.indexOf('new')); +// Displays 6 +console.log('The index of "new" from the end is ' + anyString.lastIndexOf('new')); +// Displays 6 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Links</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/length/index.html b/files/de/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..555d22094a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,87 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Global_Objects/String/length +tags: + - JavaScript + - Property + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>length</code></strong> Eigenschaft repräsentiert die Länge eines Strings.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.length</code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <strong><code>length</code></strong> Eigenschaft gibt die Anzahl der Codeteile des Strings zurück. Javascript verwendet {{interwiki("wikipedia", "UTF-16")}}. , also einen 16-Bit Code zur Kodierung der meisten Zeichen, aber zur Darstellung weniger verbreiteter Zeichen werden 2 Codes benötigt. Es ist also durchaus möglich, dass der zurückgegebene Wert nicht der Anzahl der Zeichen in einem String entspricht.</p> + +<p>ECMAScript 2016 (ed. 7) Spezifikation definiert eine maximale Länge von <code>2<sup>53</sup> - 1 </code>Elementen.<br> + Vor dieser Spezifikation war keine maximale Länge an Elementen definiert.</p> + +<p class="syntaxbox">Ein leerer String hat die Länge 0.</p> + +<p>Die statische String-Eigenschaft gibt den Wert 1 zurück.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Basic_usage" name="Example:_Basic_usage">Grundlegende Nutzung</h3> + +<pre class="brush: js">var str = 'Mozilla'; +var leerstr = ''; + +console.log('Mozilla ist ' + str.length + ' Zeichen lang'); +/* "Mozilla ist 7 Zeichen lang" */ + +console.log('Der leere String hat eine Länge von ' + leerstr.length + 'Zeichen'); +/* "Der leere String hat eine Länge von 0 Zeichen" */ +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Deinition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.length")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li><a class="external" href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/match/index.html b/files/de/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..27bfac9c75 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Global_Objects/String/match +tags: + - JavaScript + - Method + - Property + - Reference + - Regular Expression + - String + - match + - Übereinstimmung +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +<div>{{JSRef}}</div> + +<p><strong><code>match()</code></strong> gibt zurück, wo ein regulärer Ausdruck in einem String enthalten ist. </p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.match(<var>regexp</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein regulärer Ausdruck. Falls <code>regexp</code> kein Objekt vom Typ {{jsxref("RegExp")}} ist wird es mit Hilfe von <code>new RegExp(obj)</code> konvertiert. Falls dieser Parameter nicht übergeben wird, wird ein {{jsxref("Array")}} mit einem leeren {{jsxref("String")}} zurückgegben: [""].</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Es wird ein {{jsxref("Array")}} zurückgegeben, das als erstes Element den gesamten übereinstimmenden String enthält, gefolgt von allen weiteren Treffern, die in Klammern angegeben wurden. Falls keine Übereinstimmungen gefunden wurden, wird {{jsxref("null")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Falls der reguläre Ausdruck nicht den Modifikator <code>g</code> enthält, verhält sich <strong><code>match()</code> </strong>wie {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}. Im zurückgegebenen {{jsxref("Array")}} sind zusätzlich die propertys <code>input</code> und <code>index</code> enthalten. <code>input</code> ist gleich dem zu durchsuchenden String, <code>index</code> enthält den Index der Übereinstimmung.</p> + +<p>Falls der <code>g</code> Modifikator im regulären Ausdruck enthalten ist, wird ein {{jsxref("Array")}} mit allen übereinstimmenden Substrings zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_match">Verwendung von <code>match()</code></h3> + +<p>Im folgenden Beispiel wird <strong><code>match()</code></strong> verwendet um <code>'Kapitel'</code> und anschließend eine oder mehrere Zahlen, gefolgt von einem Punkt und einer Zahl, 0 oder mehrmals zu finden. Der reguläre Ausdruck enthält den <code>i</code> Modifikator und unterscheidet somit nicht zwischen Groß- und Kleinschreibung.</p> + +<pre class="brush: js notranslate">var str = 'Fuer mehr Informationen siehe Kapitel 3.4.5.1'; +var re = /siehe (kapitel \d+(\.\d)*)/i; +var found = str.match(re); + +console.log(found); + +// gibt folgendes auf der Konsole aus: +// [ 'siehe Kapitel 3.4.5.1', +// 'Kapitel 3.4.5.1', +// '.1', +// index: 22, +// input: 'Fuer mehr Informationen siehe Kapitel 3.4.5.1' ] +</pre> + +<h3 id="Verwendung_von_match_mit_den_i_und_g_Modifikatoren">Verwendung von <code>match()</code> mit den <code>i</code> und <code>g</code> Modifikatoren</h3> + +<p>Die Buchstaben von A - E und von a - e werden auf der Konsole ausgegeben.</p> + +<pre class="brush: js notranslate">var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; +var regexp = /[A-E]/gi; +var matches_array = str.match(regexp); + +console.log(matches_array); +// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e'] +</pre> + +<h3 id="match_ohne_Parameter"><code>match()</code> ohne Parameter</h3> + +<pre class="brush: js notranslate">var str = "Nichts kommt von nichts."; + +str.match(); +// [""]</pre> + +<h3 id="Verwendung_mit_einem_nicht_regulären_Ausdruck">Verwendung mit einem nicht regulären Ausdruck</h3> + +<p>Falls ein String oder eine Zahl anstatt eines regulären Ausdrucks übergeben wird, wird der Parameter in einen {{jsxref("RegExp", "regulären Ausdruck")}} konvertiert. Ist es eine positive Zahl mit Vorzeichen, wird das positive Vorzeichen ignoriert.</p> + +<pre class="brush: js notranslate">var str1 = "NaN bedeutet not a number. Infinity enthält -Infinity and +Infinity in JavaScript.", + str2 = "Zahlen: 1, 6, 3", + str3 = "null ist ein Datentyp."; + +str1.match("number"); // ["number"] +str1.match(NaN); // ["NaN"] +str1.match(Infinity); // ["Infinity"] +str1.match(+Infinity); // ["Infinity"] +str1.match(-Infinity); // ["-Infinity"] +str2.match(6); // ["6"] +str2.match(+3); // ["3"] +str3.match(null); // ["null"]</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">Extras</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Anfangsdefinition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.String.match")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/prototype/index.html b/files/de/web/javascript/reference/global_objects/string/prototype/index.html new file mode 100644 index 0000000000..e2c896b98d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/prototype/index.html @@ -0,0 +1,189 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +tags: + - Eigentum + - JavaScript + - Prototyp + - Referenz + - Strang + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p><font><font>Die </font></font><strong><code>String.prototype</code></strong><font><font>Eigenschaft repräsentiert das Prototypobjekt {{jsxref ("String")}}.</font></font></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung"><font><font>Beschreibung</font></font></h2> + +<p><font><font>Alle {{jsxref ("String")}} Instanzen erben von </font></font><code>String.prototype</code><font><font>. </font><font>Änderungen am </font></font><code>String</code><font><font>Prototypobjekt werden an alle Instanzen von {{jsxref ("String")}} weitergegeben.</font></font></p> + +<h2 id="Eigenschaften"><font><font>Eigenschaften</font></font></h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd><font><font>Gibt die Funktion an, mit der der Prototyp eines Objekts erstellt wird.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.length")}}</font></font></dt> + <dd><font><font>Reflektiert die Länge der Zeichenfolge.</font></font></dd> + <dt><code><em>N</em></code></dt> + <dd><font><font>Wird verwendet, um auf das Zeichen an der </font></font><em><font><font>N-</font></font></em><font><font> ten Position </font><font>zuzugreifen, </font><font>wobei </font></font><em><font><font>N</font></font></em><font><font> eine ganze Zahl zwischen 0 und eins ist, die kleiner als der Wert von {{jsxref ("String.length", "length")} ist. </font><font>Diese Eigenschaften sind schreibgeschützt.</font></font></dd> +</dl> + +<p>Methods</p> + +<h2 id="Methoden"><font><font>Methoden</font></font></h2> + +<h3 id="Methoden_die_nichts_mit_HTML_zu_tun_haben"><font><font>Methoden, die nichts mit HTML zu tun haben</font></font></h3> + +<dl> + <dt><font><font>{{jsxref ("String.prototype.charAt ()")}}</font></font></dt> + <dd><font><font>Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.charCodeAt ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zahl zurück, die der UTF-16-Code-Einheitswert am angegebenen Index ist.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.codePointAt ()")}}</font></font></dt> + <dd><font><font>Gibt eine nicht negative Ganzzahl zurück, die der Codepunktwert des UTF-16-codierten Codepunkts ab dem angegebenen Index ist.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.concat ()")}}</font></font></dt> + <dd><font><font>Kombiniert den Text zweier Zeichenfolgen und gibt eine neue Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.includes ()")}}</font></font></dt> + <dd><font><font>Legt fest, ob eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden darf.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.endsWith ()")}}</font></font></dt> + <dd><font><font>Bestimmt, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge endet.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.indexOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des ersten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.lastIndexOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des letzten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.localeCompare ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zahl zurück, die angibt, ob eine Referenzzeichenfolge vor oder nach der angegebenen Zeichenfolge in Sortierreihenfolge steht oder mit dieser übereinstimmt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.match ()")}}</font></font></dt> + <dd><font><font>Wird verwendet, um einen regulären Ausdruck mit einer Zeichenfolge abzugleichen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.matchAll ()")}}</font></font></dt> + <dd><font><font>Gibt einen Iterator aller Übereinstimmungen zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.normalize ()")}}</font></font></dt> + <dd><font><font>Gibt die Unicode-Normalisierungsform des aufrufenden Zeichenfolgenwerts zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.padEnd ()")}}</font></font></dt> + <dd><font><font>Füllt die aktuelle Zeichenfolge am Ende mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.padStart ()")}}</font></font></dt> + <dd><font><font>Füllt die aktuelle Zeichenfolge von Anfang an mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.</font></font></dd> + <dt><s><font><font>{{jsxref ("String.prototype.quote ()")}} {{obsolete_inline}}</font></font></s></dt> + <dd><s><font><font>Umschließt die Zeichenfolge in doppelte Anführungszeichen (" </font></font><code>"</code><font><font>").</font></font></s></dd> + <dt><font><font>{{jsxref ("String.prototype.repeat ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zeichenfolge zurück, die aus den Elementen des Objekts besteht, die zu den angegebenen Zeiten wiederholt wurden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.replace ()")}}</font></font></dt> + <dd><font><font>Wird verwendet, um eine Übereinstimmung zwischen einem regulären Ausdruck und einer Zeichenfolge zu finden und die übereinstimmende Teilzeichenfolge durch eine neue Teilzeichenfolge zu ersetzen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.search ()")}}</font></font></dt> + <dd><font><font>Führt die Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck und einer angegebenen Zeichenfolge aus.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.slice ()")}}</font></font></dt> + <dd><font><font>Extrahiert einen Abschnitt einer Zeichenfolge und gibt eine neue Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.split ()")}}</font></font></dt> + <dd><font><font>Teilt ein {{jsxref ("Global_Objects / String", "String")}} -Objekt in ein Array von Zeichenfolgen auf, indem die Zeichenfolge in Teilzeichenfolgen aufgeteilt wird.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.startsWith ()")}}</font></font></dt> + <dd><font><font>Legt fest, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge beginnt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.substr ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>Gibt die Zeichen in einer Zeichenfolge zurück, die an der angegebenen Position mit der angegebenen Anzahl von Zeichen beginnt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.substring ()")}}</font></font></dt> + <dd><font><font>Gibt die Zeichen in einer Zeichenfolge zwischen zwei Indizes in die Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLocaleLowerCase ()")}}</font></font></dt> + <dd><font><font>Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben konvertiert. </font><font>Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toLowerCase ()", "toLowerCase ()")}} zurückgegeben.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLocaleUpperCase ()")}}</font></font></dt> + <dd><font><font>Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben umgewandelt. </font><font>Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toUpperCase ()", "toUpperCase ()")}} zurückgegeben.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLowerCase ()")}}</font></font></dt> + <dd><font><font>Gibt den aufrufenden Zeichenfolgenwert zurück, der in Kleinbuchstaben konvertiert wurde.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toSource ()")}} {{non-standard_inline}}</font></font></dt> + <dd><font><font>Gibt ein Objektliteral zurück, das das angegebene Objekt darstellt. </font><font>Mit diesem Wert können Sie ein neues Objekt erstellen. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.toSource ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toString ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zeichenfolge zurück, die das angegebene Objekt darstellt. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.toString ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toUpperCase ()")}}</font></font></dt> + <dd><font><font>Gibt den aufrufenden Zeichenfolgenwert zurück, der in Großbuchstaben konvertiert wurde.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trim ()")}}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Anfang und Ende der Zeichenfolge ab. </font><font>Teil des ECMAScript 5-Standards.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trimStart ()")}}</font></font><br> + <font><font>{{jsxref ("String.prototype.trimLeft ()")}}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Anfang der Zeichenfolge ab.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trimEnd ()")}}</font></font><br> + <font><font>{{jsxref ("String.prototype.trimRight ()")}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Ende der Zeichenfolge ab.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.valueOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Grundwert des angegebenen Objekts zurück. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.valueOf ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype. @@ iterator ()", "String.prototype [@@ iterator] ()")}}</font></font></dt> + <dd><font><font>Gibt ein neues </font></font><code>Iterator</code><font><font>Objekt zurück, das die Codepunkte eines String-Werts durchläuft und jeden Codepunkt als String-Wert zurückgibt.</font></font></dd> +</dl> + +<h3 id="HTML-Wrapper-Methoden"><font><font>HTML-Wrapper-Methoden</font></font></h3> + +<p><font><font>Diese Methoden sind nur eingeschränkt einsetzbar, da sie nur einen Teil der verfügbaren HTML-Tags und -Attribute bereitstellen.</font></font></p> + +<dl> + <dt><font><font>{{jsxref ("String.prototype.anchor ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("name", "a", "<a name=\"name\">")}} (Hypertext-Ziel)</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.big ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("big")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.blink ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("blinken")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.bold ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("b")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fixed ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("tt")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fontcolor ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("color", "font", "<font color = \" color \ ">")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fontsize ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("size", "font", "<font size = \" size \ ">")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.italics ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("i")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.link ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("href", "a", "<a href=\"url\">")}} (Link zu URL)</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.small ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("small")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.strike ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("strike")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.sub ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("sub")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.sup ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("sup")}}</font></font></dd> +</dl> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Anfangsdefinition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität"><font><font>Browser-Kompatibilität</font></font></h2> + +<p class="hidden"> <font><font>Die Kompatibilitätstabelle auf dieser Seite wird aus strukturierten Daten generiert. </font><font>Wenn Sie zu den Daten beitragen möchten, lesen Sie bitte </font></font><a href="https://github.com/mdn/browser-compat-data"><font><font>https://github.com/mdn/browser-compat-data</font></font></a><font><font> und senden Sie uns eine Pull-Anfrage.</font></font></p> + +<p>{{Compat("javascript.builtins.String.prototype")}}</p> + +<h2 id="Sieh_auch">Sieh auch</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/raw/index.html b/files/de/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..4405b1b72d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,160 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Global_Objects/String/raw +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +<div>{{JSRef}}</div> + +<div>Die statische <strong><code>String.raw()</code></strong> Methode ist eine tag Funktion für <a href="/de/docs/Web/JavaScript/Reference/template_strings">template literale</a> ähnlich dem r Präfix in Python oder dem @ Präfix in C# für String Literale (es gibt jedoch einen Unterschied: siehe in der Beschreibung <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">dieses Issues</a>). Es wird verwendet um rohen, unveränderten Text zu verwenden.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>String.raw(<var>callSite</var>, <var>...substitutions</var>) +String.raw`templateString` +</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd>Sauber formatiertes template call object, wie <code>{ raw: 'string' }</code>.</dd> + <dt><code>...substitutions</code></dt> + <dd>Enthält Substitutionswerte.</dd> + <dt><code>templateString</code></dt> + <dd>Ein <a href="/de/docs/Web/JavaScript/Reference/template_strings">template string</a>, optional mit Substitutionen (<code>${...}</code>).</dd> +</dl> + +<h3 id="Rückgabewerte">Rückgabewerte</h3> + +<p>Einen rohen, unveränderbaren String des template Strings.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Ein {{jsxref("TypeError")}} wird ausgeworfen wenn das erste Argument nicht sauber formatiert ist.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Meistens wird <code>String.raw()</code> mit template strings (Vorlagen-Zeichenketten) benutzt. Die erste oben beschriebene Syntax wird kaum benutzt weil die JavaScript engine die Argumente richtig aufrufen wird so wie bei anderen <a href="/de/docs/Web/JavaScript/Reference/template_strings#Tagged_template_strings">tag Funktionen.</a></p> + +<p><code>String.raw()</code> ist die einzige built-in tag function für template strings; Sie funktioniert wie eine default template function und führt concatenation (Verbindung mehrerer Strings zu einem) aus. Man kann sie sogar mit JS code neu schreiben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_String.raw()">Verwendung von <code>String.raw()</code></h3> + +<pre class="brush: js">String.raw`Hi\n${2+3}!`; +// 'Hi\\n5!', das Zeichen nach 'Hi' ist kein newline (Zeilenumbruch) Zeichen, +// '\' und 'n' sind zwei Zeichen. + +String.raw`Hi\u000A!`; +// 'Hi\\u000A!', hier genauso, diesmal bekommen wir folgende Zeichen zurrück: +// \, u, 0, 0, 0, A, 6 +// Alle Typen von escape characters (besondere Steuerzeichen) sind ineffektiv +// Backslashes werden unverändert ausgegeben. +// Man kann dies prüfen indem man die .length property des strings abfragt +console.log( String.raw`Hi\u000A!`.length ) // gibt 9 zurrück +console.log( "Hi\u000A!".length ) // gibt 4 zurrück + + +let name = 'Bob'; +String.raw`Hi\n${name}!`; +// 'Hi\\nBob!', Substitutionen werden bearbeitet. + +// Normalerweise ruft man String.raw() nicht als function auf aber man kann +//folgendes: +String.raw({ raw: 'test' }, 0, 1, 2); +// 't0e1s2t' +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>41</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>41</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/template_strings">Template strings</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/repeat/index.html b/files/de/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..6008654521 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,286 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>repeat()</code></strong>-Funktion erzeugt und gibt eine Zeichenkette zurück, die die spezifizierte Anzahl von Kopien der angegebenen Zeichenkette aneinandergereiht enthält.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.repeat(<var>Anzahl</var>);</code> +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>Anzahl</code></dt> + <dd>Eine Zahl zwischen 0 und +∞: [0, +∞), die die Anzahl Kopien der Ursprungszeichenkette in der neu erzeugten Zeichenkette definiert.</dd> +</dl> + +<h3 id="Rückgabeergebnis">Rückgabeergebnis</h3> + +<p>Eine neue Zeichenkette mit der angegebenen Anzahl an Kopien der vorgegebenen Zeichenkette.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: die Wiederholungsanzahl darf nicht negativ sein.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: die Anzahl an Wiederholungen darf nicht unendlich sein und die maximale Zeichenkettenlänge nicht überschreiten.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">'abc'.repeat(-1); // Parameterfehler +'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (Anzahl wird in einen ganzzahligen Integer umgewandelt) +'abc'.repeat(1/0); // Parameterfehler + +({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +// 'abcabc' (repeat() ist eine generische Methode) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion wurde zur ECMAScript 2015 Spezifikation hinzugefügt und steht unter Umständen noch nicht in allen JavaScript-Implementierungen zur Verfügung. Bedarfsweise können Sie die Methode <code>String.prototype.repeat()</code> durch folgenden Code zur Verfügung stellen:</p> + +<pre class="brush: js">if (!String.prototype.repeat) { + String.prototype.repeat = function(count) { + 'use strict'; + if (this == null) { + throw new TypeError('can\'t convert ' + this + ' to object'); + } + var str = '' + this; + count = +count; + if (count != count) { + count = 0; + } + if (count < 0) { + throw new RangeError('repeat count must be non-negative'); + } + if (count == Infinity) { + throw new RangeError('repeat count must be less than infinity'); + } + count = Math.floor(count); + if (str.length == 0 || count == 0) { + return ''; + } + // Ensuring count is a 31-bit integer allows us to heavily optimize the + // main part. But anyway, most current (August 2014) browsers can't handle + // strings 1 << 28 chars or longer, so: + if (str.length * count >= 1 << 28) { + throw new RangeError('repeat count must not overflow maximum string size'); + } + var rpt = ''; + for (var i = 0; i < count; i++) { + rpt += str; + } + return rpt; + } +} +</pre> + +<h4 id="Polyfill_ES5">Polyfill ES5</h4> + +<pre class="syntaxbox">//#es5 +'use strict'; +(function(win){ + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){o.repeat=(function(A,E){return function(n){var i=n>>0,s=this,l=s.length,j;if(i===0||l<1){s=''}else{j=268435456;if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)}};return s}})(w.Array,w.RangeError)}; + })(win); +})(window); + +//test: +console.clear(); +console.log( +'abc'.repeat(false),//'' +'abc'.repeat({}),//'' +'abc'.repeat([]),//'' +'abc'.repeat(['']),//'' +'abc'.repeat([0]),//'' +'abc'.repeat([0,1]),//'' +'abc'.repeat([1,1]),//'' +'abc'.repeat(0),//'' +'abc'.repeat(.6),//'' +'abc'.repeat(true),//'abc' +'abc'.repeat(1),//'abc' +'abc'.repeat(2),//'abcabc' +'abc'.repeat([2]),//'abcabc' +'abc'.repeat(3.5),//'abcabcabc' +''.repeat(2)//'' +); +console.log( +'abc'.repeat(-Infinity),//RangeError: Invalid count value +'abc'.repeat(Infinity),//RangeError: Invalid count value +'abc'.repeat(1/0),//RangeError: Invalid count value +'abc'.repeat(-1)//RangeError: Invalid count value +); + +/* +es5 src: +'use strict'; +(function(win){ + + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){ + o.repeat=(function(A,E){ + return function(n){ + var i=n>>0,s=this,l=s.length,j; + if(i===0||l<1){s=''}else{ + j=268435456; + if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)} + }; + return s + }; + })(w.Array,w.RangeError); + }; + //.. + })(win); + +})(window); +*/ +</pre> + +<h4 id="Polyfill_ES6">Polyfill ES6</h4> + +<pre class="syntaxbox">//#es6 + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + (o=>{ + + if(!exist(o,'repeat','function')){const A=w.Array,E=w.RangeError;o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new E('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}}; + + })(w.String.prototype); + +})(window); + +/* + +es6 src: + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + + (o=>{ + + if(!exist(o,'repeat','function')){ + + const A=w.Array; + + o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new RangeError('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}; + + }; + + //.. + + })(w.String.prototype); + + +})(window); + +*/ + + +//test: + +console.clear(); + +console.log( + +'abc'.repeat(false),//'' + +'abc'.repeat({}),//'' + +'abc'.repeat([]),//'' + +'abc'.repeat(['']),//'' + +'abc'.repeat([0]),//'' + +'abc'.repeat([0,1]),//'' + +'abc'.repeat([1,1]),//'' + +'abc'.repeat(0),//'' + +'abc'.repeat(.6),//'' + +'abc'.repeat(true),//'abc' + +'abc'.repeat(1),//'abc' + +'abc'.repeat(2),//'abcabc' + +'abc'.repeat([2]),//'abcabc' + +'abc'.repeat(3.5),//'abcabcabc' + +''.repeat(2)//'' + +); + +console.log( + +'abc'.repeat(-Infinity),//RangeError: Invalid count value + +'abc'.repeat(Infinity),//RangeError: Invalid count value + +'abc'.repeat(1/0),//RangeError: Invalid count value + +'abc'.repeat(-1)//RangeError: Invalid count value + +);</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Erste Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.repeat")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/string/replace/index.html b/files/de/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..c375d3d1f6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,344 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Reference/Global_Objects/String/replace +tags: + - Expressions + - JavaScript + - Method + - Prototype + - Reference + - Regular + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +<p>{{JSRef}}<br> + Die <code><strong>replace()</strong></code>-Methode gibt eine neue Zeichenkette zurück, in der einige oder alle Übereinstimmungen mit einem <code>Muster</code> durch einen <code>Ersatz</code> ausgetauscht wurden. Das <code>Muster</code> kann eine Zeichenkette oder eine RegExp sein, als <code>Ersatz </code>dienen eine Zeichenkette oder eine Funktion, welche für jede Übereinstimmung aufgerufen wird.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>str</em>.replace(<em>regexp|substr</em>, <em>newSubStr|function</em></code><code>);</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein {{jsxref("Global_Objects/RegExp", "RegExp")}}-Objekt. Die Übereinstimmung wird durch den Rückgabewert aus Parameter #2 ersetzt.</dd> +</dl> + +<dl> + <dt><code>substr</code></dt> + <dd>Eine {{jsxref("Global_Objects/String", "Zeichenkette")}}, welche durch <code>newSubStr</code> ersetzt werden soll. Nur das erste Vorkommen wird ersetzt.</dd> +</dl> + +<dl> + <dt><code>newSubStr</code></dt> + <dd>Die {{jsxref("Global_Objects/String", "Zeichenkette")}}, welche den Substring aus Parameter #1 ersetzt. Eine Anzahl spezieller Ersetzungsmuster wird unterstützt, siehe den "<a href="#Eine_Zeichenkette_als_Parameter_angeben">Eine Zeichenkette als Parameter angeben</a>"-Abschnitt weiter unten.</dd> +</dl> + +<dl> + <dt><code>function</code></dt> + <dd>Eine Funktion, welche aufgerufen wird, um den neuen Substring zu erzeugen, der an Stelle des gefundenen Substrings aus Parameter #1 stehen soll. Die Argumente für diese Funktion werden im "<a href="#Eine_Funktion_als_Parameter_angeben">Eine Funktion als Parameter angeben</a>"-Abschnitt unten erläutert.</dd> +</dl> + +<h3 id="Rückgabe">Rückgabe</h3> + +<p>Eine neue Zeichenkette, in der einige oder alle Übereinstimmungen mit einem Muster durch einen Ersatz ausgetauscht wurden.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Diese Methode ändert nicht das <code>String</code>-Objekt, auf welchem sie aufgerufen wird. Sie gibt lediglich einen neuen String zurück.</p> + +<p>Um ein globales Suchen und Ersetzen durchzuführen, setzen Sie den <code>g</code>-Umschalter im Regulären Ausdruck.</p> + +<h3 id="Eine_Zeichenkette_als_Parameter_angeben" name="Eine_Zeichenkette_als_Parameter_angeben">Eine Zeichenkette als Parameter angeben</h3> + +<p>Die Ersatzzeichenkette kann folgende spezielle Ersetzungsmuster beinhalten:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Pattern</td> + <td class="header">Inserts</td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Fügt ein "$" ein.</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Fügt den gefundenen Substring ein.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Fügt den Stringteil vor dem gefundenen Substring ein.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Fügt den Stringteil nach dem gefundenen Substring ein.</td> + </tr> + <tr> + <td style="white-space: nowrap;"><code>$<em>n</em></code></td> + <td>Mit <code><em>n</em></code> als nicht negative ganze Zahl kleiner als 100 wird der <em>n</em>te eingeklammerte Submatch-String eingefügt, der im ersten Argument in der <code>RegExp</code> angegeben wurde.</td> + </tr> + </tbody> +</table> + +<h3 id="Eine_Funktion_als_Parameter_angeben" name="Eine_Funktion_als_Parameter_angeben">Eine Funktion als Parameter angeben</h3> + +<p>Sie können eine Funktion als zweiten Parameter angeben. In diesem Fall wird diese Funktion aufgerufen, nachdem die Suche ausgeführt wurde. Der Rückgabewert der Funktion wird als Ersatz eingesetzt. (Anmerkung: Die oben genannten speziellen Ersetzungsmuster werden in diesem Fall <em>nicht</em> beachtet.) Bedenken Sie, dass die Funktion für jede Übereinstimmung erneut aufgerufen wird, wenn der reguläre Ausdruck im ersten Parameter den global-Flag gesetzt hat.</p> + +<p>Die Argumente dieser Funktion lauten wie folgt:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Möglicher Name</td> + <td class="header">Gelieferter Wert</td> + </tr> + <tr> + <td><code>match</code></td> + <td>Der gefundene Substring. (Entspricht $& oben.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>Der <em>n</em>th eingeklammerte Submatch-String, fall im ersten Argument ein <code>RegExp-Objekt</code> angegeben wurde. (Entspricht $1, $2, etc. oben.) Wurde zum Beispiel <code>/(\a+)(\b+)/ angegeben, so ist</code> <code>p1</code> die Übereinstimmung für<code> \a+</code>, und <code>p2</code> für <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>Die Position, an welcher der gefundene Substring innerhalb der gesamten Zeichenkette gefunden wurde. War zum Beispiel die gesamte Zeichenkette <code>"abcd"</code> und der gefundene Substring <code>"bc"</code>, dann wäre das Argument <code>1</code>.)</td> + </tr> + <tr> + <td style="white-space: nowrap;"><code>string</code></td> + <td>Die gesamte Zeichenkette, welche durchsucht wird.</td> + </tr> + </tbody> +</table> + +<p>(Die genaue Anzahl der Argumente hängt davon ab, ob das erste Argument eine <code>RegExp</code> war und wieviele eingeklammerte Submatches in diesem Fall angegeben wurden.)</p> + +<p>Das folgende Beispiel wird <code>newString </code>auf <code>"<span class="console-formatted-string source-code">abc - 12345 - #$*%</span>"</code> setzen:</p> + +<pre class="brush: js">function replacer(match, p1, p2, p3, offset, string){ + // p1 is nondigits, p2 digits, and p3 non-alphanumerics + return [p1, p2, p3].join(' - '); +} +newString = "abc12345#$*%".replace(/([^\d]*)(\d*)([^\w]*)/, replacer); +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example_Defining_the_regular_expression_in_replace" name="Example:_Defining_the_regular_expression_in_replace">Beispiel: Definieren des regulären Ausdrucks in <code>replace</code></h3> + +<p>Globales Ersetzen kann nur mit einem regulären Ausdruck durchgeführt werden. Im folgenden Beispiel wird der reguläre Ausdruck in <code>replace</code> definiert und beinhaltet den Schalter <code>ignore case</code>.</p> + +<pre class="brush: js">var str = "Twas the night before Xmas..."; +var newstr = str.replace(/xmas/i, "Christmas"); +print(newstr); +</pre> + +<p>Dies erzeugt die Ausgabe "Twas the night before Christmas..."</p> + +<h3 id="Example_Using_global_and_ignore_with_replace" name="Example:_Using_global_and_ignore_with_replace">Beispiel: Nutzung von <code>global</code> und <code>ignore</code> mit <code>replace</code></h3> + +<p>Das nachfolgende Beispiel enthält einen regulären Ausdruck, der sowohl das <code>global</code> als auch das <code>ignore</code> Flag gesetzt hat. Dadurch wird von <code>replace</code> jedes Vorkommnis von 'apples' in der Zeichenkette durch 'oranges' ersetzt.</p> + +<pre class="brush: js">var re = /apples/gi; +var str = "Apples are round, and apples are juicy."; +var newstr = str.replace(re, "oranges"); +print(newstr); +</pre> + +<p>Dies erzeugt die Ausgabe "oranges are round, and oranges are juicy."</p> + +<h3 id="Beispiel_Vertausche_Wörter_in_Strings">Beispiel: Vertausche Wörter in Strings</h3> + +<p>Im folgenden Skript werden die Wörter in dem String getauscht. Für die Vertauschung im Text nutzt das Skript die Ersetzungspatterns <code>$1</code> und <code>$2</code>.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); +print(newstr); +</pre> + +<p>Die Ausgabe ist: "Smith, John".</p> + +<h3 id="Example_Using_an_inline_function_that_modifies_the_matched_characters" name="Example:_Using_an_inline_function_that_modifies_the_matched_characters">Beispiel: Nutzung von Inline-Funktionen, die die erkannten Zeichen modifizieren</h3> + +<p>In diesem Beispiel werden alle Großbuchstaben durch einen Bindestrich und den entsprechenden Kleinbuchstaben ersetzt. Der wichtige Punkt in dem Beispiel ist, dass der Additions-Operator (Konkatination) vor dem Zurückgeben der neuen Zeichenkette erfolgen muss.</p> + +<p>Die Ersetzungsfunktion bekommt das erkannte Muster als Parameter übergeben und benutzt diesen, um den Buchstaben zu transformieren und ihn mit dem Bindestrich zu verbinden. Zum Schluss wird das Ergebnis zum Ersetzen zurückgegeben.</p> + +<pre class="brush: js">function styleHyphenFormat(propertyName) { + function upperToHyphenLower(match) { + return '-' + match.toLowerCase(); + } + return propertyName.replace(/[A-Z]/g, upperToHyphenLower); +} +</pre> + +<p>Gegeben <code>styleHyphenFormat('borderTop')</code>, gibt 'border-top' zurück.</p> + +<p>Weil das Ergebnis transformiert werden soll, bevor die finale Ersetzung durchgeführt wird, muss eine Funktion eingesetzt werden. Dieses erzwingt die Ausführung von <code>toLowerCase()</code>. Wenn man das gleiche versucht ohne eine Funktion zu benutzen, wird die toLowerCase() Methode ohne Wirkung sein.</p> + +<pre class="brush: js">var newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // won't work +</pre> + +<p>Dieses ist weil <code>'$&'.toLowerCase()</code> ausgeführt wird, bevor der String als Pattern genutzt wird.</p> + +<h3 id="Example_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent" name="Example:_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent">Beispiel: Grad Fahrenheit in Celsius-Grad umwandeln</h3> + +<p>Das folgende Beispiel ersetzt einen Wert in Grad Fahrenheit durch den entsprechenden Celsius-Wert. Der Fahrenheitwert sollte eine Nummer sein, die mit einem F endet. Die Funktion gibt eine Celsius-Temperatur mit der Endung C aus. Ist zum Beispiel der Eingabewert 212F, so gibt die Funktion 100C zurück. Ist die Nummer 0F, so wird -17,77777777777778C zurück gegeben.</p> + +<p>Der reguläre Ausdruck <code>test</code> prüft jede Nummer, die mit F endet. Die Nummer in Grad Fahrenheit ist durch den zweiten Funktionsparameter, <code>p1</code>, ansprechbar. Die Funktion setzt den Celsiuswert basierend auf dem Fahrenheitwert in einer Zeichenkette in der <code>f2c</code>-Funktion. <code>f2c gibt dann den Celsiuswert zurück. Diese Funktion </code>ähnelt dem s///e-Flag in Perl.</p> + +<pre class="brush: js">function f2c(x) { + function convert(str, p1, offset, s) { + return ((p1-32) * 5/9) + "C"; + } + var s = String(x); + var test = /(\d+(?:\.\d*)?)F\b/g; + return s.replace(test, convert); +} +</pre> + +<h3 id="Example_Use_an_inline_function_with_a_regular_expression_to_avoid_for_loops" name="Example: Use an inline function with a regular expression to avoid for loops" style="line-height: 24px;">Beispiel: Verwenden einer inline-Funktion mit einem regulärem Ausdruck um Schleifen zu vermeiden</h3> + +<p>Das folgende Beispiel nimmt eine Zeichenkettenmuster und konvertiert es in ein Array von Objekten.</p> + +<p><strong>Eingabe:</strong><br> + Eine Zeichenkette, die aus den Zeichen x, - und _ besteht</p> + +<pre>x-x_ +x---x---x---x--- +x-xxx-xx-x- +x_x_x___x___x___</pre> + +<div><strong><span style="line-height: 1.5;">Ausgabe:</span></strong></div> + +<div><span style="line-height: 1.5;">Ein Array mit Objekten. Ein 'x' zeigt einen 'an'-Status an, ein '-' (Bindestrich) symbolisiert einen 'aus'-Status und ein '_' (Unterstrich) gibt die Länge des 'an'-Status an.</span></div> + +<pre class="brush: json"><span style="line-height: 1.5;">[</span> + { on: true, length: 1 }, + { on: false, length: 1 }, + { on: true, length: 2 } + ... +]</pre> + +<div><strong>Ausschnitt:</strong></div> + +<div> +<pre class="brush: js">var str = 'x-x_'; +var retArr = []; +str.replace(/(x_*)|(-)/g, function(match, p1, p2){ + if(p1) retArr.push({ on: true, length: p1.length }); + if(p2) retArr.push({ on: false, length: 1 }); +}); + +console.log(retArr);</pre> +</div> + +<div>Der Ausschnitt generiert ein Array mit drei Objekten im gewünschten Format, ohne eine Schleife zu verwenden.</div> + +<div></div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition.<br> + Implementiert in JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Eigenschaft</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-spezifische_Bemerkungen">Firefox-spezifische Bemerkungen</h2> + +<ul> + <li>Mit dem Start von Gecko 27 {{geckoRelease(27)}}, wurde diese Methode an die ECMAScript Spezifikation angepasst. Wenn <code>replace()</code> mit einem globalen regulären Ausdruck aufgerufen wird, wird die {{jsxref("RegExp.lastIndex")}} Eigenschaft (wenn sie Spezifiziert wurde) auf 0 zurückgesetzt ({{bug(501739)}}).</li> + <li>Mit dem Start von Gecko 39 {{geckoRelease(39)}} wurden das nicht standardisierte <code>flags</code> Argument als deprecated markiert und wirft eine Warnung in der Konsole ({{bug(1142351)}}).</li> + <li>Mit dem Start von Gecko 47 {{geckoRelease(47)}} wurden das nicht standardisierte <code>flags</code> Argument nicht länger in <span class="short_text" id="result_box" lang="de"><span>Nicht-</span><span>Release-Builds</span></span> unterstützt und wird bald vollständig entfernt ({{bug(1245801)}}).</li> + <li>Mit dem Start von Gecko 49 {{geckoRelease(49)}} wurden das nicht standardisierte <code>flags</code> Argument nicht mehr unterstützt ({{bug(1108382)}}).</li> +</ul> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/slice/index.html b/files/de/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..d30b18e21f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,152 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>slice()</code></strong> Methode extrahiert einen Teilbereich eines Strings und gibt einen neuen String zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.slice(<var>AnfangIndex</var>[, E<var>ndIndex</var>])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>AnfangIndex</code></dt> + <dd>Der nullbasierte Index von welchem mit der Extraktion begonnen wird. Wenn dieser negativ ist, wird er als <code>strLength + AnfangIndex, </code>wobei <code>strLength</code> die länge des Strings darstellt, (bspw., wenn <code>AnfangIndex</code> <code>-3</code> ist, wird es als <code>strLength - 3 gewertet</code>). Wenn <code>beginIndex</code><em> </em>größer oder gleich length des Strings ist, gibt <code>slice()</code> einen leeren String zurück.</dd> + <dt><code>EndIndex</code></dt> + <dd>Optional. Der nullbasierte Index <em>vor</em> welchem die Extraktion beendet wird. Der Charakter an diesem Index wird nicht mit einbezogen. Wenn <code>EndIndex </code>ausgelassen wird, extrahiert <code>slice()</code> bis zum Ende des Strings. Wenn <code>EndIndex </code>negativ ist, wird es wie <code>strLength + EndIndex</code> gewertet, wobei strLength sich auf die Länge des Strings bezieht (z.B.: wenn E<code>ndIndex</code> <code>-3 ist, wird es gewertet wie </code><code>strLength - 3).</code></dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Ein neuer String, welcher die extrahierte Sektion des Strings enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>slice()</code> extrahiert den Text eines Strings und gibt einen neuen zurück. Änderungen im einen String wirken sich nicht auf den anderen String aus.</p> + +<p><code>slice()</code> extrahiert bis, aber nicht einschließlich, <code>EndIndex. </code><code>str.slice(1, 4)</code> extrahiert den zweiten Charakter bis zum vierten (Character mit den Indexen 1, 2, und 3).</p> + +<p>Als Beispiel, <code>str.slice(2, -1)</code> extrahiert den dritten Charakter bis zum zweiten, bis zum letzten Charakter im String.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzen_von_slice()_um_einen_neuen_String_zu_erzeugen"><code>Benutzen von slice()</code> um einen neuen String zu erzeugen</h3> + +<p>Das folgende Beispiel benutzt <code>slice()</code> um einen neuen String zu erzeugen.</p> + +<pre class="brush: js">var str1 = 'The morning is upon us.', // the length of str1 is 23. + str2 = str1.slice(1, 8), + str3 = str1.slice(4, -2), + str4 = str1.slice(12), + str5 = str1.slice(30); +console.log(str2); // OUTPUT: he morn +console.log(str3); // OUTPUT: morning is upon u +console.log(str4); // OUTPUT: is upon us. +console.log(str5); // OUTPUT: "" +</pre> + +<h3 id="Benutzen_von_slice()_mit_negativen_Indexen">Benutzen von <code>slice()</code> mit negativen Indexen</h3> + +<p>Das folgende Beispiel benutzt <code>slice()</code> mit negativen Indexen.</p> + +<pre class="brush: js">var str = 'The morning is upon us.'; +str.slice(-3); // returns 'us.' +str.slice(-3, -1); // returns 'us' +str.slice(0, -1); // returns 'The morning is upon us' +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompatibilität">Browser kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/split/index.html b/files/de/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..cfea09cc76 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,212 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Reference/Global_Objects/String/split +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>split()</code></strong> Methode teilt ein {{jsxref("String")}} Objekt in ein Array von Strings auf, indem der String in Teilstrings zerteilt wird, wobei ein angegebenes Trennzeichen verwendet wird, um zu bestimmen, wo die Aufteilung erfolgen soll.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-split.html")}}</p> + +<h2 id="Summary" name="Summary">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.split([<var>separator</var>[, <var>limit</var>]])</code></pre> + +<div class="blockIndicator warning"> +<p>Achtung: Wenn leerer ein String ("") als Trennzeichen verwendet wird, wird der String <strong>nicht</strong> zwischen jedem <em>vom Benutzer wahrgenommenen Zeichen</em> (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">Graphem-Cluster</a>) oder zwischen jedem Unicode-Zeichen (Codepoint) aufgeteilt, sondern zwischen jeder UTF-16-Codeeinheit. Dadurch werden <a href="http://unicode.org/faq/utf_bom.html#utf16-2">Ersatzpaare</a> (surrogate pairs) zerstört. Siehe auch <a href="https://stackoverflow.com/a/34717402">How do you get a string to a character array in JavaScript?</a> auf Stack Overflow.</p> +</div> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>separator</code> {{optional_inline}}</dt> + <dd>Ein String, der die Punkte angibt, an denen jede Aufteilung erfolgen soll. <code>separator</code> wird als Zeichenfolge oder als {{jsxref("Global_Objects/RegExp", "regulärer Ausdruck", "", 1)}} behandelt. Wenn ein Nur-Text <code>separator</code> mehr als ein Zeichen enthält, muss der gesamte String gefunden werden, damit eine Trennung erfolgt. Wenn <code>separator</code> nicht angegeben wird oder in <code>str</code> nicht vorkommt, enthält das zurückgegebene Array ein Element, das den gesamten String enthält. Wenn <code>separator</code> ein leerer String ist, wird jedes Zeichen von <code>str</code> in ein Array-Element umgewandelt.</dd> + <dt><code>limit</code> {{optional_inline}}</dt> + <dd>Ganzzahl, die ein Limit für die Anzahl der zu findenden Splits angibt. Wenn dieser Parameter angegeben wird, teilt die <code>split()</code> Methode die Zeichenfolge bei jedem Vorkommen des angegebenen <code>separator</code> auf, stoppt jedoch, nachdem die Anzahl von <code>limit</code> erreicht wurde. Es können immer noch weniger Einträge als <code>limit</code> enthalten sein, wenn das Ende des Strings erreicht wurde, bevor das angegebene Limit erreicht wird. Der übrig gebliebene Text wird im neuen Array nicht enthalten sein.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Array")}} mit Strings, welcher an jedem Punkt aufgeteilt wurde, an dem das Trennzeichen in der angegebenen Zeichenfolge aufgetreten ist.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Wenn gefunden, wird <code>separator</code> aus dem String entfernt und die Teilstrings werden in einem Array zurückgegeben. Wenn <code>separator</code> nicht gefunden oder weggelassen wird, enthält das Array ein Element, das aus dem gesamten String besteht. Wenn <code>separator</code> ein leerer String ist, wird <code>str</code> in ein Array aus Zeichen umgewandelt. Wenn <code>separator</code> am Anfang, Ende oder Anfang und Ende eines Strings gefunden wird, beginnt, endet oder beginnt und endet das Array mit einem leeren String. Besteht ein String daher nur aus einem einzigen Vorkommnis von <code>separator</code> besteht, besteht das Array also aus zwei leeren Strings.</p> + +<p>Wenn <code>separator</code> ein regulärer Ausdruck ist, der runde Klammern enthält, werden die Ergebnisse (einschließlich etwaiger undefinierter Ergebnisse) der Klammern bei jeder Übereinstimmung von <code>separator</code> in das ausgegebene Array eingefügt.</p> + +<div class="blockIndicator note"> +<p><strong>Hinweis:</strong> Wenn <code>separator</code> ein Array ist, wird das Array in einen String umgewandelt und als Trennzeichen verwendet.</p> +</div> + +<div class="blockIndicator note"> +<p><strong>Hinweis:</strong> Wenn der String leer ist, gibt <code>split()</code> ein Array zurück, das einen leeren String anstelle eines leeren Arrays enthält. Wenn sowohl der String als auch das Trennzeichen leere Zeichenfolgen sind, wird ein leeres Array zurückgegeben.</p> +</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_split" name="Example:_Using_split">Verwendung von <code>split()</code></h3> + +<p>Im folgenden Beispiel wird eine Funktion definiert, die einen String mithilfe des angegebenen Trennzeichens in ein Array aus Strings aufteilt. Nach dem Aufteilen des Strings protokolliert die Funktion Meldungen, die den ursprüngliche String angeben (vor der Aufteilung), das verwendete Trennzeichen, die Anzahl der Elemente im Array und die einzelnen Arrayelemente.</p> + +<pre class="brush: js">function splitString(stringToSplit, separator) { + var arrayOfStrings = stringToSplit.split(separator); + + console.log('The original string is: "' + stringToSplit + '"'); + console.log('The separator is: "' + separator + '"'); + console.log('The array has ' + arrayOfStrings.length + ' elements: ' + arrayOfStrings.join(' / ')); +} + +var tempestString = 'Oh brave new world that has such people in it.'; +var monthString = 'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'; + +var space = ' '; +var comma = ','; + +splitString(tempestString, space); +splitString(tempestString); +splitString(monthString, comma);</pre> + +<p>Das Beispiel erzeugt den folgende Ausgabe:</p> + +<pre class="brush: js">The original string is: "Oh brave new world that has such people in it." +The separator is: " " +The array has 10 elements: Oh / brave / new / world / that / has / such / people / in / it. + +The original string is: "Oh brave new world that has such people in it." +The separator is: "undefined" +The array has 1 elements: Oh brave new world that has such people in it. + +The original string is: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec" +The separator is: "," +The array has 12 elements: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec</pre> + +<h3 id="Example:_Removing_spaces_from_a_string" name="Example:_Removing_spaces_from_a_string">Leerzeichen aus einem String entfernen</h3> + +<p>Im folgenden Beispiel sucht <code>split()</code> nach 0 oder mehr Leerzeichen, gefolgt von einem Semikolon und 0 oder mehr Leerzeichen. Wenn es sie findet, entfernt es die Leerzeichen aus dem String. <code>nameList</code> ist das Array, was als Ergebnis von <code>split() zurückgegeben wird</code>.</p> + +<pre class="brush: js">var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand '; + +console.log(names); + +var re = /\s*(?:;|$)\s*/; +var nameList = names.split(re); + +console.log(nameList);</pre> + +<p>Dies protokolliert zwei Zeilen. Die erste Zeile protokolliert die ursprüngliche Zeichenfolge und die zweite Zeile das resultierende Array.</p> + +<pre>Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", "" ] +</pre> + +<h3 id="Example:_Returning_a_limited_number_of_splits" name="Example:_Returning_a_limited_number_of_splits">Eine begrenzte Anzahl von Trennungen zurückgeben</h3> + +<p>Im folgenden Beispiel sucht <code>split()</code> nach 0 oder mehr Leerzeichen im String und gibt die ersten 3 Treffer zurück, die es findet.</p> + +<pre class="brush: js">var myString = 'Hello World. How are you doing?'; +var splits = myString.split(' ', 3); + +console.log(splits);</pre> + +<p>Dieses Skript gibt folgendes aus:</p> + +<pre>["Hello", "World.", "How"] +</pre> + +<h3 id="Teilen_mit_einer_RegExp_um_Teile_des_Trennzeichens_in_das_Ergebnis_aufzunehmen">Teilen mit einer <code>RegExp</code>, um Teile des Trennzeichens in das Ergebnis aufzunehmen</h3> + +<p>Wenn <code>separator</code> ein regulärer Ausdruck ist, der runde Klammern <code>()</code> enthält, werden übereinstimmende Ergebnisse in das Array aufgenommen.</p> + +<pre class="brush: js">var myString = 'Hello 1 word. Sentence number 2.'; +var splits = myString.split(/(\d)/); + +console.log(splits);</pre> + +<p>Dieses Skript gibt folgendes aus:</p> + +<pre class="brush: js">[ "Hello ", "1", " word. Sentence number ", "2", "." ]</pre> + +<p> </p> + +<h3 id="Teilen_mit_einem_Array_als_Trennzeichen">Teilen mit einem Array als Trennzeichen</h3> + +<p> </p> + +<pre class="brush: js">var myString = 'this|is|a|Test'; +var splits = myString.split(['|']); + +console.log(splits); //["this", "is", "a", "Test"] + +var myString = 'ca,bc,a,bca,bca,bc'; + +var splits = myString.split(['a','b']); +// myString.split(['a','b']) ist dasselbe wie myString.split(String(['a','b'])) + +console.log(splits); //["c", "c,", "c", "c", "c"]</pre> + +<h3 id="Example:_Reversing_a_String_using_split" name="Example:_Reversing_a_String_using_split">Einen String mit <code>split()</code> umkehren</h3> + +<div class="blockIndicator warning"> +<p>Dies ist keine robuste Art einen String umzukehren.</p> + +<pre class="brush: js">var str = 'asdfghjkl'; +var strReverse = str.split('').reverse().join(''); // 'lkjhgfdsa' +// split() returns an array on which reverse() and join() can be applied +</pre> + +<p>Das funktioniert nicht, wenn der String Graphem-Cluster enthält, selbst wenn ein Unicode-fähiger Split verwendet wird (verwenden Sie stattdessen bspw. <a href="https://github.com/mathiasbynens/esrever">esrever</a>).</p> + +<pre class="brush: js">var str = 'résumé'; +var strReverse = str.split(/(?:)/u).reverse().join(''); +// => "́emuśer" +</pre> + +<p><strong>Bonus:</strong> Verwenden Sie sen {{jsxref("Operators/Comparison_Operators", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}} Operator um zu testen, ob der ursprüngliche String ein Palindrom war.</p> +</div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{Compat("javascript.builtins.String.split")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/startswith/index.html b/files/de/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..adbb0dce44 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,150 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/startsWith +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - Referenz + - String + - protype +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>Die <strong>startsWith()-</strong>Methode stellt fest, ob ein String mit den Zeichen eines anderen Strings beginnt, falls dies so ist, wird <code>true</code>, sonst wird <code>false</code> zurückgegeben. </p> + +<pre class="syntaxbox"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>Die Zeichenfolge, nach der am Anfang des Strings gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Die Position, an der die Suche nach <code>searchString</code> begonnen werden soll. Der Standardwert ist 0.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><strong>true</strong> wenn der String mit den Zeichen aus dem übergebenen String beginnt, andernfalls <strong>false</strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode dient dazu herauszufinden, ob ein String am Anfang eines anderen Strings steht. Die Methode unterscheidet Groß- und Kleinschreibung.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_startsWith">Benutzung von <code>startsWith()</code></h3> + +<pre class="brush: js">//startsWith +var str = 'Sein oder nicht sein, das ist hier die Frage'; + +console.log(str.startsWith('Sein oder')); // true +console.log(str.startsWith('nicht sein')); // false +console.log(str.startsWith('nicht sein', 10)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode ist Bestandteil der ECMAScript-6-Spezifikation. Dennoch kann es vorkommen, dass sie noch nicht in allen Javascript-Implementierungen vorhanden ist. Man kann ihre Funktionsweise allerdings mit folgendem Ausdruck emulieren:</p> + +<pre class="brush: js">if (!String.prototype.startsWith) { + String.prototype.startsWith = function(searchString, position) { + position = position || 0; + return this.indexOf(searchString, position) === position; + }; +} +</pre> + +<p>Eine robustere und schnellerer (optimierte) Version findet sich <a href="https://github.com/mathiasbynens/String.prototype.startsWith">auf GitHub, geschrieben von Mathias Bynens</a>.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<h2 id="CompatibilityTable"><span style="font-size: 14px; font-weight: normal; line-height: 1.5;">{{CompatibilityTable}}</span></h2> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>28</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"> </h2> + +<p>Zu beachten ist, dass die MSDN Dokumentation für diese Methode (<a href="https://msdn.microsoft.com/de/library/mt146831(v=vs.94).aspx">https://msdn.microsoft.com/en-us/library/mt146831(v=vs.94).aspx</a>) besagt, das es nicht im Internet Explorer unterstützt wird.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/substr/index.html b/files/de/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..354d417ea9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,171 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>substr()</code></strong> gibt die Zeichen eines Strings in einem gegebenen Intervall zurück.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Ort im String, an dem mit dem Extrahieren von Zeichen begonnen wird. Wird eine negative Zahl übergeben, wird sie als <code>str.length - start</code> behandelt (Wenn <code>start</code> z. B. -3 ist, wird es als <code>str.length - 3</code> behandelt).</dd> + <dt><code>length</code></dt> + <dd>Optional. Die Anzahl der Zeichen, die extrahiert werden sollen.</dd> +</dl> + +<h3 id="Description" name="Description">Rückgabewert</h3> + +<p>Einen neuen String, der den extrahierten Bereich des gegebene Strings enthält. Wenn <strong><code>length</code> <code>0</code></strong> oder negativ ist, wird ein leerer String zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>start</code> ist ein Zeichenindex. Der Index des ersten Zeichens ist 0 und der Index des letzten Zeichens ist 1 weniger als die Länge des Strings. <code>substr()</code>fängt mit dem Extrahieren von Zeichen bei <code>start</code> an und extrahiert <code>length</code> Zeichen (es sei denn, es erreicht vorher das Ende des Strings, dann gibt es weniger zurück).</p> + +<p>Wenn <code>start</code> positiv ist und größer gleich der Länge des Strings ist, gibt <code>substr()</code> einen leeren String zurück.</p> + +<p>Wenn <code>start</code> negativ ist, verwendet <code>substr()</code> es als Zeichenindex vom Ende des Strings. Wenn <code>start</code> negativ ist und <code>abs(start)</code> größer als die Länge des Strings ist, verwendet <code>substr()</code> 0 als Zeichenindex. Anmerkung: Der beschriebene Umgang mit negativen Werten für <code>start</code> wird von Microsoft JScript nicht unterstützt.</p> + +<p>Wenn <code>length</code> 0 oder negativ ist, gibt <code>substr()</code> einen leeren String zurück. Wenn <code>length</code> nicht übergeben wird, extrahiert <code>substr()</code> alle Zeichen bis zum Ende des Strings.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_substr" name="Example:_Using_substr">Verwenden von <code>substr()</code></h3> + +<pre class="brush: js">var str = 'abcdefghij'; + +console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc' +console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi' +console.log('(-3): ' + str.substr(-3)); // '(-3): hij' +console.log('(1): ' + str.substr(1)); // '(1): bcdefghij' +console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab' +console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): ' +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Microsofts JScript unterstützt keine negativen Werte für den Startindex. Der folgende Kompatibilitätscode ist ein Workaround für diesen Bug:</p> + +<pre class="brush: js">// Nur verwenden, wenn die substr()-Funktion nicht funktioniert +if ('ab'.substr(-1) != 'b') { + /** + * Einen Teilstring erhalten + * @param {integer} start Startindex des Teilstrings + * @param {integer} length Länge des Teilstrings + * @return {string} + */ + String.prototype.substr = function(substr) { + return function(start, length) { + // Aufruf der Originalfunktion + return substr.call(this, + // Wenn start negativ ist, berechnen wie viel start + // vom Anfang des Strings ist + start < 0 ? this.length + start : start, + length); + } + }(String.prototype.substr); +} +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Im (informativen) Anhang B "Compatibility" definiert. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Im (informativen) Anhang B "Compatibility" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/substring/index.html b/files/de/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..4ed1e33959 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,199 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - Funktion + - JavaScript + - Method + - Methode(2) + - Méthode + - Prototype + - Reference + - Referenz + - Référence(2) + - String + - Zeichenkette +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Definition</h2> + +<p>Die <strong><code>substring()</code></strong> Methode gibt einen Teilstring eines <code>Strings</code> zwischen einem Index und einem anderen, oder dem Ende der Zeichenkette zurück.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>indexA</code></dt> + <dd>Ein Integer zwischen <code>0</code> und der Länge der Zeichenkette, welcher das erste Zeichen des Teilstrings repräsentiert.</dd> + <dt><code>indexB</code></dt> + <dd>Optional. Ein Integer zwischen <code>0</code> und der Länge der Zeichenkette, welcher das erste nicht im Teilstring enthaltene Zeichen darstellt.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>substring()</code> extrahiert Zeichen von <code>indexA</code> bis nicht einschließlich <code>indexB</code>. Im Detail:</p> + +<ul> + <li>Falls <code>indexA</code> gleich <code>indexB ist</code>, gibt <code>substring()</code> einen leeren String zurück.</li> + <li>Falls <code>indexB</code> nicht angegeben ist, extrahiert <code>substring()</code> alle Zeichen bis zum Ende der Zeichenkette.</li> + <li>Falls eines der Argumente kleiner als 0 oder {{jsxref("Global_Objects/NaN", "NaN")}} ist, wird dieser als 0 interpretiert.</li> + <li>Falls eines der Argumente größer als die Länge der Zeichenkette ist, wird dieses als <code>stringName.length behandelt</code>.</li> +</ul> + +<p>Falls <code>indexA</code> größer als <code>indexB ist</code>, werden die Argumente vertauscht <code>substring()</code>; zum Beispiel, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_substring" name="Example:_Using_substring">Beispiel: Benutzung von <code>substring()</code></h3> + +<p>Das folgende Beispiel benutzt <code>substring()</code>, um Zeichen des Strings <code>'Mozilla' anzuzeigen</code>:</p> + +<pre class="brush: js">var anyString = 'Mozilla'; + +// Zeigt 'Moz' +console.log(anyString.substring(0, 3)); +console.log(anyString.substring(3, 0)); + +// Zeigt 'lla' +console.log(anyString.substring(4, 7)); +console.log(anyString.substring(7, 4)); + +// Zeigt 'Mozill' +console.log(anyString.substring(0, 6)); + +// Zeigt 'Mozilla' +console.log(anyString.substring(0, 7)); +console.log(anyString.substring(0, 10)); +</pre> + +<h3 id="Example:_Using_substring_with_length_property" name="Example:_Using_substring_with_length_property">Beispiel: Benutzung von <code>substring()</code> mit <code>length</code> Eigenschaft</h3> + +<p>Das folgende Beispiel benutzt die <code>substring()</code> Methode und die {{jsxref("String.length", "length")}} Eigenschaft, um die letzten Zeichen des Strings zu extrahieren. Diese Methode ist leichter zu merken, da die genauen Start- und Endparameter nicht bekannt sein müssen.</p> + +<pre class="brush: js">// Zeigt 'illa' - die letzten 4 Zeichen +var anyString = 'Mozilla'; +var anyString4 = anyString.substring(anyString.length - 4); +console.log(anyString4); + +// Zeigt 'zilla' - die letzten 5 Zeichen +var anyString = 'Mozilla'; +var anyString5 = anyString.substring(anyString.length - 5); +console.log(anyString5); +</pre> + +<h3 id="Example:_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Beispiel: Ersetze ein Teilstring mit einem String</h3> + +<p>Das folgende Beispiel ersetzt ein Teilstring mit einem String. Es werden sowohhl einzelne Zeichen als auch Teilstrings ersetzt. Der Funktionsaufruf am Ende des Beispiel ändert die Zeichenkette <code>'Brave New World'</code> in <code>'Brave New Web'</code>.</p> + +<pre class="brush: js">// Ersetzt oldS mit newS in der Zeichenkette fullS +function replaceString(oldS, newS, fullS) { + for (var i = 0; i < fullS.length; ++i) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString('World', 'Web', 'Brave New World'); +</pre> + +<p>Beachte, dass dieses Beispiel auch in einer Endlosschleife resultieren kann, wenn <code>oldS</code> ein Teilstring von <code>newS</code> ist — zum Beispiel, falls 'World' mit 'OtherWorld' ersetzt wird. Der folgende Code zeigt ein bessere Methode Strings zu ersetzen:</p> + +<pre class="brush: js">function replaceString(oldS, newS, fullS) { + return fullS.split(oldS).join(newS); +} +</pre> + +<p>Der oben stehende Code zeigt ein Beispiel für die Verwendung der substring Operation. Falls Teilstrings ersetzt werden, kann in den meisten Fällen {{jsxref("String.prototype.replace()")}} verwendet werden.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>ECMAScript 1. Edition.</td> + <td>Standard</td> + <td>In JavaScript 1.0 implementiert.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Standard Support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Standard Support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/suchen/index.html b/files/de/web/javascript/reference/global_objects/string/suchen/index.html new file mode 100644 index 0000000000..5fb838010a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/suchen/index.html @@ -0,0 +1,105 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/suchen +tags: + - JavaScript + - Méthode + - Prototyp + - Referenz + - Regulärer Ausdruck + - Zeichenkette +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>search()</code></strong> methode führt eine Suche für eine Übereinstimmung von einem Regulären Ausdruck und diesem {{jsxref("String")}} Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-search.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein Regulär-Ausdruck Objekt. Wenn ein nicht-RegExp Objekt <code>obj</code> eingereicht wird, wird es durch <code>new RegExp(obj)</code> zu {{jsxref("RegExp")}} konvertiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die erste übereinstimmung zwischen dem Regulären Audruck und und der gegebenen Zeichenkette; wenn nicht gefunden, <strong>-1</strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn du wissen willst ob ein Muster gefunden wurde, und was sein Index ist nutze <code>search()</code> (wenn du nur wissen willst ob es das gibt nutze die ähnliche {{jsxref("RegExp.prototype.test()", "test()")}} Methode auf dem RegExp Prototyp, der einen boolean zurückgibt); für mehr informationen (aber langsamererere Ausführung) nutze {{jsxref("String.prototype.match()", "match()")}} (ähnlich zum Ausdruck {{jsxref("RegExp.prototype.exec()", "exec()")}}).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_search">Benutzung von <code>search()</code></h3> + +<p>Das folgende Beispiel durchsucht eine Zeichenkette mit 2 verschiedenen regex Objekten, um eine erfolgreiche, und unerfolgreiche Suche zu zeigen.</p> + +<pre class="brush: js">var str = "hey LukE"; +var re = /[A-Z]/g; +var re2 = /[.]/g; +console.log(str.search(re)); // gibt 4 zurück, was der Index des ersten Großbuchstaben "L" ist. +console.log(str.search(re2)); // gibt -1 zurück kann "." nicht finden</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initielle Definition. Eingeführt in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.search")}}</p> + +<h2 id="Gecko-spezifische_Hinweise">Gecko-spezifische Hinweise</h2> + +<ul> + <li><code>flags</code> war ein nicht-standard Zweitargument nur in Gecko verfügbar: <var>str</var>.search(<var>regexp, flags</var>)</li> + <li>Vorher {{Gecko("8.0")}}, <code>search()</code> war falsch eingeführt; wenn es ohne oder mit {{jsxref("undefined")}} parametern Ausgeführt wurde, würde es mit 'undefined' übereinstimmen, anstatt mit einer leeren Zeichenkette übereinzustimmen. Das wurde behoben; jetzt ist <code>'a'.search()</code> und <code>'a'.search(undefined)</code> korrekt und geben 0 zurück.</li> + <li>Ab Gecko 39 {{geckoRelease(39)}}, gibt das nicht-Standard <code>flag</code> Argument eine Konsolenwarnung ({{bug(1142351)}}).</li> + <li>Ab Gecko 47 {{geckoRelease(47)}}, ist das nicht-Standard <code>flag</code> Argument nicht länger unterstützt in nicht-veröffentlichten Builds und wird bald vollständig entfernt ({{bug(1245801)}}).</li> + <li>Ab Gecko 49 {{geckoRelease(49)}}, ist das nicht-Standard <code>flag</code> Argument nicht länger unterstützt ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..f3eb4d9f68 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,79 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLowerCase()</code></strong> Methode gibt den Wert des aufrufenden Strings in Kleinbuchstaben umgewandelt zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den alten String konvertiert zu Kleinbuchstaben enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toLowerCase()</code> Methode gibt den Wert des Strings in Kleinbuchstaben umgewandelt zurück. <code>toLowerCase()</code> hat keine Auswirkungen auf den Wert des Strings <code>str</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_toLowerCase()">Benutzung von <code>toLowerCase()</code></h3> + +<pre class="brush: js">console.log('ALPHABET'.toLowerCase()); // 'alphabet' +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.toLowerCase")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/touppercase/index.html b/files/de/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..c221990e73 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,127 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<div> +<div>{{JSRef}}</div> + +<p>Die <strong><code>toUpperCase()</code></strong> Methode gibt den Wert des aufrufenden Strings in Großbuchstaben umgewandelt zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den alten String konvertiert zu Großbuchstaben enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toUpperCase()</code> Methode gibt den Wert des Strings in Großbuchstaben umgewandelt zurück. <code>toUpperCase()</code> hat keine Auswirkungen auf den Wert des Strings <code>str</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_toUpperCase()">Benutzung von <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log('alphabet'.toUpperCase()); // 'ALPHABET' +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> +</div> diff --git a/files/de/web/javascript/reference/global_objects/string/trim/index.html b/files/de/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..59ada93228 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,93 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Global_Objects/String/Trim +tags: + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef}}</div> + +<p>Die<strong><code> trim()</code></strong> Methode entfernt Leerzeichen an beiden Enden einer Zeichenfolge. Das betrifft Leerzeichen verschiedenster Art (space, tab, no-break space, etc.) und alle Zeilenumbruch einleitende Zeichen (LF, CR, etc.).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.trim()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den gegebenen String ohne Whitespaces am Anfang und am Ende enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trim()</code> Methode gibt eine Zeichenfolge ohne Leerzeichen an beiden Enden zurück. <code>trim()</code> beeinflusst oder verändert nicht den ursprünglichen Wert der Zeichenfolge.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="trim()_verwenden"><code>trim()</code> verwenden</h3> + +<p>Das folgende Beispiel zeigt die kleingeschriebene Zeichenfolge <strong><code>'foo'</code></strong>:</p> + +<pre class="brush: js">var orig = ' foo '; +console.log(orig.trim()); // 'foo' + +// Ein Beispiel bei dem .trim() Leerzeichen an einem Ende entfernt + +var orig = 'foo '; +console.log(orig.trim()); // 'foo' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Führe folgenden Code vor allem anderen aus um die Methode <strong><code>trim()</code></strong> zu erstellen sollte sie nativ nicht zur Verfügung stehen.</p> + +<pre class="brush: js">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</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">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trim")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/trimleft/index.html b/files/de/web/javascript/reference/global_objects/string/trimleft/index.html new file mode 100644 index 0000000000..db5dbd55cb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trimleft/index.html @@ -0,0 +1,58 @@ +--- +title: String.prototype.trimLeft() +slug: Web/JavaScript/Reference/Global_Objects/String/TrimLeft +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>trimLeft()</code></strong> Methode entfernt Leerzeichen vom linken Ende der Zeichenkette.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimLeft()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuen String, der den alten String ohne Whitespaces auf der linken Seite beinhaltet.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trimLeft()</code> Methode gibt die Zeichenkette ohne Leerzeichen am linken Ende zurück. <code>trimLeft()</code> manipuliert nicht den Wert der Zeichenkette.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="trimLeft()_verwenden"><code>trimLeft()</code> verwenden</h3> + +<p>Im folgenden Beispiel wird die Funktionalität dieser Methode dargestellt.</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimLeft(); +console.log(str.length); // 5 +console.log(str); // 'foo ' +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Gehört keinem Standard an. Hinzugefügt in JavaScript 1.8.1.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trimLeft")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/trimright/index.html b/files/de/web/javascript/reference/global_objects/string/trimright/index.html new file mode 100644 index 0000000000..b66e15f474 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trimright/index.html @@ -0,0 +1,58 @@ +--- +title: String.prototype.trimRight() +slug: Web/JavaScript/Reference/Global_Objects/String/TrimRight +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>trimRight()</code></strong> Methode entfernt Leerzeichen vom rechten Ende der Zeichenkette.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimRight()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuen String, der den alten String ohne Whitespaces auf der rechten Seite beinhaltet.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trimRight()</code> Methode gibt die Zeichenkette ohne Leerzeichen am rechten Ende zurück. <code>trimRight()</code> manipuliert nicht den Wert der Zeichenkette.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="trimRight()_verwenden"><code>trimRight()</code> verwenden</h3> + +<p>Im folgenden Beispiel wird die Funktionalität dieser Methode dargestellt.</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimRight(); +console.log(str.length); // 6 +console.log(str); // ' foo' +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Gehört keinem Standard an. Hinzugefügt in JavaScript 1.8.1.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trimRight")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> +</ul> |