recursal/MDN huggingface dataset:
Array.prototype.some()
======================

**`some()`** 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。

尝试一下
----

语法
--


```js
some(callbackFn)
some(callbackFn, thisArg)
```

### 参数

`callbackFn`

为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数：

`element`

数组中当前正在处理的元素。

`index`

正在处理的元素在数组中的索引。

`array`

调用了 `some()` 的数组本身。


`thisArg` 可选

执行 `callbackFn` 时用作 `this` 的值。参见迭代方法。

### 返回值

如果回调函数对数组中至少一个元素返回一个真值，则返回 `true`。否则返回 `false`。

描述
--

`some()` 方法是一个迭代方法。它为数组中的每个元素调用一次指定的 `callbackFn` 函数，直到 `callbackFn` 返回一个真值。如果找到这样的元素，`some()` 方法将会立即返回 `true` 并停止遍历数组。否则，如果 `callbackFn` 对所有元素都返回假值，`some()` 就会返回 `false`。

`some()` 类似于数学中的“存在量词（∃）”。特别地，在对于一个空数组，任何条件下它都返回 `false`。

`callbackFn` 仅针对已分配值的数组索引调用。它不会为稀疏数组中的空槽调用。

`some()` 不会改变调用它的数组，但指定的 `callbackFn` 函数可以。但是请注意，数组的长度是在第一次调用 `callbackFn` *之前*保存的。因此：

* 当开始调用 `some()` 时，`callbackFn` 将不会访问超出数组初始长度的任何元素。
* 对已访问索引的更改不会导致再次在这些元素上调用 `callbackFn`。
* 如果数组中一个现有的、尚未访问的元素被 `callbackFn` 更改，则它传递给 `callbackFn` 的值将是该元素被修改后的值。被删除的元素则不会被访问。

**警告：** 上述类型的并发修改经常导致难以理解的代码，通常应避免（特殊情况除外）。

