recursal/MDN huggingface dataset:
Object() 构造函数
=============

**`Object()`** 构造函数将输入转换为一个对象。它的行为取决于输入的类型。

语法
--


```js
new Object(value)
Object(value)
```


**备注：** `Object()` 可以在带有或者不带有 `new` 的情况下调用，但有时会产生不同的效果。参见返回值。

### 参数

`value`

任意值。

### 返回值

当调用或者构造 `Object()` 构造函数本身时，其返回值是一个对象：

* 如果该值是 `null` 或者 `undefined`，它会生成并返回一个空对象。
* 如果该值已经是一个对象，则返回该值。
* 否则，它将返回与给定值对应的类型的对象。例如，传递 `BigInt` 基本类型会返回一个 `BigInt` 封装对象。

当通过继承 `Object` 的类的构造函数中的 `super()` 隐式调用 `Object()` 时，它以 `new.target.prototype` 为原型初始化一个新对象。传递给 `super()` 的任意值都将被忽略——例如，即使你传递一个数字，构造函数中的 `this` 值也不会变成 `Number` 实例。

示例
--

### 创建一个新对象


```js
const o = new Object();
o.foo = 42;

console.log(o);
// { foo: 42 }
```

### 使用 undefined 和 null 类型调用 Object

以下示例在 `o` 中存储一个空 `Object` 对象：


```js
const o = new Object();
```



```js
const o = new Object(undefined);
```



```js
const o = new Object(null);
```

### 获取 BigInt 和 Symbol 的封装对象

当用 `new` 调用 `BigInt()` 和 `Symbol()` 构造函数时会抛出一个错误，以阻止创建封装对象而不是基本类型值的常见错误。为这些类型创建封装对象的唯一方法是使用它们调用 `Object()`：


```js
const numberObj = new Number(1);
console.log(typeof numberObj); // "object"

const bigintObj = Object(1n);
console.log(typeof bigintObj); // "object"

const symbolObj = Object(Symbol("foo"));
console.log(typeof symbolObj); // "object"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object-constructor |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* 对象初始化
Object.getOwnPropertyDescriptors()
==================================

**`Object.getOwnPropertyDescriptors()`** 静态方法返回给定对象的所有自有属性描述符。

尝试一下
----

语法
--


```js
Object.getOwnPropertyDescriptors(obj)
```

### 参数

`obj`

要获取其所有自有属性描述符的对象。

### 返回值

一个包含给定对象的所有自有属性描述符的对象。如果没有属性，则可能是一个空对象。

描述
--

该方法允许查看对象的所有自有属性的精确描述。在 JavaScript 中，一个*属性*由一个字符串值的名称或一个 `Symbol` 和一个属性描述符组成。关于属性描述符类型及其特性的更多信息可以在 `Object.defineProperty()` 中找到。

一个*属性描述符*是一个记录，具有以下一些特性：

`value`

与属性关联的值（仅限数据描述符）。

`writable`

当且仅当与属性关联的值可以更改时，为 `true`（仅限数据描述符）。

`get`

作为属性 getter 的函数，如果没有 getter 则为 `undefined`（仅限访问器描述符）。

`set`

作为属性 setter 的函数，如果没有 setter 则为 `undefined`（仅限访问器描述符）。

`configurable`

当且仅当此属性描述符的类型可以更改且该属性可以从相应对象中删除时，为 `true`。

`enumerable`

当且仅当此属性在相应对象的属性枚举中出现时，为 `true`。

示例
--

### 浅拷贝一个对象

而 `Object.assign()` 方法仅将可枚举的自有属性从源对象复制到目标对象，你可以使用此方法和 `Object.create()` 方法对两个未知对象进行浅拷贝：


```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### 创建子类

创建子类的典型方法是定义子类，将其原型设置为超类的实例，然后在该实例上定义属性。这么写很不优雅，特别是对于 getter 和 setter 而言。相反，你可以使用此代码设置原型：


```js
function superclass() {}
superclass.prototype = {
  // 在这里定义超类的构造方法、方法和属性
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // 在这里定义子类的构造方法、方法和属性
});
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertydescriptors |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Object.getOwnPropertyDescriptors` 的 polyfill
* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill
Object.isExtensible()
=====================

