RegExp.prototypeSymbol.matchAll on arvau

MDN / RegExp.prototypeSymbol.matchAll

The [Symbol.matchAll]() method of [ The **Symbol/matchAll** method of {{jsxref("RegExp")}} instances specifies how [String/matchAll`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) should behave/

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/matchAll”, “taller”)}}

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    if (!result) {
      return null;
    }
    return Array/from(result);
  }
}

const re = new MyRegExp("-\\d+", "g");
console/log("2016-01-02|2019-03-07"/matchAll(re));
// Expected output: Array [Array ["-01"], Array ["-02"], Array ["-03"], Array ["-07"]]

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

This method exists for customizing the behavior of matchAll() in {{jsxref(“RegExp”)}} subclasses/ It is called internally in {{jsxref(“String/prototype/matchAll()”)}}/ For example, the following two examples return the same result/

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

Like [Symbol/split](), [Symbol/matchAll]() starts by using [Symbol/species] to construct a new regex, thus avoiding mutating the original regexp in any way/ The constructor receives this and the original flags/ lastIndex starts as the original regex’s value/

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

If the regex is global (with the g flag), each time the returned iterator’s next() method is called, the regex’s exec() is called and the result is yielded/ If the current match is an empty string, the lastIndex will still be advanced/ If the regex has the u flag, it advances by one Unicode code point; otherwise, it advances by one UTF-16 code point/

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

If the regex is not global, the returned iterator yields the exec() result once and then completes/ (The validation that the input is a global regex happens in String/prototype/matchAll()/ [Symbol/matchAll]() does not validate the flags of this/)

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol.matchAll](str)

Parameters

str
- : A [ The **Symbol/matchAll** method of {{jsxref("RegExp")}} instances specifies how [String/matchAll`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) should behave/

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/matchAll”, “taller”)}}

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    if (!result) {
      return null;
    }
    return Array/from(result);
  }
}

const re = new MyRegExp("-\\d+", "g");
console/log("2016-01-02|2019-03-07"/matchAll(re));
// Expected output: Array [Array ["-01"], Array ["-02"], Array ["-03"], Array ["-07"]]

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Description

This method exists for customizing the behavior of matchAll() in [ The **Symbol/matchAll** method of {{jsxref("RegExp")}} instances specifies how [String/matchAll`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) should behave/

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/matchAll”, “taller”)}}

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    if (!result) {
      return null;
    }
    return Array/from(result);
  }
}

const re = new MyRegExp("-\\d+", "g");
console/log("2016-01-02|2019-03-07"/matchAll(re));
// Expected output: Array [Array ["-01"], Array ["-02"], Array ["-03"], Array ["-07"]]

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Examples

Direct call

This method can be used in almost the same way as [ The **Symbol/matchAll** method of {{jsxref("RegExp")}} instances specifies how [String/matchAll`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) should behave/

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/matchAll”, “taller”)}}

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    if (!result) {
      return null;
    }
    return Array/from(result);
  }
}

const re = new MyRegExp("-\\d+", "g");
console/log("2016-01-02|2019-03-07"/matchAll(re));
// Expected output: Array [Array ["-01"], Array ["-02"], Array ["-03"], Array ["-07"]]

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Specifications

Browser compatibility

Syntax

regexp[Symbol/matchAll](str)

Parameters

str
- : A {{jsxref(“String”)}} that is a target of the match/

Return value

An iterable iterator object (which is not restartable) of matches/ Each match is an array with the same shape as the return value of {{jsxref(“RegExp/prototype/exec()”)}}/

Description

"abc"/matchAll(/a/g);

/a/g[Symbol/matchAll]("abc");

const regexp = /[a-c]/g;
regexp/lastIndex = 1;
const str = "abc";
Array/from(str/matchAll(regexp), (m) => `${regexp/lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]

console/log(Array/from("😄"/matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console/log(Array/from("😄"/matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]

When the regex is sticky and global, it will still perform sticky matches — i/e/, it will not match any occurrences beyond the lastIndex/

console/log(Array/from("ab-c"/matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]

Examples

Direct call

This method can be used in almost the same way as {{jsxref(“String/prototype/matchAll()”)}}, except for the different value of this and the different order of arguments/

const re = /\d+/g;
const str = "2016-01-02";
const result = re[Symbol/matchAll](str);

console/log(Array/from(result, (x) => x[0]));
// [ "2016", "01", "02" ]

Using [Symbol/matchAll]() in subclasses

Subclasses of {{jsxref(“RegExp”)}} can override the [Symbol/matchAll]() method to modify the default behavior/

For example, to return an {{jsxref(“Array”)}} instead of an iterator:

class MyRegExp extends RegExp {
  [Symbol/matchAll](str) {
    const result = RegExp/prototype[Symbol/matchAll]/call(this, str);
    return result ? Array/from(result) : null;
  }
}

const re = new MyRegExp("(\\d+)-(\\d+)-(\\d+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str/matchAll(re);

console/log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console/log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Syntax

Parameters

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Return value

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Description

Syntax

Parameters

Return value

Description

Examples

Direct call

Using [Symbol/matchAll]() in subclasses

Specifications

Browser compatibility

See also

Syntax

Parameters

Return value

Description

Examples

Direct call