`some()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 测试数组元素的值

下面的例子检测在数组中是否有元素大于 10。


```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
```

### 使用箭头函数测试数组元素的值

箭头函数可以通过更简洁的语法实现相同的用例。


```js
[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true
```

### 判断数组元素中是否存在某个值

此例为模仿 `includes()` 方法，若元素在数组中存在，则回调函数返回值为 `true` :


```js
const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
```

### 将任意值转换为布尔类型


```js
const TRUTHY\_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY\_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
```

### 在稀疏数组上使用 some()

`some()` 不会在空槽上运行它的断言函数。


```js
console.log([1, , 3].some((x) => x === undefined)); // false
console.log([1, , 1].some((x) => x !== 1)); // false
console.log([1, undefined, 1].some((x) => x !== 1)); // true
```

### 在非数组对象上调用 some()

`some()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引，直到到达末尾或 `callbackFn` 返回 `true`。


```js
const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
};
console.log(Array.prototype.some.call(arrayLike, (x) => typeof x === "number"));
// false
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.some |

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

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

参见
--

* `core-js` 中 `Array.prototype.every` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.every()`
* `Array.prototype.forEach()`
* `Array.prototype.find()`
* `Array.prototype.includes()`
* `TypedArray.prototype.some()`
Array.of()
==========

**`Array.of()`** 静态方法通过可变数量的参数创建一个新的 `Array` 实例，而不考虑参数的数量或类型。

尝试一下
----

语法
--


```js
Array.of()
Array.of(element0)
Array.of(element0, element1)
Array.of(element0, element1, /\* … ,\*/ elementN)
```

### 参数

`elementN`

用于创建数组的元素。

### 返回值

新的 `Array` 实例。

描述
--

`Array.of()` 和 `Array()` 构造函数之间的区别在于对单个参数的处理：`Array.of(7)` 创建一个具有单个元素 `7` 的数组，而 `Array(7)` 创建一个 `length` 为 `7` 的空数组（这意味着一个由 7 个空槽组成的数组，而不是由 7 个 `undefined` 组成的数组）。


```js
Array.of(7); // [7]
Array(7); // 由 7 个空槽组成的数组

Array.of(1, 2, 3); // [1, 2, 3]
Array(1, 2, 3); // [1, 2, 3]
```


`Array.of()` 方法是一个通用的工厂方法。例如，如果 `Array` 的子类继承了 `of()` 方法，继承的 `of()` 方法将返回子类的新实例而不是 `Array` 实例。事实上，`this` 值可以是任何接受单个参数表示新数组长度的构造函数，并且构造函数将与传递给 `of()` 的参数数量一起被调用。当所有元素都被分配时，最终的 `length` 将再次设置。如果 `this` 值不是构造函数，则改用普通的 `Array` 构造函数。

示例
--

### 使用 Array.of()


```js
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
```

### 非数组构造函数调用 of()

`of()` 方法可以在任何接受单个参数表示新数组长度的构造函数上调用。


```js
function NotArray(len) {
  console.log("NotArray called with length", len);
}

console.log(Array.of.call(NotArray, 1, 2, 3));
// NotArray called with length 3
// NotArray { '0': 1, '1': 2, '2': 3, length: 3 }

console.log(Array.of.call(Object)); // [Number: 0] { length: 0 }
```


当 `this` 值不是构造函数时，返回一个普通的 `Array` 对象。


```js
console.log(Array.of.call({}, 1)); // [ 1 ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.of |

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

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

参见
--

* `core-js` 中 `Array.prototype.map` 的 polyfill
* 索引集合类
* `Array`
* `Array()`
* `Array.from()`
* `TypedArray.of()`
Array.prototype.with()
======================

`Array` 实例的 **`with()`** 方法是使用方括号表示法修改指定索引值的复制方法版本。它会返回一个新数组，其指定索引处的值会被新值替换。

语法
--


```js
array.with(index, value)
```

### 参数

`index`

要修改的数组索引（从 0 开始），将会转换为整数。

* 负数索引会从数组末尾开始计数——即当 `index < 0` 时，会使用 `index + array.length`。
* 如果规范化后的索引超出数组边界，会抛出 `RangeError`。

`value`

要分配给指定索引的任何值。

### 返回值

一个全新的数组，其中 `index` 索引处的元素被替换为 `value`。

### 异常

`RangeError`

`index > array.length` 或 `index < -array.length` 时抛出。

描述
--

`with()` 通过返回一个指定索引处的值被新值替换的新数组，来改变数组中指定索引处的值。原数组不会被修改。这使得你可以以链式调用数组方法的方式来对数组进行操作。

`with()` 方法永远不会产生稀疏数组。如果原数组是稀疏的，新数组对应的空白索引位置会替换为 `undefined`。

`with()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 创建一个新的数组，改变其中一个元素


```js
const arr = [1, 2, 3, 4, 5];
console.log(arr.with(2, 6)); // [1, 2, 6, 4, 5]
console.log(arr); // [1, 2, 3, 4, 5]
```

### 数组方法的链式调用

使用 `with()` 方法，你可以在更新一个数组元素后继续调用其他的数组方法。


```js
const arr = [1, 2, 3, 4, 5];
console.log(arr.with(2, 6).map((x) => x \*\* 2)); // [1, 4, 36, 16, 25]
```

### 在稀疏数组上使用 with()

`with()` 方法总会创建一个密集数组。


```js
const arr = [1, , 3, 4, , 6];
console.log(arr.with(0, 2)); // [2, undefined, 3, 4, undefined, 6]
```

### 在非数组对象上调用 with()

`with()` 方法会读取 `this` 上的 `length` 属性，之后读取 `this` 上的每个整数键并写入到新数组中，同时 `value` 会被写入指定的 `index`。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.with.call(arrayLike, 0, 1));
// [ 1, undefined, 4 ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.with |

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

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

参见
--

* `core-js` 中 `Array.prototype.with` 的 polyfill
* `Array.prototype.toReversed()`
* `Array.prototype.toSorted()`
* `Array.prototype.toSpliced()`
* `TypedArray.prototype.with()` (en-US)
Array.prototype.toString()
==========================

**`toString()`** 方法返回一个字符串，表示指定的数组及其元素。

