↑ arvau

MDN / RegExp.prototypeSymbol.search

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this.pattern = str;
  }
  [Symbol.search](str) {
    return str.indexOf(this.pattern);
  }
}

console.log("table football".search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol.search](str)

Parameters

  • str

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found.

Description

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

"abc".search(/a/);

/a/[Symbol.search]("abc");

[Symbol.search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null. The g flag has no effect with this method.

This method does not copy the regular expression, unlike [Symbol.split]() or [Symbol.matchAll](). However, unlike [Symbol.match]() or [Symbol.replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects. This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string.

const re = /[abc]/g;
re.lastIndex = 2;
console.log("abc".search(re)); // 0

const re2 = /[bc]/y;
re2.lastIndex = 1;
console.log("abc".search(re2)); // -1
console.log("abc".match(re2)); // [ 'b' ]

Examples

Direct call

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol.search](str);
console.log(result); // 4

Using [Symbol.search]() in subclasses

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this.pattern = str;
  }
  [Symbol.search](str) {
    return str.indexOf(this.pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str.search(re); // String.prototype.search calls re[Symbol.search]().
console.log(result); // 3

Specifications

Browser compatibility

See also

  • Polyfill of RegExp.prototype[Symbol.search] in core-js

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

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: RegExp/prototypeSymbol/search”)}}

class RegExp1 extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

console/log("table football"/search(new RegExp1("foo")));
// Expected output: 6

Syntax

regexp[Symbol/search](str)

Parameters

  • str

    • : A {{jsxref(“String”)}} that is a target of the search/

Return value

The index of the first match between the regular expression and the given string, or -1 if no match was found/

Description

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

"abc"/search(/a/);

/a/[Symbol/search]("abc");

[Symbol/search]() always calls the regex’s exec() method exactly once, and returns the index property of the result, or -1 if the result is null/ The g flag has no effect with this method/

This method does not copy the regular expression, unlike [Symbol/split]() or [Symbol/matchAll]()/ However, unlike [Symbol/match]() or [Symbol/replace](), it will always set lastIndex to 0 when execution starts and restore it to the previous value when it exits, therefore generally avoiding side effects/ This means that it always returns the first match in the string even when lastIndex is non-zero, and sticky regexes always search strictly at the beginning of the string/

const re = /[abc]/g;
re/lastIndex = 2;
console/log("abc"/search(re)); // 0

const re2 = /[bc]/y;
re2/lastIndex = 1;
console/log("abc"/search(re2)); // -1
console/log("abc"/match(re2)); // [ 'b' ]

Examples

Direct call

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

const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol/search](str);
console/log(result); // 4

Using [Symbol/search]() in subclasses

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

class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this/pattern = str;
  }
  [Symbol/search](str) {
    return str/indexOf(this/pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str/search(re); // String/prototype/search calls re[Symbol/search]()/
console/log(result); // 3

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also