**`Object.isExtensible()`** 静态方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

尝试一下
----

语法
--


```js
Object.isExtensible(obj)
```

### 参数

`obj`

要检查的对象。

### 返回值

指示给定对象是否可扩展的一个布尔值。

描述
--

默认情况下，对象是可扩展的：可以向它们添加新属性，并且它们的 `[[Prototype]]` 可以被重新赋值。可以使用 `Object.preventExtensions()`、`Object.seal()`、`Object.freeze()` 或 `Reflect.preventExtensions()` 中的任一方法将对象标记为不可扩展。

示例
--

### 使用 Object.isExtensible


```js
// 新对象是可拓展的。
const empty = {};
Object.isExtensible(empty); // true

// 它们可以变为不可拓展的
Object.preventExtensions(empty);
Object.isExtensible(empty); // false

// 根据定义，密封对象是不可拓展的。
const sealed = Object.seal({});
Object.isExtensible(sealed); // false

// 根据定义，冻结对象同样也是不可拓展的。
const frozen = Object.freeze({});
Object.isExtensible(frozen); // false
```

### 非对象参数

在 ES5 中，如果参数不是一个对象（即基本类型），将抛出 `TypeError`。在 ES2015 中，如果传入的参数不是一个对象，那么它将返回 `false` 而不会报错，因为按照定义，原始类型是不可变的。


```js
Object.isExtensible(1);
// TypeError: 1 is not an object (ES5 code)

Object.isExtensible(1);
// false (ES2015 code)
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isextensible |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Object.preventExtensions()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.isExtensible()`
RegExp.prototype.multiline
==========================

概述
--

**`multiline`** 属性表明正则表达式是否使用了 "`m`" 标志。`multiline` 是正则表达式实例的一个只读属性。

| `RegExp.prototype.multiline` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

`multiline` 是一个布尔对象，如果使用了 "`m`" 标志，则返回 `true`；否则，返回 `false`。"`m`" 标志意味着一个多行输入字符串被看作多行。例如，使用 "`m`"，"`^`" 和 "`$`" 将会从只匹配正则字符串的开头或结尾，变为匹配字符串中任一行的开头或结尾。

你无法直接更改此属性。

示例
--

### 示例：使用 `multiline`


```js
var regex = new RegExp("foo", "m");

console.log(regex.multiline); // true
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.multiline |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.prototype.global`
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.prototype.sticky
=======================

**`sticky`** 属性反映了搜索是否具有粘性（仅从正则表达式的 `lastIndex` 属性表示的索引处搜索）。`sticky` 是正则表达式对象的只读属性。

尝试一下
----

| `RegExp.prototype.sticky` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 是 |

描述
--

`sticky` 的值是 `Boolean` ，并在 `y` 标志使用时为真; 否则为假。`y` 标志指示，仅从正则表达式的 `lastIndex` 属性表示的索引处为目标字符串匹配（并且不会尝试从后续索引匹配）。如果一个表达式同时指定了 `sticky` 和 `global`，其将会忽略 `global` 标志。

你不能直接更改这个属性，它是只读的。

示例
--

### 使用带 sticky 标志的正则表达式


```js
var str = "#foo#";
var regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true（译注：此例仅当 lastIndex = 1 时匹配成功，这就是 sticky 的作用）
regex.lastIndex = 5;
regex.test(str); // false（lastIndex 被 sticky 标志考虑到，从而导致匹配失败）
regex.lastIndex; // 0（匹配失败后重置）
```

### 锚定的 sticky 标志

火狐的 SpiderMonkey 引擎的几个版本有一个 bug，处理 `^` 断言和 sticky 标志时，会允许使用了 sticky 标志的表达式从 `^` 断言开始匹配，这是不对的。这个 bug 是在 Firefox 3.6 之后的某个版本引入的（which had the sticky flag but not the bug）并于 2015 年修复。可能正因为这个 bug，ES2015 规范 特别指出：