尝试一下
----

语法
--


```js
toString()
```

### 返回值

一个表示数组元素的字符串。

描述
--

`Array` 对象覆盖了 `Object` 的 `toString` 方法。数组的 `toString` 方法实际上在内部调用了 `join()` 方法来拼接数组并返回一个包含所有数组元素的字符串，元素之间用逗号分隔。如果 `join` 方法不可用或者不是函数，则会使用 `Object.prototype.toString` 来代替，并返回 `[object Array]`。


```js
const arr = [];
arr.join = 1; // 将 `join` 重新赋值为非函数的值
console.log(arr.toString()); // [object Array]

console.log(Array.prototype.toString.call({ join: () => 1 })); // 1
```


当数组需要被表示为文本值，或者当数组在字符串拼接中被引用时，JavaScript 会自动调用 `toString()` 方法。

示例
--

### 使用 toString()


```js
const array1 = [1, 2, "a", "1a"];

console.log(array1.toString()); // "1,2,a,1a"
```

### 在稀疏数组中使用 toString()

与 `join()` 的行为一致，`toString()` 将空槽视为 `undefined` 并生成一个额外的分隔符：


```js
console.log([1, , 3].toString()); // '1,,3'
```

### 在非数组对象中使用 toString()

`toString()` 是通用的。它期望 `this` 具有 `join()` 方法；如果不存在，则使用 `Object.prototype.toString()`。


```js
console.log(Array.prototype.toString.call({ join: () => 1 }));
// 1; 一个数字
console.log(Array.prototype.toString.call({ join: () => undefined }));
// undefined
console.log(Array.prototype.toString.call({ join: "not function" }));
// "[object Object]"
```

规范
--

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

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

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

参见
--

* 索引集合类
* `Array`
* `Array.prototype.join()`
* `Array.prototype.toLocaleString()`
* `TypedArray.prototype.toString()`
* `String.prototype.toString()`
Array.prototype.entries()
=========================

**`entries()`** 方法返回一个新的*数组迭代器*对象，该对象包含数组中每个索引的键/值对。

尝试一下
----

语法
--


```js
entries()
```

### 返回值

一个新的可迭代迭代器对象。

描述
--

当在稀疏数组上使用时，`entries()` 方法迭代空槽，就像它们的值为 `undefined` 一样。

`entries()` 方法是通用的。它只要求 `this` 值具有 `length` 属性和以整数为键的属性。

示例
--

### 迭代索引和元素


```js
const a = ["a", "b", "c"];

for (const [index, element] of a.entries()) {
  console.log(index, element);
}

// 0 'a'
// 1 'b'
// 2 'c'
```

### 使用 for...of 循环


```js
const array = ["a", "b", "c"];
const arrayEntries = array.entries();

for (const element of arrayEntries) {
  console.log(element);
}

// [0, 'a']
// [1, 'b']
// [2, 'c']
```

### 迭代稀疏数组

`entries()` 将访问空槽，就像它们是 `undefined` 一样。


```js
for (const element of [, "a"].entries()) {
  console.log(element);
}
// [0, undefined]
// [1, 'a']
```

### 在非数组对象上调用 entries()

`entries()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引。


```js
const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
};
for (const entry of Array.prototype.entries.call(arrayLike)) {
  console.log(entry);
}
// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.entries |

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

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

参见
--

* `core-js` 中 `Array.prototype.entries` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype.entries()`
* 迭代协议
Array.isArray()
===============

**`Array.isArray()`** 静态方法用于确定传递的值是否是一个数组。

尝试一下
----

语法
--


```js
Array.isArray(value)
```

### 参数

`value`

需要检测的值。

### 返回值

如果 `value` 是 `Array`，则为 `true`；否则为 `false`。如果 `value` 是 `TypedArray` 实例，则总是返回 `false`。

描述
--

`Array.isArray()` 检查传递的值是否为 `Array`。它不检查值的原型链，也不依赖于它所附加的 `Array` 构造函数。对于使用数组字面量语法或 `Array` 构造函数创建的任何值，它都会返回 `true`。这使得它可以安全地使用跨领域（cross-realm）对象，其中 `Array` 构造函数的标识是不同的，因此会导致 `instanceof Array` 失败。

有关更多细节，请参阅文章“确定 JavaScript 对象是否为数组”。

`Array.isArray()` 也拒绝原型链中带有 `Array.prototype`，而实际不是数组的对象，但 `instanceof Array` 会接受。

示例
--

### 使用 Array.isArray()


```js
// 下面的函数调用都返回 true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
Array.isArray(new Array("a", "b", "c", "d"));
Array.isArray(new Array(3));
// 鲜为人知的事实：其实 Array.prototype 也是一个数组：
Array.isArray(Array.prototype);

