diff options
Diffstat (limited to 'files/de/web/javascript/reference/global_objects/regexp')
4 files changed, 875 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/global_objects/regexp/flags/index.html b/files/de/web/javascript/reference/global_objects/regexp/flags/index.html new file mode 100644 index 0000000000..65956f3c3b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/flags/index.html @@ -0,0 +1,83 @@ +--- +title: RegExp.prototype.flags +slug: Web/JavaScript/Reference/Global_Objects/RegExp/flags +tags: + - ECMAScript 2015 + - Eigenschaft + - JavaScript + - Prototyp + - Referenz + - RegExp + - Regular Expressions + - Reguläre Expressionen +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>flags</code></strong> Eigenschaft gibt einen String mit den Flags des RegExp-Objektes zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-flags.html")}}</div> + +<p class="hidden">Der Code für dieses interaktive Beispiel ist in einem GitHub Repository gespeichert. Wenn du etwas zum Interaktiven-Beispiel-Project beitragen möchtest, klone bitte <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und sende uns Pull-Requests.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Flags in der <code>flags</code> Eigenschaft sind alphabetisch sortiert (von links nach rechts, z.B. <code>"gimuy"</code>).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Die_flags_benutzen">Die <code>flags</code> benutzen</h3> + +<pre class="brush: js">/foo/ig.flags; // "gi" +/bar/myu.flags; // "muy" +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (RegExp.prototype.flags === undefined) { + Object.defineProperty(RegExp.prototype, 'flags', { + configurable: true, + get: function() { + return this.toString().match(/[gimuy]*$/)[0]; + } + }); +} +</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-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initielle Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatiblität">Browser-Kompatiblität</h2> + +<div> +<div class="hidden">Die Kompatiblitäts-Tabelle auf dieser Seite ist generiert von strukturierter Daten. Wenn du etwas dazu beitragen möchtest, solltest du dir <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> anschauen und uns Pull-Requests schicken.</div> + +<p> {{Compat("javascript.builtins.RegExp.flags")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.source")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/index.html b/files/de/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..9639ba265f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,560 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - JavaScript + - Klasse + - Referenz + - RegExp + - Reguläre Ausdrücke +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<p>{{JSRef}}</p> + +<p>Der <code><strong>RegExp</strong> constructor</code> erstellt ein Objekt mit regulären Werten, um diese dann als Muster an einem Text anzuwenden.</p> + +<p>Für eine Einführung über reguläre Ausdrücke, lies das <a href="/en-US/docs/JavaScript/Guide/Regular_Expressions">Kapitel Regular Expressions im JavaScript Guide</a> (englisch).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>/<em>muster</em>/<em>flags</em></code> + +<code>RegExp(<em>muster</em> <em>[, flags]</em>)</code> +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>muster</code></dt> + <dd>Text des regulären Ausdrucks.</dd> + <dt><code>flags</code></dt> + <dd> + <p>Optional, flags kann eine Zeichenkette mit einer beliebige Kombination folgender Werte sein:</p> + + <dl> + <dt><code>g</code></dt> + <dd>globale Suche (nach einem Treffer fortsetzen)</dd> + <dt><code>i</code></dt> + <dd>Groß-/Kleinschreibung ignorieren</dd> + <dt><code>m</code></dt> + <dd>multiline; behandelt den Suchkontext als Mehrfachzeilen, d.h. Anfang- und Endeanker (^ und $) entsprechen dem Anfang bzw. Ende <em>jeder einzelnen</em> Zeile (begrenzt durch \n oder \r), nicht nur dem Anfang und Ende der gesamten zu durchsuchenden Zeichenkette.</dd> + <dt><code>y</code> {{Fx_minversion_inline(3)}} {{non-standard_inline}}</dt> + <dd>sticky; matches only from the index indicated by the <code>lastIndex</code> property of this regular expression in the target string (and does not attempt to match from any later indexes). This allows the match-only-at-start capabilities of the character "^" to effectively be used at any location in a string by changing the value of the <code>lastIndex</code> property.</dd> + </dl> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Es bestehen zwei Möglichkeiten, ein RegExp-Objekt zu erzeugen: Eine literale Notation und ein Konstruktor. In der literaren Version werden im Gegensatz zu der Konstruktorversion keine Anführungszeichen verwendet, um Zeichenketten zu kennzeichnen. Dementsprechend erzeugen beide der folgenden Zeilen den gleichen regulären Ausdruck:</p> + +<pre class="brush: js notranslate">/ab+c/i; +new RegExp("ab+c", "i"); +</pre> + +<p>Die literale Notation stellt eine Kompilierung des regulären Ausdrucks während der Auswertung des Ausdrucks bereit. Nutzen Sie die literale Notation, wenn der reguläre Ausdruck unverändert bleiben wird. Wenn Sie zum Beispiel die literale Notation für die Erzeugung eines regulären Ausdruck verwenden, um ihn in einer Schleife zu anzuwenden, wird der reguläre Ausdruck nicht in jedem Schleifendurchlauf rekompiliert.</p> + +<p>Der Konstruktor des RegExp-Objekts, z.B. <code>new RegExp("ab+c")</code>, stellt eine Laufzeitkompilierung des regulären Ausdrucks bereit. Nutzen Sie die Konstruktor-Funktion, wenn sich das reguläre Suchmuster ändern wird oder Sie das Muster nicht kennen und es aus einer anderen Quelle wie z.B. einer Benutzereingabe beziehen.</p> + +<p>Bei Verwendung der Konstruktor-Funktion sind die normalen Zeichenfolgenmaskierungsregeln (Voranstellen eines Rückwärtsschrägstrichs (\) vor Sonderzeichen innerhalb von Zeichenketten) einzuhalten. Zum Beispiel sind folgende Zeilen äquivalent:</p> + +<pre class="brush: js notranslate">var re = /\w+/; +var re = new RegExp("\\w+"); +</pre> + +<h2 id="Bedeutung_spezieller_Zeichen_in_regulären_Ausdrücken">Bedeutung spezieller Zeichen in regulären Ausdrücken</h2> + +<ul> + <li><a href="#Zeichenklassen">Zeichenklassen</a></li> + <li><a href="#Zeichenauswahl">Zeichenauswahl</a></li> + <li><a href="#Bereichsgrenzen">Bereichsgrenzen</a></li> + <li><a href="#Gruppierung-und-Rueckwaertsreferenz">Gruppierung und Rückwärtsreferenzen</a></li> + <li><a href="#Quantoren">Quantoren</a></li> +</ul> + +<table class="fullwidth-table"> + <tbody> + <tr id="character-classes"> + <th colspan="2"><a name="Zeichenklassen">Zeichenklassen</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(Punkt, Satzendezeichen) stimmt mit jedem Einzelzeichen <em>außer</em> den Zeilenvorschub- und Wagenrücklaufzeichen (<code>\n</code> <code>\r</code> <code>\u2028</code> oder <code>\u2029</code>) überein.</p> + + <p>Zu beachten ist, dass das <code>m</code> <em>multiline flag</em> nicht das Punktverhalten verändert. Um ein Musterentsprechung über mehrere Zeilen hinweg zu erreichen, kann die leere negative Zeichenauswahl <code>[^]</code> verwendet werden, sie stimmt mit jedem Zeichen einschließlich Zeilenumbrüchen überein.</p> + + <p><code>/.y/</code> passt z.B. auf "my" und "ay", nicht aber auf "yes" in "yes make my day".</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Stimmt mit einer arabischen Ziffer überein. Äquivalent zu <code>[0-9]</code>.</p> + + <p><code>/\d/</code> or <code>/[0-9]/</code> passt z.B. auf '2' in "B2 ist die Zimmernummer."</p> + </td> + </tr> + <tr> + <td><code>\D</code></td> + <td> + <p>Stimmt mit jedem Zeichen überein, das keine arabische Ziffer ist. Äquivalent zu <code>[^0-9]</code>.</p> + + <p><code>/\D/</code> or <code>/[^0-9]/</code> passt z.B. auf 'B' in "B2 ist die Zimmernummer."</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Stimmt mit einem alphanumerischen Zeichen (Wortzeichen) einschließlich dem Unterstrich überein. Äquivalent zu <code>[A-Za-z0-9_]</code>.</p> + + <p><code>/\w/</code> passt zum Beispiel auf 'A' in "Apfel", '5' in "€5,28," und '3' in "3D."</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Stimmt mit jedem Zeichen überein, das kein alphanumerisches Zeichen (Wortzeichen) ist. Äquivalent zu <code>[^A-Za-z0-9_]</code>.</p> + + <p><code>/\W/</code> or <code>/[^A-Za-z0-9_]/</code> passt z.B. auf '%' in "50%."</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Stimmt mit einem einzelnen Leerraumzeichen überein (Leerzeichen, Tabulator, Seitenvorschub, Zeilenvorschub und weitere Unicode-Zeichen). Äquivalent zu <code>[ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f \u3000]</code>.</p> + + <p><code>/\s\w*/</code> passt z.B. auf ' bar' in "foo bar."</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Stimmt mit einem einzelnen Zeichen überein, das kein Leerraumzeichen ist. (Nicht-Leerraumzeichen).<br> + Äquivalent zu <code>[^\s]</code> und zu <code>[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f \u3000]</code>.</p> + + <p><code>/\S\w*/</code> passt z.B. auf 'foo' in "foo bar."</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Stimmt mit einem Tabulatorzeichen überein.</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Stimmt mit einem Wagenrücklaufzeichen überein.</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Stimmt mit einem Zeilenvorschub überein.</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Stimmt mit einem vertikalen Tabulatorzeichen überein.</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Stimmt mit einem Seitenvorschub überein.</td> + </tr> + <tr> + <td><code>[\b]</code></td> + <td> + <p>Stimmt mit einem Rücklöschzeichen (Backspace) überein. (Nicht zu verwechseln mit <code>\b</code>)</p> + </td> + </tr> + <tr> + <td><code>\0</code></td> + <td>Stimmt mit einem NUL-Zeichen überein. (Keine weiteren Ziffern dürfen folgen!)</td> + </tr> + <tr> + <td><code>\c<em>X</em></code></td> + <td> + <p>Wobei <code><em>X</em></code> ein Buchstabe von A - Z ist. Stimmt mit einem Steuerzeichen überein.</p> + + <p><code>/\cM/</code> passt z.B. auf Steuerung-M in einer Zeichenkette.</p> + </td> + </tr> + <tr> + <td><code>\x<em>hh</em></code></td> + <td> + <p>Stimmt mit einem Zeichen mit dem Code <code><em>hh</em></code> (zwei hexadezimale Ziffern) überein.</p> + + <p>/foo\x20bar/ passt z.B. auf 'o b' in "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\u<em>hhhh</em></code></td> + <td>Stimmt mit einem Zeichen mit dem Unicode <code><em>hhhh</em></code> (vier hexadezimale Ziffern) überein.</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Bei einem Zeichen, das normalerweise als Literal behandelt wird, signalisiert ein vorangestellter Rückschrägstrich, dass es als Spezialzeichen und nicht als Literal zu interpretieren ist.</p> + + <p>Z.B. passt <code>/b/</code> auf das Zeichen <code>'b'</code>. Durch Voranstellen des Rückschrägstriches vor das "b", also <code>/\b/</code>, bekommt das Zeichen eine besondere Bedeutung und passt auf eine Wordgrenze.</p> + + <p><em>oder</em></p> + + <p>Bei einem Zeichen, das normalerweise als Zeichen mit spezieller Bedeutung interpretiert wird, signalisiert ein vorangestellter Rückschrägstrich, dass es ohne besondere Bedeutung als Literal interpretiert werden soll.</p> + + <p>Zum Beispiel ist * Quantor-Spezialzeichen, das eine Übereinstimmung mit null oder mehreren Vorkommen des vorausgehenden Zeichens bedeutet; z.B. bedeutet <code>/a*/</code> eine Übereinstimmung von null oder mehr "a"s. Um dem "<code>*"</code> als Literal zu entsprechen, wird ein Rückschrägstrich vorangestellt; z.B. passt <code>/a\*/</code> auf 'a*'.</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="character-sets"> + <th colspan="2"> + <p><a name="Zeichenauswahl">Zeichenauswahl</a></p> + </th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>[xyz]</code></td> + <td> + <p>Zeichenauswahl, stimmt mit einem Beliebigen der eingeschlossenen Zeichen überein. Mittels eines Bindestriches kann ein Bereich von Zeichen angegeben werden.</p> + + <p><code>[abcd]</code> ist gleichbedeutend mit<code>[a-d]</code> und passt auf 'b' in "brisket" und 'c' in "chop".</p> + </td> + </tr> + <tr> + <td><code>[^xyz]</code></td> + <td> + <p>Eine negative bzw. komplementäre Zeichenauswahl. Das bedeutet eine Übereinstimmung mit jedem Zeichen, das <em>nicht</em> in den eckigen Klammern eingeschlossen ist. Mittels eines Bindestriches kann ein Bereich von Zeichen angegeben werden.</p> + + <p>Zum Beispiel ist <code>[^abc]</code> gleichbedeutend mit<code> [^a-c]</code>. Beides passt auf 'o' in "bacon" und 'h' in "chop."</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="boundaries"> + <th colspan="2"><a name="Bereichsgrenzen">Bereichsgrenzen</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Stimmt mit dem Anfang eines Subjekts und, wenn das <em>multiline flag</em> gesetzt ist, auch mit der Stelle unmittelbar nach einem Zeilenumbruchzeichen überein.</p> + + <p><code>/^E/</code> passt z.B. nicht auf 'E' in "ein E" aber auf das erste 'E' in "Ein E."</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Stimmt mit dem Ende eines Subjekts und, wenn das <em>multiline flag</em> gesetzt ist, auch mit der Stelle unmittelbar vor einem Zeilenumbruchzeichen überein.</p> + + <p><code>/t$/</code> passt z.B. auf das 't' in "Brot", nicht aber in "Brote".</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Stimmt mit einer null-breiten Wortgrenze wie zwischen einem Buchstaben und einem Leerzeichen überein. (Nicht zu verwechseln mit der Zeichenklasse <code>[\b]</code>)</p> + + <p><code>/\bno/</code> passt z.B. auf 'no' in "at noon"; <code>/ly\b/</code> passt auf 'ly' in "possibly yesterday."</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Stimmt mit einer null-breiten Nichtwortgrenze wie zwischen zwei Buchstaben oder zwischen zwei Leerzeichen überein.</p> + + <p><code>/\Bon/</code> passt z.B. auf 'on' in "at noon" und <code>/ye\B/</code> passt auf 'ye' in "possibly yesterday."</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="grouping-back-references"> + <th colspan="2"><a name="Gruppierung-und-Rueckwaertsreferenz">Gruppierung und Rückwärtsreferenz</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>(<em>x</em>)</code></td> + <td> + <p>Stimmt mit <code><em>x</em></code> überein und speichert die Übereinstimmung. Dies wird auch <em>capturing parentheses</em> (engl., aufzeichnende Klammern) genannt.</p> + + <p><code>/(foo)/</code> passt z.B. auf 'foo' in "foo bar" und speichert die Übereinstimmung. Aufgezeichnete Teilzeichenketten können aus den Elementen <code>[1], ..., [n]</code> des Ergebnisfelds (Array) oder den Eigenschaften <code>$1, ..., $9</code> des vordefinierten <code>RegExp</code>-Objekts ausgelesen werden.</p> + + <p>Aufzeichnende Gruppierungen führen zu Performanzeinbußen. Wenn die übereinstimmenden Teilzeichenketten nicht wiederverwendet werden müssen, sind nicht aufzeichnende Klammern zu bevorzugen (siehe weiter unten).</p> + </td> + </tr> + <tr> + <td><code>\<em>n</em></code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Ein Rückbezug auf die zuletzt gefundene Teilzeichenkette, die der Übereinstimmung mit der n-ten runden Klammer im regulären Ausdruck entspricht (öffnende Klammern gezählt).</p> + + <p><code>/apple(,)\sorange\1/</code> passt z.B. auf 'apple, orange,' in "apple, orange, cherry, peach." und zeichnet das Komma auf. Ein umfassenderes Beispiel folgt im Anschluss an diese Tabelle.</p> + </td> + </tr> + <tr> + <td><code>(?:<em>x</em>)</code></td> + <td>Stimmt mit <code><em>x</em></code> überein, speichert die Übereinstimmung aber nicht, auch <em>non-capturing parentheses</em> genannt. Auf die übereinstimmende Teilzeichenkette kann nicht mittels der Elemente <code>[1], ..., [n]</code> des Arrays oder der vordefinierten Eigenschaften <code>$1, ..., $9 </code>des <code>RegExp</code>-Objekts zugegriffen werden .</td> + </tr> + </tbody> + <tbody> + <tr id="quantifiers"> + <th colspan="2"><a name="Quantoren">Quantoren</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>*</code></td> + <td> + <p>Stimmt mit dem null- oder mehrmaligen Vorkommen des voranstehenden Zeichen überein.</p> + + <p><code>/bo*/</code> passt z.B. auf 'boooo' in "A ghost booooed" und 'b' in "A bird warbled", aber auf nichts in "A goat grunted".</p> + </td> + </tr> + <tr> + <td><code>+</code></td> + <td> + <p>Stimmt mit dem ein- oder mehrmaligen Vorkommen des voranstehenden Zeichen überein. Äquivalent zu <code>{1,}</code></p> + + <p><code>/ca+/</code> passt z.B. auf 'ca' in "candy" und 'caaa' in "caaandy" aber auf nichts in "cindy".</p> + </td> + </tr> + <tr> + <td><code>*?</code><br> + <code>+?</code></td> + <td> + <p>Passt wie <code>*</code> und<code>+</code> weiter oben, aber der Ausdruck ist nicht gierig, d.h. er passt auf die kürzestmögliche Übereinstimmung.</p> + + <p><code>/_.*?_/</code> passt z.B. auf "_foo_" in "_foo_ _bar_" aber nicht auf "_foo_ _bar_" wie der Ausdruck ohne dem <code>?</code> hinterm <code>*</code>.</p> + </td> + </tr> + <tr> + <td><code>?</code></td> + <td> + <p>Stimmt mit dem null- oder einmaligen Vorkommen des voranstehenden Zeichens überein.</p> + + <p><code>/e?le?/</code> passt z.B. auf das 'el' in "angel" und auf das 'le' in "angle."</p> + + <p>If used immediately after any of the quantifiers <code>*</code>, <code>+</code>, <code>?</code>, or <code>{}</code>, makes the quantifier non-greedy (matching the minimum number of times), as opposed to the default, which is greedy (matching the maximum number of times).</p> + + <p>Das Fragezeichen wird auch in lookahead assertions verwendet, welche unter <code>(?=)</code>, <code>(?!)</code>, sowie <code>(?:)</code> in dieser Tabelle beschrieben sind.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>(?=<em>y</em>)</code></td> + <td>Passt nur auf <code><em>x</em></code>, wenn <code><em>y</em></code> darauf folgt. Zum Beispiel passt <code>/Jack(?=Sprat)/</code> nur auf 'Jack', wenn danach 'Sprat' folgt. <code>/Jack(?=Sprat|Frost)/</code> passt nur auf 'Jack', wenn 'Sprat' oder 'Frost' folgt. Allerdings ist weder 'Sprat' noch 'Frost' Teil der Übereinstimmungsresultate.</td> + </tr> + <tr> + <td><code><em>x</em>(?!<em>y</em>)</code></td> + <td> + <p>Passt nur auf <code><em>x</em></code>, wenn darauf nicht <code><em>y</em></code> folgt. <code>/\d+(?!\.)/</code> z.B. stimmt nur mit einer Zahl überein, sofern kein Dezimalpunkt folgt.</p> + + <p><code>/\d+(?!\.)/.exec("3.141")</code> passt auf 141, aber nicht auf 3.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>|<em>y</em></code></td> + <td> + <p>Passt entweder auf <code><em>x</em></code> oder <code><em>y</em></code>.</p> + + <p><code>/green|red/</code> passt z.B. auf 'green' in "green apple" und auf 'red' in "red apple."</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>}</code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Stimmt mit genau <code><em>n</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{2}/</code> passt z.B. auf beide 'a' in "caandy" und die ersten beiden 'a' in "caaandy", nicht aber auf das 'a' in "candy".</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>,}</code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Stimmt mit mindestens <code><em>n</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{2,}/</code> passt z.B. auf alle 'a' in "caandy" und in "caaaaaaandy.", nicht aber auf das 'a' in "candy".</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>,<em>m</em>}</code></td> + <td> + <p>Wobei <code><em>n</em></code> und <code><em>m</em></code> positive Ganzzahlen sind. Stimmt mit mindestens <code><em>n</em></code> und höchstens <code><em>m</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{1,3}/</code> passt z.B. auf nichts in "cndy", das 'a' in "candy," die beiden 'a' in "caandy," und die ersten drei 'a' in "caaaaaaandy". Es ist zu beachten, dass bei der Übereinstimmung in "caaaaaaandy" der Treffer "aaa" ist, obwohl in der Originalzeichenkette mehr 'a' vorhanden wären.</p> + </td> + </tr> + </tbody> +</table> + +<h3 id="Fußnoten">Fußnoten</h3> + +<ol> + <li>{{endnote("equivalent_s")}}Equivalent to: + <p><code>[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> + </li> + <li>{{endnote("equivalent_S")}}Equivalent to: + <p><code>[^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> + </li> +</ol> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<dl> + <dt><a href="/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/prototype" title="JavaScript/Reference/Global_Objects/RegExp/prototype">prototype</a></dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu allen Objekten</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h3 id="Methoden">Methoden</h3> + +<p>Das globale <code>RegExp</code> Objekt hat keine eigenen Methoden. Es erbt allerdings manche Methoden durch die Prototypenkette.{{jsOverrides("Function", "Methods", "prototype")}}</p> + +<h2 id="RegExp-Instanzen"><code>RegExp</code>-Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('en/JavaScript/Reference/Global_Objects/RegExp/prototype','Properties')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('en/JavaScript/Reference/Global_Objects/RegExp/prototype','Methods')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Beispiel_Anwendung_regulären_Ausdrucks_zur_Datenformatänderung">Beispiel: Anwendung regulären Ausdrucks zur Datenformatänderung</h3> + +<p>Das folgende Script nutzt die <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="JavaScript/Reference/Global_Objects/String/replace">replace</a></code> Methode und nutzt die vererbte <a href="/en-US/docs/JavaScript/Reference/Global_Objects/String" title="JavaScript/Reference/Global_Objects/String">String</a> Instanz <code>(re)</code> um als Rückgabewert eine Übereinstimmung des Namens <code>(str) </code>in dem Format <em>erster, letzter </em>und im Format <em>letzter</em>, <em>erster </em>zu finden. In dem zu ersetzenden Text nutzt das Script $1 und $2 um das Ergebnis der übereinstimmenden Treffer in der Klammer als Muster des regulären Ausdrucks.</p> + +<pre class="brush: js notranslate">var re = /(\w+)\s(\w+)/; +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); +print(newstr);</pre> + +<p>Das ergibt: "Smith, John".</p> + +<h3 id="Beispiel_Anwendung_eines_regulären_Ausdrucks_auf_mehrzeilige_Texte">Beispiel: Anwendung eines regulären Ausdrucks auf mehrzeilige Texte</h3> + +<pre class="brush: js notranslate">var s = "Please yes\nmake my day!"; +s.match(/yes.*day/); +// Returns null +s.match(/yes[^]*day/); +// Returns 'yes\nmake my day' +</pre> + +<h3 id="Beispiel_Anwendung_eines_regulären_Ausdrucks_mit_dem_sticky_flag">Beispiel: Anwendung eines regulären Ausdrucks mit dem "sticky" flag</h3> + +<p>Dieses Beispiel zeigt, wie man die feste Kennzeichung (<code>sticky flag</code>) an reguläre Ausdrücke nutzt, um Übereinstimmungen von individuelle Treffer von mehrzeigen Eingaben zu erhalten.</p> + +<pre class="brush: js notranslate">var text = "First line\nSecond line"; +var regex = /(\S+) line\n?/y; + +var match = regex.exec(text); +print(match[1]); // prints "First" +print(regex.lastIndex); // prints 11 + +var match2 = regex.exec(text); +print(match2[1]); // prints "Second" +print(regex.lastIndex); // prints "22" + +var match3 = regex.exec(text); +print(match3 === null); // prints "true"</pre> + +<p>One can test at run-time whether the sticky flag is supported, using <code>try { … } catch { … }</code>. For this, either an <code>eval(…)</code> expression or the <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since the <code>/<var>regex</var>/<var>flags</var></code> notation is processed at compile-time, so throws an exception before the <code>catch</code> block is encountered). For example:</p> + +<pre class="brush: js notranslate">var supports_sticky; +try { RegExp('','y'); supports_sticky = true; } +catch(e) { supports_sticky = false; } +alert(supports_sticky); // alerts "true"</pre> + +<h3 id="Beispiel_Regulärer_Ausdruck_und_Unicode-Zeichen">Beispiel: Regulärer Ausdruck und Unicode-Zeichen</h3> + +<p>Wie oben erwähnt treffen Übereinstimmugnen mit <code>\w</code> or <code>\W</code> nur ASCII basierende Zeichen; als Beispiel: 'a' bis 'z', 'A' bis 'Z', 0 bis 9 und '_'. Um Übereinstimmungen für Zeichensätze anderer Sprachen wie Kyrillisch oder Hebräisch zu erzielen, nutze <code>\uhhhh</code>., während "hhhh" den Unicode-Wert des Zeichensatzes in Hexadezimal angibt. Dieses Beispiel demonstriert wie man Unicode-Zeichen aus einem Wort erhält:</p> + +<pre class="brush: js notranslate">var text = "Образец text на русском языке"; +var regex = /[\u0400-\u04FF]+/g; + +var match = regex.exec(text); +print(match[0]); // prints "Образец" +print(regex.lastIndex); // prints "7" + +var match2 = regex.exec(text); +print(match2[0]); // prints "на" [did not print "text"] +print(regex.lastIndex); // prints "15" + +// and so on</pre> + +<p>Hier ist eine externe Quelle um alle Unicode Blöcke für verschiedene Scripte zu erhalten: <a href="http://kourge.net/projects/regexp-unicode-block" title="http://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a></p> + +<h3 id="Weitere_nennenswerte_Beispiele">Weitere nennenswerte Beispiele</h3> + +<h5 id="Extrahieren_eines_Subdomain-Namens_aus_einer_URL">Extrahieren eines Subdomain-Namens aus einer URL</h5> + +<pre class="brush: js notranslate" style="font-size: 14px;">var url = "http://xxx.domain.com"; +print(/[^.]+/.exec(url)[0].substr(7)); // prints "xxx"</pre> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<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 (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Phone</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/JavaScript/Guide/Regular_Expressions" title="JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="/en-US/docs/JavaScript/Guide" title="JavaScript/Guide">JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/input/index.html b/files/de/web/javascript/reference/global_objects/regexp/input/index.html new file mode 100644 index 0000000000..d173458705 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/input/index.html @@ -0,0 +1,105 @@ +--- +title: RegExp.input ($_) +slug: Web/JavaScript/Reference/Global_Objects/RegExp/input +tags: + - JavaScript + - Property + - Reference + - RegExp + - Regular Expressions +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/input +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die nicht-standarde input Propertie ist eine statische Propertie regularer Expressionen, welche die Zeichenkette, der eine reguläre Expression entgegengestellt wird, enthält. <code>RegExp.$_</code> ist ein Alias für diese Propertie.</p> + +<h2 id="Syntaxis">Syntaxis</h2> + +<pre class="syntaxbox"><code><var>RegExp</var>.input +RegExp.$_</code> +</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>input</code>-Propertie ist statisch, ist nicht eine Propertie eines einzigen Obiectes einer regulären Expression. Stattdessen nutzt man es immer als <code>RegExp.input</code> oder</p> + +<p>Der Wert der <code>input</code>-Propertie wird verändert, wenn die gesuchte Zeichenkette in der regulären Expression verändert wird und diese Zeichenkette passt.</p> + +<h2 id="Beispiele"><code>Beispiele</code></h2> + +<h3 id="Verwendung_von_input_und__"><code>Verwendung von <code>input</code> und <code>$_</code></code></h3> + +<pre class="brush: js"><code>var re = /hi/g; +re.test("hi there!"); +RegExp.input; // "hi there!" +re.test("foo"); // neuer Test, unpassend +RegExp.$_; // "hi there!" +re.test("hi world!"); // neuer Test, passend +RegExp.$_; // "hi world!" +</code></pre> + +<h2 id="Specificationen"><code>Specificationen</code></h2> + +<p><code>Non-standard. Nicht Teil von irgendeiner laufenden Specification.</code></p> + +<h2 id="Browsercompatibilität"><code>Browsercompatibilität</code></h2> + +<div><code>{{CompatibilityTable}}</code></div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th><code>Feature</code></th> + <th><code>Chrome</code></th> + <th><code>Firefox (Gecko)</code></th> + <th><code>Internet Explorer</code></th> + <th><code>Opera</code></th> + <th><code>Safari</code></th> + </tr> + <tr> + <td><code>Basisunterstützung</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th><code>Feature</code></th> + <th><code>Android</code></th> + <th><code>Chrome for Android</code></th> + <th><code>Firefox Mobile (Gecko)</code></th> + <th><code>IE Mobile</code></th> + <th><code>Opera Mobile</code></th> + <th><code>Safari Mobile</code></th> + </tr> + <tr> + <td><code>Basisunterstützung</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch"><code>Siehe auch</code></h2> + +<ul> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/test/index.html b/files/de/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..e908792657 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,127 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/test +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>test()</code></strong> Methode führt eine Suche nach einer Übereinstimmung zwischen einer regular expression und einem String durch. Sie gibt <code>true</code> oder <code>false</code> zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-test.html", "taller")}}</div> + +<p class="hidden">Der Quellcode dieses interaktiven Beispiels befindet sich in einer GitHub repository. Wenn Sie sich an diesem Projekt beteiligen möchten, clonen Sie bitte <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden Sie uns einen pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code><var>str</var></code></dt> + <dd>Der String, mit dem die regular expression verglichen wird.</dd> +</dl> + +<h3 id="Rückgabewerte">Rückgabewerte</h3> + +<p><code>true</code> wird zurückgegeben, wenn es eine Übereinstimmung zwischen der regular expression und dem String gibt <code><var>str</var></code>. Anderenfalls wird <code>false</code> zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Verwenden Sie <code>test()</code>, wenn Sie wissen möchten, ob ein Muster auf einen String zutrifft. <code>test()</code> gibt einen boolschen Wert zurück, wohingegen die {{jsxref("String.prototype.search()")}} Methode den Index der Übereinstimmung, oder wenn keine Übereinstimmung gefunden wird, <code>-1</code> zurück gibt.</p> + +<p>Um mehr Informationen zu erhalten, können Sie alternativ die langsammere {{jsxref("RegExp.prototype.exec()", "exec()")}} Methode verwenden. (Sie ähnelt {{jsxref("String.prototype.match()")}} Methode.)</p> + +<p>As with <code>exec()</code> (or in combination with it), <code>test()</code> called multiple times on the same global regular expression instance will advance past the previous match.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="test_anwenden">test() anwenden</h3> + +<p>Ein einfaches Beispiel, um zu testen, ob <code>"hello"</code> am Anfang eines Strings enthalten ist. Die Ausgabe ist ein boole'scher Wert. </p> + +<pre class="brush: js notranslate">const str = 'hello world!'; +const result = /^hello/.test(str); + +console.log(result); // true +</pre> + +<p>Das folgende Beispiel logt eine Nachricht, die vom Erfolg des Tests abhängt:</p> + +<pre class="brush: js notranslate">function testInput(re, str) { + let midstring; + if (re.test(str)) { + midstring = 'contains'; + } else { + midstring = 'does not contain'; + } + console.log(`${str} ${midstring} ${re.source}`); +} +</pre> + +<h3 id="Anwendung_von_test_mit_dem_Kennzeichen_global">Anwendung von test() mit dem Kennzeichen "global"</h3> + +<p>When a regex has the <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2">global flag</a> set, <code>test()</code> will advance the {{jsxref("RegExp.lastIndex", "lastIndex")}} of the regex. ({{jsxref("RegExp.prototype.exec()")}} also advances the <code>lastIndex</code> property.)</p> + +<p>Further calls to <code>test(<var>str</var>)</code> will resume searching <code><var>str</var></code> starting from <code>lastIndex</code>. The <code>lastIndex</code> property will continue to increase each time <code>test()</code> returns <code>true</code>. </p> + +<div class="blockIndicator note"> +<p><strong>Note:</strong> As long as <code>test()</code> returns <code>true</code>, <code>lastIndex</code> will <em>not</em> reset—even when testing a different string!</p> +</div> + +<p>When <code>test()</code> returns <code>false</code>, the calling regex's <code>lastIndex</code> property will reset to <code>0</code>.</p> + +<p>The following example demonstrates this behaviour:</p> + +<pre class="brush: js notranslate">const regex = /foo/g; // the "global" flag is set + +// regex.lastIndex is at 0 +regex.test('foo') // true + +// regex.lastIndex is now at 3 +regex.test('foo') // false + +// regex.lastIndex is at 0 +regex.test('barfoo') // true + +// regex.lastIndex is at 6 +regex.test('foobar') //false + +// regex.lastIndex is at 0 +// (...and so on) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_-Kompatibilität">Browser -Kompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.RegExp.test")}}</p> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<p>Prior to Firefox 8, <code>test()</code> was implemented incorrectly. When called without parameters, it would match against the value of the previous input (<code>RegExp.input</code> property) instead of against the string <code>"undefined"</code>.</p> + +<p>This is fixed. Now, <code>/undefined/.test()</code> correctly results in <code>true</code>, instead of throwing an error.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Das Kapitel <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> im <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype")}}</li> +</ul> |