> 
> 当使用带有 `y` 标识的匹配模式时，^ 断言总是会匹配输入的开始位置或者（如果是多行模式）每一行的开始位置。
> 
> 
> 

正确行为的示例：


```js
var regex = /^foo/y;
regex.lastIndex = 2;
regex.test("..foo"); // false - 索引 2 不是字符串的开始

var regex2 = /^foo/my;
regex2.lastIndex = 2;
regex2.test("..foo"); // false - 索引 2 不是字符串或行的开始
regex2.lastIndex = 2;
regex2.test(".\nfoo"); // true - 索引 2 是行的开始
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.sticky |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
RegExp.prototype.source
=======================

概述
--

**`source`** 属性返回一个值为当前正则表达式对象的模式文本的字符串，该字符串不会包含正则字面量两边的斜杠以及任何的标志字符。

示例
--


```js
var regex = /fooBar/gi;

console.log(regex.source); // "fooBar"，不包含 /.../ 和 "ig"。
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.source |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.prototype.flags`
RegExp.prototype.flags
======================

`RegExp` 实例的 **`flags`** 访问器属性返回当前正则表达式的标志。

尝试一下
----

描述
--

`RegExp.prototype.flags` 具有一个字符串值。`flags` 属性中的标志按字母顺序排列（从左到右，例如 `"dgimsuvy"`）。它实际上调用了其他标志访问器（如 `hasIndices`、`global` 等）并逐个连接这些结果。

所有内置函数都是读取 `flags` 属性，而不是读取单独的标志访问器。

`flags` 的 set 访问器是 `undefined`。因此你不能直接修改该属性。

示例
--

### 使用 flags


```js
/foo/gi.flags; // "gi"
/bar/muy.flags; // "muy"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.flags |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `RegExp.prototype.flags` 的 polyfill
* `RegExp.prototype.source`
RegExp.lastMatch ($&)
=====================

**非标准:** 该特性是非标准的，请尽量不要在生产环境中使用它！

**lastMatch** 非标准属性是正则表达式的静态和只读属性，含有最后匹配到的字符串。`RegExp.$&` 是这个属性的别名。

语法
--
```

RegExp.lastMatch
RegExp['$&']
```

描述
--

`lastMatch` 属性是静态的，不是正则表达式独立对象的属性。反之，你应始终将其使用为 `RegExp.lastMatch` 或者 `RegExp['$&']`。

`lastMatch` 属性的值是只读的，并且会在匹配成功时修改。

你不能使用属性访问器 (`RegExp.$&`) 来使用简写的别名，因为解析器在这里会将 "&" 看做表达式，并抛出 `SyntaxError` 。使用 方括号符号来访问属性。

示例
--

### 使用 `lastMatch` 和 `$&`


```js
var re = /hi/g;
re.test("hi there!");
RegExp.lastMatch; // "hi"
RegExp["$&"]; // "hi"
```

规范
--

非标准。并不是任何现行规范的一部分。

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* 非标准
 `RegExp.input ($_)`
* 非标准
 `RegExp.lastParen ($+)`