// 下面的函数调用都返回 false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray("Array");
Array.isArray(true);
Array.isArray(false);
Array.isArray(new Uint8Array(32));
// 这不是一个数组，因为它不是使用数组字面量语法或 Array 构造函数创建的
Array.isArray({ \_\_proto\_\_: Array.prototype });
```

### instanceof 和 Array.isArray()

当检测 `Array` 实例时，`Array.isArray` 优于 `instanceof`，因为 `Array.isArray` 能跨领域工作。


```js
const iframe = document.createElement("iframe");
document.body.appendChild(iframe);
const xArray = window.frames[window.frames.length - 1].Array;
const arr = new xArray(1, 2, 3); // [1, 2, 3]

// 正确检查 Array
Array.isArray(arr); // true
// arr 的原型是 xArray.prototype，它是一个不同于 Array.prototype 的对象
arr instanceof Array; // false
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.isarray |

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

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

参见
--

* `core-js` 中 `Array.isArray` 的 polyfill
* 索引集合类指南
* `Array`
Array.prototype.toSorted()
==========================

`Array` 实例的 **`toSorted()`** 方法是 `sort()` 方法的复制方法版本。它返回一个新数组，其元素按升序排列。

语法
--


```js
// 不传入函数
toSorted()

// 传入箭头函数
toSorted((a, b) => { /\* … \*/ })

// 传入比较函数
toSorted(compareFn)

// 內联比较函数
toSorted(function compareFn(a, b) { /\* … \*/ })
```

### 参数

`compareFn` 可选

指定一个定义排序顺序的函数。如果省略，则将数组元素转换为字符串，然后根据每个字符的 Unicode 码位值进行排序。

`a`

用于比较的第一个元素。

`b`

用于比较的第二个元素。


### 返回值

一个新数组，其元素按升序排序。

描述
--

有关 `compareFn` 参数的更多信息，请参阅 `sort()`。

当在稀疏数组上使用 `toSorted()` 方法时，它迭代时会将空槽视为具有 `undefined` 值的元素。

`toSorted()` 方法是通用的，它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 对数组进行排序


```js
const months = ["Mar", "Jan", "Feb", "Dec"];
const sortedMonths = months.toSorted();
console.log(sortedMonths); // ['Dec', 'Feb', 'Jan', 'Mar']
console.log(months); // ['Mar', 'Jan', 'Feb', 'Dec']

const values = [1, 10, 21, 2];
const sortedValues = values.toSorted((a, b) => a - b);
console.log(sortedValues); // [1, 2, 10, 21]
console.log(values); // [1, 10, 21, 2]
```


有关更多用法示例，请参见 `sort()`。

### 在稀疏数组上使用 toSorted()

空槽被视为具有 `undefined` 值而被排序。它们总是排序到数组的末尾，并且 `compareFn` 不会对它们进行调用。


```js
console.log(["a", "c", , "b"].toSorted()); // ['a', 'b', 'c', undefined]
console.log([, undefined, "a", "b"].toSorted()); // ["a", "b", undefined, undefined]
```

### 在非数组对象上调用 toSorted()

`toSorted()` 方法会读取 `this` 的 `length` 属性。然后它会收集所有在 `0` 到 `length - 1` 范围内的整数键属性，对它们进行排序并将它们写入一个新的数组中。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.toSorted.call(arrayLike));
// [4, 5, undefined]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tosorted |

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

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

