String.prototype.match()

regexp

Ein reguläres Ausdrücks-Objekt oder ein beliebiges Objekt, das eine Symbol.match Methode besitzt.

Wenn regexp kein RegExp Objekt ist und keine Symbol.match Methode hat, wird es implizit mit new RegExp(regexp) in ein RegExp konvertiert.

Wenn Sie keinen Parameter angeben und die match() Methode direkt verwenden, erhalten Sie ein Array mit einem leeren String: [""], da dies dem Äquivalent von match(/(?:)/) entspricht.

Ein Array, dessen Inhalt von der Präsenz oder Absenz des globalen (g) Flags abhängt, oder null, wenn keine Übereinstimmungen gefunden werden.

• Wenn das g Flag verwendet wird, werden alle Ergebnisse, die mit dem vollständigen regulären Ausdruck übereinstimmen, zurückgegeben, aber keine Erfassungsgruppen sind enthalten.
• Wenn das g Flag nicht verwendet wird, werden nur das erste vollständige Match und die zugehörigen Erfassungsgruppen zurückgegeben. In diesem Fall wird match() dasselbe Ergebnis zurückgeben wie RegExp.prototype.exec() (ein Array mit einigen zusätzlichen Eigenschaften).

Die Implementierung von String.prototype.match macht nicht viel mehr, als die Symbol.match Methode des Arguments mit dem String als erstem Parameter aufzurufen. Die eigentliche Implementierung stammt von RegExp.prototype[Symbol.match]().

• Wenn Sie wissen müssen, ob eine Zeichenkette mit einem regulären Ausdruck RegExp übereinstimmt, verwenden Sie RegExp.prototype.test().
• Wenn Sie nur das erste gefundene Match möchten, sollten Sie stattdessen RegExp.prototype.exec() verwenden.
• Wenn Sie Erfassungsgruppen erhalten möchten und das globale Flag gesetzt ist, müssen Sie RegExp.prototype.exec() oder String.prototype.matchAll() verwenden.

Für weitere Informationen über die Semantik von match(), wenn ein regulärer Ausdruck übergeben wird, siehe RegExp.prototype[Symbol.match]().

Im folgenden Beispiel wird match() verwendet, um "Chapter" gefolgt von einem oder mehreren numerischen Zeichen, gefolgt von einem Dezimalpunkt und numerischem Zeichen null oder mehrmals zu finden.

Der reguläre Ausdruck enthält das i Flag, sodass Groß-/Kleinschreibungsunterschiede ignoriert werden.

const str = "For more information, see Chapter 3.4.5.1";
const re = /see (chapter \d+(\.\d)*)/i;
const found = str.match(re);

console.log(found);
// [
//   'see Chapter 3.4.5.1',
//   'Chapter 3.4.5.1',
//   '.1',
//   index: 22,
//   input: 'For more information, see Chapter 3.4.5.1',
//   groups: undefined
// ]

Im obigen Match-Ergebnis ist 'see Chapter 3.4.5.1' das gesamte Match. 'Chapter 3.4.5.1' wurde von (chapter \d+(\.\d)*) erfasst. '.1' war der letzte Wert, der von (\.\d) erfasst wurde. Die index Eigenschaft (22) ist der nullbasierte Index des gesamten Matches. Die input Eigenschaft ist die ursprüngliche Zeichenkette, die geparst wurde.

Das folgende Beispiel demonstriert die Verwendung des globalen Flags und ignore-case Flags mit match(). Alle Buchstaben von A bis E und a bis e werden zurückgegeben, jeder in seinem eigenen Element im Array.

const str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const regexp = /[A-E]/gi;
const matches = str.match(regexp);

console.log(matches);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

In Browsern, die benannte Erfassungsgruppen unterstützen, wird im folgenden Code "fox" oder "cat" in eine Gruppe namens animal erfasst:

const paragraph = "The quick brown fox jumps over the lazy dog. It barked.";

const capturingRegex = /(?<animal>fox|cat) jumps over/;
const found = paragraph.match(capturingRegex);
console.log(found.groups); // {animal: "fox"}

Wenn ein Objekt eine Symbol.match Methode hat, kann es als benutzerdefinierter Matcher verwendet werden. Der Rückgabewert von Symbol.match wird zum Rückgabewert von match().

const str = "Hmm, this is interesting.";

str.match({
  [Symbol.match](str) {
    return ["Yes, it's interesting."];
  },
}); // returns ["Yes, it's interesting."]

Wenn der regexp Parameter ein String oder eine Zahl ist, wird er implizit mit new RegExp(regexp) in ein RegExp konvertiert.

const str1 =
  "NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.";
const str2 =
  "My grandfather is 65 years old and My grandmother is 63 years old.";
const str3 = "The contract was declared null and void.";
str1.match("number"); // "number" is a string. returns ["number"]
str1.match(NaN); // the type of NaN is the number. returns ["NaN"]
str1.match(Infinity); // the type of Infinity is the number. returns ["Infinity"]
str1.match(+Infinity); // returns ["Infinity"]
str1.match(-Infinity); // returns ["-Infinity"]
str2.match(65); // returns ["65"]
str2.match(+65); // A number with a positive sign. returns ["65"]
str3.match(null); // returns ["null"]

Dies kann unerwartete Ergebnisse haben, wenn Sonderzeichen nicht richtig escaped werden.

console.log("123".match("1.3")); // [ "123" ]

Dies ist ein Match, weil . in einem regulären Ausdruck jedes Zeichen entspricht. Um es nur speziell für ein Punktzeichen zu machen, müssen Sie die Eingabe escapen.

console.log("123".match("1\\.3")); // null

• Polyfill von String.prototype.match in core-js mit Fixes und Implementierung von modernem Verhalten wie Symbol.match Unterstützung
• String.prototype.matchAll()
• RegExp
• RegExp.prototype.exec()
• RegExp.prototype.test()