* 非标准
 `RegExp.leftContext ($`)`
* 非标准
 `RegExp.rightContext ($')`
* 非标准
 `RegExp.$1-$9`
RegExp.prototype[@@search]()
============================

**`[@@search]()`** 方法执行了一个在给定字符串中的一个搜索以取得匹配正则模式的项。

语法
--
```

regexp[Symbol.search](str)
```

### 参数

`str`

搜索的目标 `String`。

### 返回值

整数

如果成功的话，`[@@search]()` 返回该正则模式的第一个匹配项的在字符串中的位置索引。否则将返回 -1。

描述
--

这个方法在 `String.prototype.search()` 的内部调用。例如，下面的两个方法返回相同结果。


```js
"abc".search(/a/);

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


这个方法为自定义 `RegExp` 子类中的匹配行为而存在。

示例
--

### 直接调用

这个方法的使用方式和 `String.prototype.search()` 相同，不同之处是 `this` 和参数顺序。


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

### 在子类中使用`@@search`

{jsxref("RegExp")}} 的子类可以覆写 `[@@search]()`方法来修改默认行为。


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

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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@search |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* `String.prototype.search()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
RegExp.prototype.toString()
===========================

概述
--

**`toString()`** 返回一个表示该正则表达式的字符串。

语法
--
```

regexObj.toString()
```

### 参数

无

描述
--

`RegExp` 对象覆盖了 `Object` 对象的 `toString()` 方法，并没有继承 `Object.prototype.toString()`。对于 `RegExp` 对象，`toString` 方法返回一个该正则表达式的字符串形式。

示例
--

### 示例：使用 `toString`

下例输出 `RegExp` 对象的字符串值：
```

myExp = new RegExp("a+b+c");
alert(myExp.toString());       // 显示 "/a+b+c/"

foo = new RegExp("bar", "g");
alert(foo.toString());         // 显示 "/bar/g"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.tostring |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Object.prototype.toString()`
RegExp.prototype[@@match]()
===========================

对*正则表达式*匹配*字符串*时，\*\*`[@@match]()`\*\*方法用于获取匹配结果。

尝试一下
----

语法
--
```

regexp[Symbol.match](str)
```

### 参数

`str`

match 的目标参数是`String`

### 返回值

match 方法会返回一个数组，它包括整个匹配结果，和通过捕获组匹配到的结果，如果没有匹配到则返回 null

描述
--

这个方法在 `String.prototype.match()` 的内部调用。例如，下面的两个方法返回相同结果。


```js
"abc".match(/a/);

/a/[Symbol.match]("abc");
```


这个方法为自定义 `RegExp` 子类中的匹配行为而存在。

示例
--

### 直接调用

这个方法的使用方式和 `String.prototype.match()` 相同，不同之处是 `this` 和参数顺序。


```js
var re = /[0-9]+/g;
var str = "2016-01-02";
var result = re[Symbol.match](str);
console.log(result); // ["2016", "01", "02"]
```

### 在子类中使用`@@match`

`RegExp` 的子类可以覆写 `[@@match]()`方法来修改默认行为。


```js
class MyRegExp extends RegExp {
  [Symbol.match](str) {
    var result = RegExp.prototype[Symbol.match].call(this, str);
    if (!result) return null;
    return {
      group(n) {
        return result[n];
      },
    };
  }
}

var re = new MyRegExp("([0-9]+)-([0-9]+)-([0-9]+)");
var str = "2016-01-02";
var result = str.match(re); // String.prototype.match calls re[@@match].
console.log(result.group(1)); // 2016
console.log(result.group(2)); // 01
console.log(result.group(3)); // 02
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@match |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* `String.prototype.match()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
RegExp.prototype.global
=======================

概述
--

**`global`** 属性表明正则表达式是否使用了 "`g`" 标志。`global` 是一个正则表达式实例的只读属性。

| `RegExp.prototype.global` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

`global` 的值是布尔对象，如果使用了 "`g`" 标志，则返回 `true`；否则返回 `false`。 "`g`" 标志意味着正则表达式应该测试字符串中所有可能的匹配。

你无法直接更改此属性。

示例
--

### 示例：使用 `global`


```js
var regex = new RegExp("foo", "g");

console.log(regex.global); // true
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.global |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.prototype.lastIndex`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.hasIndices`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.$1-$9
============

**非标准:** 该特性是非标准的，请尽量不要在生产环境中使用它！

非标准 **$1, $2, $3, $4, $5, $6, $7, $8, $9** 属性是包含括号子串匹配的正则表达式的静态和只读属性。

语法
--
```

RegExp.$1
RegExp.$2
RegExp.$3
RegExp.$4
RegExp.$5
RegExp.$6
RegExp.$7
RegExp.$8
RegExp.$9
```

描述
--

$1, ..., $9 属性是静态的，他不是独立的正则表达式属性。所以，我们总是像这样子使用他们`RegExp.$1`, ..., `RegExp.$9`.

属性的值是只读的而且只有在正确匹配的情况下才会改变。

括号匹配项是无限的，但是 RegExp 对象能捕获的只有九个。你可以通过返回一个数组索引来取得所有的括号匹配项。

这些属性可以在`String.replace` 方法中替换字符串。在这种情况下，不用在前面加上 RegExp。下面的例子将详细说明。当正则表达式中不包含括号，脚本中的 `$n`'s 就是字面上的意思 (当 n 是正整数).

示例
--

### `$n` 在 `String.replace 中的应用`

以下脚本用 `replace()` 方法去匹配一个 first last 格式的 name`String` 实例 输出 last first 格式。在替换文本里，脚本用 `$1` 和 `$2` 表示正则表达式中的括号匹配项的结果。


```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
str.replace(re, "$2, $1"); // "Smith, John"
RegExp.$1; // "John"
RegExp.$2; // "Smith"
```

技术指标
----

非标准。不属于当前的任何规范。

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* 非标准
 `RegExp.input ($_)`
* 非标准
 `RegExp.lastMatch ($&)`
* 非标准
 `RegExp.lastParen ($+)`
* 非标准
 `RegExp.leftContext ($`)`
* 非标准
 `RegExp.rightContext ($')`
RegExp.prototype.unicode
========================

**`unicode`** 属性表明正则表达式带有"`u`" 标志。 `unicode` 是正则表达式独立实例的只读属性。

| `RegExp.prototype.unicode` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 是 |

描述
--

`unicode` 的值是 `Boolean`，并且如果使用了 "`u`" 标志则为 `true`；否则为 `false`。"`u`" 标志开启了多种 Unicode 相关的特性。使用 "u" 标志，任何 Unicode 代码点的转义都会被解释。

你不能直接修改这个属性，它是只读的。

示例
--

### 使用 `unicode` 属性


```js
var regex = new RegExp("\u{61}", "u");

console.log(regex.unicode); // true
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.unicode |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* `RegExp.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.lastIndex
================

概述
--

**`lastIndex`** 是正则表达式的一个可读可写的整型属性，用来指定下一次匹配的起始索引。

| `RegExp.lastIndex` 的属性特性 |
| --- |
| 可写 | 是 |
| 可枚举 | 否 |
| 可配置 | 否 |

语法
--


```js
lastIndex = regExpObj.lastIndex;
```

描述
--

只有正则表达式使用了表示全局检索的 "`g`" 或者粘性检索的 "`y`" 标志时，该属性才会起作用。此时应用下面的规则：

* 如果 `lastIndex` 大于字符串的长度，则 `regexp.test` 和 `regexp.exec` 将会匹配失败，然后 `lastIndex` 被设置为 0。
* 如果 `lastIndex` 等于或小于字符串的长度，则该正则表达式匹配从 `lastIndex` 位置开始的字符串。
    + 如果 `regexp.test` 和 `regexp.exec` 匹配成功，`lastIndex` 会被设置为紧随最近一次成功匹配的下一个位置。
    + 如果 `regexp.test` 和 `regexp.exec` 匹配失败，`lastIndex` 会被设置为 0
示例
--

考虑下面的语句：


```js
var re = /(hi)?/g;
```


匹配空字符串


```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```


返回 `["hi", "hi"]` ，`lastIndex` 等于 2。


```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```


返回 `["", undefined]`，即一个数组，其第 0 个元素为匹配的字符串。此种情况下为空字符串，是因为 `lastIndex` 为 2（且一直是 2），"`hi`" 长度为 2。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-regexp-instances |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.global`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.prototype.dotAll
=======================

**`dotAll`** 属性表明是否在正则表达式中一起使用"`s`"修饰符（引入/s 修饰符，使得。可以匹配任意单个字符）。`dotAll` 是一个只读的属性，属于单个正则表达式实例。

| `RegExp.prototype.dotAll` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 是 |

描述
--

如果使用了"`s`"修饰符，`dotAll` 的值将返回`Boolean`类型的`true`，否则将返回`false`。"`s`"修饰符表示，特殊字符"`.`"应另外匹配字符串中的下述行终结符（line terminator characters），否则将会失配：

* U+000A 换行符（"`\n`"）
* U+000D 回车符（"`\r`"）
* U+2028 行分隔符（line separator）
* U+2029 段分隔符（paragraph separator）

这实际上意味着"`.`"将会匹配任意的单个 Unicode Basic Multilingual Plane (BMP) 字符。若要使其与 astral 字符（大于 \uFFFF 的 Unicode 字符）匹配，你应当使用"`u`"（Unicode）修饰符。一起使用这两个修饰符，"`.`"将无一例外地匹配任意 Unicode 字符。

无法直接修改此属性。

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `RegExp.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.rightContext ($')
========================

**非标准:** 该特性是非标准的，请尽量不要在生产环境中使用它！

**rightContext** 非标准属性是正则表达式的静态和只读属性，含有最新匹配的右侧子串。 `RegExp.$'` 是这个属性的别名。

语法
--
```

RegExp.rightContext
RegExp["$'"]
```

描述
--

`rightContext` 属性是静态的，不是正则表达式独立对象的属性。反之，你应始终将其使用为 `RegExp.rightContext` 或者 `RegExp["$'"]`。

`rightContext` 属性的值是只读的，并且会在匹配成功时修改。

你不能使用属性访问器 (`RegExp.$'`) 来使用简写的别名，因为解析器在这里会将其看做字符串的开始，并抛出 `SyntaxError`。使用 方括号符号来访问属性。

示例
--

### 使用 `rightContext` 和 `$'`


```js
var re = /hello/g;
re.test("hello world!");
RegExp.rightContext; // " world!"
RegExp["$'"]; // " world!"
```

规范
--

非标准。并不是任何现行规范的一部分。

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* 非标准
 `RegExp.input ($_)`
* 非标准
 `RegExp.lastMatch ($&)`
* 非标准
 `RegExp.lastParen ($+)`
* 非标准
 `RegExp.leftContext ($`)`
* 非标准
 `RegExp.$1-$9`
get RegExp[@@species]
=====================

**`RegExp[@@species]`** 访问器属性返回`RegExp` 的构造器。

语法
--
```

RegExp[Symbol.species]
```

描述
--

`species` 访问器属性返回 `RegExp` 对象的默认构造器。子类构造器可能会覆盖它，来修改构造器的指派。

示例
--

`species`属性返回默认构造器函数，它是用于`RegExp` 对象的`RegExp`构造器：


```js
RegExp[Symbol.species]; // 函数 RegExp()
```


在派生的正则类（也就是你自定义的正则类 `MyRegExp`）中，`MyRegExp` 的 species 是 `MyRegExp` 构造器。但是，你可能希望覆盖它，以便在你的派生类方法中，返回 `RegExp` 父类对象：


```js
class MyRegExp extends RegExp {
  // 将 MyRegExp species 覆盖为 RegExp 父类构造器
  static get [Symbol.species]() {
    return RegExp;
  }
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp-@@species |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* `RegExp`
* `Symbol.species`
RegExp() constructor
====================

**`RegExp`** 用于创建正则表达式对象，该对象用于将文本与一个模式匹配

阅读JavaScript 指南中的正则表达式一节以了解正则表达式。

尝试一下
----

语法
--

可以使用字面量、构造函数和工厂方法来创建正则表达式
```

/pattern/flags
new RegExp(pattern[, flags])
RegExp(pattern[, flags])
```

### 参数

`pattern`

正则表达式的文本。从 ES5 开始，这也可以是另一个 `RegExp` 对象或文字（仅用于两个 RegExp 构造函数符号）。模式可以包含特殊字符来匹配比字面值字符串更广泛的值范围。

`flags`

如果指定，`flags` 是包含要添加的标志的字符串。

或者，如果为模式提供了一个对象，flags 字符串将替换该对象的任何标志 (并且`lastIndex`将重置为 0)(从 ES2015 开始)。

如果没有指定`flags`并且提供了一个正则表达式对象，则该对象的 flags(和 lastIndex 值) 将被复制。

`flags` 可包含下列任何字符的组合：

`g` （全局匹配）

找到所有的匹配，而不是在第一个匹配之后停止。

`i` （忽略大小写）

如果`u`标志也被启用，使用 Unicode 大小写折叠。

`m` （多行匹配）

将开始和结束字符 (`^` and `$`) 视为在多行上工作。换句话说，匹配每一行的开头或结尾*each* line (由`\n`或者`\r` 分隔)，而不仅仅是整个输入字符串的开头或结尾。

`s` （点号匹配所有字符）

允许`.` 去匹配新的行

`u` （unicode）

Treat `pattern` as a sequence of Unicode code points. (See also Binary strings).

`y` （sticky，粘性匹配）

Matches only from the index indicated by the `lastIndex` property of this regular expression in the target string. Does not attempt to match from any later indexes.


示例
--

### 字面量和构造函数

这里有两种方法创建`RegExp` 对象：*字面量* 和 *构造函数*.

* **文字符号的** 参数用斜杠括起来，不使用引号。
* **构造函数的** 参数不包含在斜杠之间，但使用引号。

以下三个表达式创建相同的正则表达式：


```js
/ab+c/i;
new RegExp(/ab+c/, "i"); // 字面量
new RegExp("ab+c", "i"); // 构造函数
```


当表达式被求值时，文字表示法会导致对正则表达式的编译。当正则表达式保持不变时，请使用字面量表示法。例如，如果使用字面量表示法来构造循环中使用的正则表达式，则不会在每次迭代时重新编译正则表达式。

正则表达式对象的构造函数—例如，new RegExp('ab+c')—会导致正则表达式的运行时编译。当你知道正则表达式模式将发生变化时，或者你不知道该模式，但正在从其他来源 (如用户输入) 获取它时，请使用构造函数。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-constructor |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* JavaScript 指南中的
* 正则表达式一节
* `String.prototype.match()`
* `String.prototype.replace()`
RegExp.prototype[@@replace]()
=============================

**`[@@replace]()`** 方法会在一个字符串中用给定的替换器，替换所有符合正则模式的匹配项，并返回替换后的新字符串结果。用来替换的参数可以是一个字符串或是一个针对每次匹配的回调函数。

尝试一下
----

语法
--
```

regexp[Symbol.replace](str, newSubStr|function)
```

### 参数

`str`

正则替换的目标字符串。

`newSubStr (replacement)`

类型为 `String` 的替换器。支持大多数特殊的替换匹配模式；见`String.prototype.replace()`页的Specifying a string as a parameter部分。

`function (replacement)`

生成新的子字符串的回调函数替换器。作用于该函数的参数的详细描述见`String.prototype.replace()`页的 Specifying a function as a parameter 部分。

### 返回值

用替换器替换相应匹配项后的新字符串。

描述
--

如果匹配模式也是`RegExp`对象，这个方法在 `String.prototype.replace()` 的内部调用。例如，下面的两个方法返回相同结果。


```js
"abc".replace(/a/, "A");

/a/[Symbol.replace]("abc", "A");
```


该方法是为了在 RegExp 子类中自定义匹配的替换模式。

如果匹配模式不是一个`RegExp` 对象，`String.prototype.replace()` 就不会调用该方法，也不会创建一个 `RegExp`对象。

示例
--

### 直接调用

这个方法基本可以和 `String.prototype.replace()` 一样使用，不同之处是 `this` 和参数顺序。


```js
var re = /-/g;
var str = "2016-01-01";
var newstr = re[Symbol.replace](str, ".");
console.log(newstr); // 2016.01.01
```

### 在子类中使用 @@replace

`RegExp` 的子类可以覆写 `[@@replace]()`方法来修改默认行为。


```js
class MyRegExp extends RegExp {
  constructor(pattern, flags, count) {
    super(pattern, flags);
    this.count = count;
  }
  [Symbol.replace](str, replacement) {
    // Perform @@replace |count| times.
    var result = str;
    for (var i = 0; i < this.count; i++) {
      result = RegExp.prototype[Symbol.replace].call(this, result, replacement);
    }
    return result;
  }
}

var re = new MyRegExp("\\d", "", 3);
var str = "01234567";
var newstr = str.replace(re, "#"); // String.prototype.replace calls re[@@replace].
console.log(newstr); // ###34567
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@replace |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

另见
--

* `String.prototype.replace()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`