参见
--

* `core-js` 中 `Array.prototype.with` 的 polyfill
* `Array.prototype.sort()`
* `Array.prototype.toReversed()`
* `Array.prototype.toSpliced()`
* `Array.prototype.with()`
* `TypedArray.prototype.toSorted()` (en-US)
Array.prototype.join()
======================

**`join()`** 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串，用逗号或指定的分隔符字符串分隔。如果数组只有一个元素，那么将返回该元素而不使用分隔符。

尝试一下
----

语法
--


```js
join()
join(separator)
```

### 参数

`separator` 可选

指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果省略，数组元素用逗号（`,`）分隔。如果 `separator` 是空字符串（`""`），则所有元素之间都没有任何字符。

### 返回值

一个所有数组元素连接的字符串。如果 `arr.length` 为 `0`，则返回空字符串。

描述
--

所有数组元素被转换成字符串并连接到一个字符串中。如果一个元素是 `undefined` 或 `null`，它将被转换为空字符串，而不是字符串 `"undefined"` 或 `"null"`。

`Array.prototype.toString()` 会在内部访问 `join` 方法，不带参数。覆盖一个数组实例的 `join` 也将覆盖它的 `toString` 行为。

当在稀疏数组上使用时，`join()` 方法迭代空槽，就像它们的值为 `undefined` 一样。

`join()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 使用用四种不同的方式连接数组

下面的示例创建一个数组 `a`，其中包含三个元素，然后用四种不同的分隔符连接所有数组元素。首先是默认的分隔符逗号，然后是一个逗号加空格，接下来是一个加号前后加空格，最后是一个空字符串。


```js
const a = ["Wind", "Water", "Fire"];
a.join(); // 'Wind,Water,Fire'
a.join(", "); // 'Wind, Water, Fire'
a.join(" + "); // 'Wind + Water + Fire'
a.join(""); // 'WindWaterFire'
```

### 在稀疏数组上使用 join()

`join()` 将空槽视为 `undefined`，并产生额外的分隔符：


```js
console.log([1, , 3].join()); // '1,,3'
console.log([1, undefined, 3].join()); // '1,,3'
```

### 在非数组对象上调用 join()

`join()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引。


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
};
console.log(Array.prototype.join.call(arrayLike));
// 2,3,4
console.log(Array.prototype.join.call(arrayLike, "."));
// 2.3.4
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.join |

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

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

参见
--

* `core-js` 中 `Array.prototype.join` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.toString()`
* `TypedArray.prototype.join()`
* `String.prototype.split()`
Array.prototype.fill()
======================

**`fill()`** 方法用一个固定值填充一个数组中从起始索引（默认为 `0`）到终止索引（默认为 `array.length`）内的全部元素。它返回修改后的数组。

尝试一下
----

语法
--


```js
fill(value)
fill(value, start)
fill(value, start, end)
```

### 参数

`value`

用来填充数组元素的值。注意所有数组中的元素都将是这个确定的值：如果 `value` 是个对象，那么数组的每一项都会引用这个元素。

`start` 可选

基于零的索引，从此开始填充，转换为整数。

* 负数索引从数组的末端开始计算，如果 `start < 0`，则使用 `start + array.length`。
* 如果 `start < -array.length` 或 `start` 被省略，则使用 `0`。
* 如果 `start >= array.length`，没有索引被填充。

`end` 可选

基于零的索引，在此结束填充，转换为整数。`fill()` 填充到但不包含 `end` 索引。

* 负数索引从数组的末端开始计算，如果 `end < 0`，则使用 `end + array.length`。
* 如果 `end < -array.length`，则使用 `0`。
* 如果 `end >= array.length` 或 `end` 被省略，则使用 `array.length`，导致所有索引都被填充。
* 如果经标准化后，`end` 的位置在 `start` 之前或之上，没有索引被填充。

### 返回值

经 `value` 填充修改后的数组。

描述
--

`fill()` 是个修改方法，不会改变 `this` 的长度，但会改变 `this` 的内容。

`fill()` 也会使用 `value` 填充稀疏数组的空槽。

`fill()` 方法是通用的。它只期望 `this` 值有一个 `length` 属性。虽然字符串也是类似数组的，但这个方法不适合应用于它们，因为字符串是不可变的。

**备注：** 在一个空数组（`length = 0`）上使用 `Array.prototype.fill()` 不会对其进行修改，因为数组没有要修改的内容。要在声明一个数组时使用 `Array.prototype.fill()`，请确保数组的 `length` 不为零。参见示例。

示例
--

### 使用 fill


```js
console.log([1, 2, 3].fill(4)); // [4, 4, 4]
console.log([1, 2, 3].fill(4, 1)); // [1, 4, 4]
console.log([1, 2, 3].fill(4, 1, 2)); // [1, 4, 3]
console.log([1, 2, 3].fill(4, 1, 1)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 3)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, -3, -2)); // [4, 2, 3]
console.log([1, 2, 3].fill(4, NaN, NaN)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 5)); // [1, 2, 3]
console.log(Array(3).fill(4)); // [4, 4, 4]

// 一个简单的对象，被数组的每个空槽所引用
const arr = Array(3).fill({}); // [{}, {}, {}]
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
```

### 使用 fill() 创建全 1 矩阵

此示例演示了如何创建全 1 的矩阵，就像 Octave 或 MATLAB 的 `ones()` 函数做到的那样。


```js
const arr = new Array(3);
for (let i = 0; i < arr.length; i++) {
  arr[i] = new Array(4).fill(1); // 创建一个大小为 4 的数组，填充全 1
}
arr[0][0] = 10;
console.log(arr[0][0]); // 10
console.log(arr[1][0]); // 1
console.log(arr[2][0]); // 1
```

### 使用 fill() 填充空数组

此示例演示了如何填充数组，将所有值设定为一个特定的值。无需指定 `end` 参数。


```js
const tempGirls = Array(5).fill("girl", 0);
```


注意，数组最初为稀疏数组，没有分配索引。`fill()` 仍然可以填充这个数组。

### 在非数组对象上调用 fill()

`fill()` 方法读取 `this` 的 `length` 属性，并设置从 `start` 到 `end` 的每个整数属性的值。


```js
const arrayLike = { length: 2 };
console.log(Array.prototype.fill.call(arrayLike, 1));
// { '0': 1, '1': 1, length: 2 }
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.fill |

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

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

参见
--

* `core-js` 中 `Array.prototype.fill` 的 polyfill
* 索引集合类
* `Array`
* `TypedArray.prototype.fill()`
Array.prototype.includes()
==========================

**`includes()`** 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 `true`，否则返回 `false`。

尝试一下
----

语法
--


```js
includes(searchElement)
includes(searchElement, fromIndex)
```

### 参数

`searchElement`

需要查找的值。

`fromIndex` 可选

开始搜索的索引（从零开始），会转换为整数。

* 负索引从数组末尾开始计数——如果 `fromIndex < 0`，那么实际使用的是 `fromIndex + array.length`。然而在这种情况下，数组仍然从前往后进行搜索。
* 如果 `fromIndex < -array.length` 或者省略 `fromIndex`，则使用 `0`，这将导致整个数组被搜索。
* 如果 `fromIndex >= array.length`，则不会搜索数组并返回 `false`。

### 返回值

一个布尔值，如果在数组中（或者在 `fromIndex` 所指示的数组部分中，如果指定 `fromIndex` 的话）找到 `searchElement` 值，则该值为 `true`。

描述
--

`includes()` 方法使用零值相等算法将 `searchElement` 与数组中的元素进行比较。0 值都被认为是相等的，不管符号是什么。（即 `-0` 等于 `0`），但 `false` *不*被认为与 `0` 相同。`NaN` 可以被正确搜索到。

当在稀疏数组上使用时，`includes()` 方法迭代空槽，就像它们的值是 `undefined` 一样。

`includes()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 使用 includes() 方法


```js
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
["1", "2", "3"].includes(3); // false
```

### fromIndex 大于等于数组长度

如果 `fromIndex` 大于等于数组的长度，则将直接返回 `false`，且不搜索该数组。


```js
const arr = ["a", "b", "c"];

arr.includes("c", 3); // false
arr.includes("c", 100); // false
```

### 计算出的索引小于 0

如果 `fromIndex` 为负值，计算出的索引将作为开始搜索 `searchElement` 的位置。如果计算出的索引小于 `0`，则整个数组都会被搜索。


```js
// 数组长度为 3
// fromIndex 为 -100
// 计算出的索引为 3 + (-100) = -97

const arr = ["a", "b", "c"];

arr.includes("a", -100); // true
arr.includes("b", -100); // true
arr.includes("c", -100); // true
arr.includes("a", -2); // false
```

### 对稀疏数组使用 includes() 方法

你可以在稀疏数组中搜索 `undefined`，得到 `true` 。


```js
console.log([1, , 3].includes(undefined)); // true
```

### 在非数组对象上调用 includes() 方法

`includes()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引。


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
};
console.log(Array.prototype.includes.call(arrayLike, 2));
// true
console.log(Array.prototype.includes.call(arrayLike, 1));
// false
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.includes |

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

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

参见
--

* `core-js` 中 `Array.prototype.includes` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.indexOf()`
* `Array.prototype.find()`
* `Array.prototype.findIndex()`
* `TypedArray.prototype.includes()`
* `String.prototype.includes()`
Array.prototype.shift()
=======================

**`shift()`** 方法从数组中删除**第一个**元素，并返回该元素的值。此方法更改数组的长度。

尝试一下
----

语法
--


```js
shift()
```

### 返回值

从数组中删除的元素；如果数组为空则返回 `undefined`。

描述
--

`shift` 方法移除索引为 0 的元素，并将后续元素的下标依次向前移动，然后返回被移除的元素。如果 `length` 属性的值为 0，则返回 `undefined`。

`pop()` 方法有着和 `shift()` 相似的行为。但是是作用于数组的最后一个元素上的。

`shift()` 方法是一个改变方法。它改变了 `this` 的内容和长度。如果你希望保持 `this` 的值不变，但返回一个删除了第一个元素的新数组，你可以使用 `arr.slice(1)`。

`shift()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。虽然字符串也是类似数组的，但这个方法不适合应用于它们，因为字符串是不可变的。

示例
--

### 移除数组中的一个元素

以下代码显示了删除其第一个元素之前和之后的 `myFish` 数组。它还显示已删除的元素：


```js
const myFish = ["angel", "clown", "mandarin", "surgeon"];

console.log("调用 shift 之前：", myFish);
// 调用 shift 之前： ['angel', 'clown', 'mandarin', 'surgeon']

const shifted = myFish.shift();

console.log("调用 shift 之后：", myFish);
// 调用 shift 之后： ['clown', 'mandarin', 'surgeon']

console.log("被删除的元素：" + shifted);
// "被删除的元素：angel"
```

### 在 while 循环中使用 shift()

shift() 方法经常用于 while 循环的条件中。下例中每次迭代都会从一个数组中移除下一项元素，直至它成为空数组。


```js
const names = ["Andrew", "Tyrone", "Paul", "Maria", "Gayatri"];

while (typeof (i = names.shift()) !== "undefined") {
  console.log(i);
}
// Andrew, Tyrone, Paul, Maria, Gayatri
```

### 在非数组对象上调用 shift()

`shift` 方法会读取 `this` 的 `length` 属性。如果规范化长度为 0，`length` 再次设置为 `0`（而之前可能为负值或 `undefined`）。否则，返回 `0` 处的属性，其余属性向左移动 1。`length` 属性递减 1。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.shift.call(arrayLike));
// undefined，因为它是一个空槽
console.log(arrayLike);
// { '1': 4, length: 2, unrelated: 'foo' }

const plainObj = {};
// 这里没有长度属性，所以长度为 0
Array.prototype.shift.call(plainObj);
console.log(plainObj);
// { length: 0 }
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.shift |

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

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

参见
--

* 索引集合类
* `Array`
* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`