recursal/MDN huggingface dataset:
TypedArray.prototype.buffer
===========================

**`buffer`** 访问器属性表示由 *TypedArray* 在构造期间引用的 `ArrayBuffer`。

语法
--
```

typedArray.buffer
```

描述
--

`buffer` 属性是一个访问器属性，它的 set 访问器函数是 `undefined`，意思是你只能够读取这个属性。它的值在 *TypedArray* 构造时建立，不能被修改。*TypedArray* 是这里的类型化数组之一。

示例
--

### 使用 `buffer` 属性


```js
var buffer = new ArrayBuffer(8);
var uint16 = new Uint16Array(buffer);
uint16.buffer; // ArrayBuffer { byteLength: 8 }
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.buffer |

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

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

另见
--

* JavaScript 类型化数组
* `TypedArray`
TypedArray.from()
=================

`TypedArray.from()` 方法 从一个类数组或者可迭代对象中创建一个新类型数组。这个方法和 `Array.from()` 类似。

语法
--


```js
TypedArray.from(arrayLike, mapFn)
TypedArray.from(arrayLike, mapFn, thisArg)
```


上面代码中的 `TypedArray` 需要替换为下面的任何一个构造函数：

* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
* `BigInt64Array`
* `BigUint64Array` (en-US)
### 参数

*`source`*

想要转换为类型数组的类数组或者可迭代对象。

*`mapFn`*

可选参数。如果指定了该参数，则最后生成的类型数组会经过该函数的加工处理后再返回。

*`thisArg`*

可选参数。执行 `mapFn` 函数时 `this` 的值。

### 返回值

一个新的 `TypedArray` 实例。

描述
--

`TypedArray.from()` 允许你从下面两者来创建数组：

* 类数组对象（拥有一个 `length` 属性和若干索引属性的任意对象）
* 可迭代对象（你可以从它身上迭代出若干个元素的对象，比如有 `Map` 和 `Set` 等）。

`TypedArray.from()` 方法有一个可选参数 `mapFn`, 让你可以在最后生成的类型数组上再执行一次 `map` 方法后再返回。也就是说以下两种形式是等价的：

* `TypedArray.from(obj, mapFn, thisArg)`
* `TypedArray.from(Array.prototype.map.call(obj, mapFn, thisArg))`

`from()` 的 `length` 属性值为 `1`。

`Array.from()` 和 `TypedArray.from()` 之间有一些微妙的区别：

* 如果 `|this|` 的值传递给 `TypedArray.from` 不是一个构造器，`TypedArray.from` 将抛出{jsxref("TypeError")}}, 而 `Array.from` 默认将创建一个 `Array`.
* `TypedArray.from` 使用`[Put]` 而 `rray.from` 使用`[DefineProperty]]`. 因此，当和 `Proxy` 对象一起时，它调用 `handler.set` 创建一个新的元素而非 `handler.defineProperty`.
* 当 `from` 获得一个迭代器时，`TypedArray` 一开始收集迭代器中的所有值，此时创建一个 `|this|` 的实例用于计数，然后在实例中设置值。 `Array.from` 设置每个从迭代器其中获取的值，最后设置它的长度。
* 当 `Array.from` 获得一个不可迭代的类数组时，it respects holes, 而 `TypedArray.from` 将确保结果是 dense.
示例
--


```js
// 使用 Set (可迭代对象)
var s = new Set([1, 2, 3]);
Uint8Array.from(s);
// Uint8Array [ 1, 2, 3 ]

// 使用字符串
Int16Array.from("123");
// Int16Array [ 1, 2, 3 ]

// 使用箭头函数对数组元素进行映射
Float32Array.from([1, 2, 3], (x) => x + x);
// Float32Array [ 2, 4, 6 ]

// 生成一个数字序列
Uint8Array.from({ length: 5 }, (v, k) => k);
// Uint8Array [ 0, 1, 2, 3, 4 ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.from |

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

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

参见
--

* `core-js` 中 `TypedArray.from` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `TypedArray.of()`
* `TypedArray.prototype.map()`
* `Array.from()`
TypedArray.prototype.copyWithin()
=================================

**`copyWithin()`** 方法将数组中元素的序列复制到以 `target` 起始的位置。拷贝的副本取自第二个参数（`start`）和第三个参数（`end`）的下标位置。`end` 参数是可选的，默认为数组长度。该方法与 `Array.prototype.copyWithin` 的算法相同。*TypedArray* 指的是这里的 类型化数组类型 之一。

语法
--
```

typedarray.copyWithin(target, start[, end = this.length])
```

### 参数

`target`

目标起始位置的下标，复制元素到这里。

`start`

源起始位置的下标，在这里开始复制元素。

`end 可选`

可选。源终止位置的下标，在这里停止复制元素。

### 返回值

修改后的类型化数组。

描述
--

更多信息请见 `Array.prototype.copyWithin`。

这个方法取代了实验性的 `TypedArray.prototype.move()`。

示例
--


```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);
console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]
uint8.copyWithin(3, 0, 3);
console.log(uint8); // Uint8Array [ 1, 2, 3, 1, 2, 3, 0, 0 ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.copywithin |

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

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

另见
--

* `TypedArray`
TypedArray.prototype.toString()
===============================

**`toString()`** 方法返回一个表示指定数组及其元素的字符串。这个方法的算法和 `Array.prototype.toString()` 一样。*TypedArray* 在这是typed array types 之一。

语法
--


```js
values()
```

### 返回值

一个字符串，表示类型数组 (typed array) 的元素。

描述
--

`TypedArray` 对象重写了`Object`的 `toString`方法。对 TypedArray 对象来说，`toString` 方法联结了数组，并返回一个字符串，它包含由逗号分隔的数组元素。例如，下面的代码创建了一个类型数组，使用`toString` 将数组转化为字符串。


```js
var numbers = new Uint8Array([2, 5, 8, 1, 4]);
numbers.toString(); // "2,5,8,1,4"
```


当一个类型数组表示为文本值，或者当一个数组被用于字符串连接，则 JavaScript 将自动调用 `toString` 方法。

### 兼容性

如果浏览器还不支持`TypedArray.prototype.toString()` 方法，JavaScript 将调用`Object`的 `toString` 方法：


```js
var numbers = new Uint8Array([2, 5, 8, 1, 4]);
numbers.toString(); // "[object Uint8Array]"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.tostring |

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

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

参见
--

* `TypedArray.prototype.join()`
TypedArray.prototype.entries()
==============================

**`entries()`** 返回新的 `Array Iterator` 对象，包含数组每个下标处的键值对。

语法
--
```

arr.entries()
```

### 返回值

新的 **`Array Iterator`** 对象。

示例
--

### `使用 for...of` 循环的迭代


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.entries();
// 你的浏览器必须支持 for..of 循环
// 以及 for 循环中的 let 区域变量
for (let n of eArray) {
  console.log(n);
}
```

### 备选迭代


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArr = arr.entries();
console.log(eArr.next().value); // [0, 10]
console.log(eArr.next().value); // [1, 20]
console.log(eArr.next().value); // [2, 30]
console.log(eArr.next().value); // [3, 40]
console.log(eArr.next().value); // [4, 50]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.entries |

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

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

另见
--

* JavaScript 类型化数组
* `TypedArray`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
get TypedArray[@@species]
=========================

**`TypedArray[@@species]`** 访问器属性返回类型化数组的构造器。

语法
--
```

TypedArray[Symbol.species]

其中 TypedArray 是下列类型之一：

Int8Array
Uint8Array
Uint8ClampedArray
Int16Array
Uint16Array
Int32Array
Uint32Array
Float32Array
Float64Array
```

描述
--

`species` 访问器属性返回类型化数组对象的构造器。子类的构造器可能会覆盖它来修改构造器的赋值。

示例
--

`species` 属性返回默认的构造器函数，对于给定的类型化数组对象，它是类型化数组构造器之一：


```js
Int8Array[Symbol.species]; // function Int8Array()
Uint8Array[Symbol.species]; // function Uint8Array()
Float32Array[Symbol.species]; // function Float32Array()
```


在派生的集合对象中（也就是你自己定义的类型化数组`MyTypedArray`）， `MyTypedArray` 的 species 是 `MyTypedArray` 构造器。但是，你可能希望覆盖它，以便在你的派生类方法中返回类型化数组的基类对象：


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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%-@@species |

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

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

另见
--

* `TypedArray`
* `Symbol.species`
TypedArray.prototype.map()
==========================

**`map()`** 方法对类型化数组的每个元素调用提供的函数，并使用结果来创建新的类型化数组。这个方法的算法和 `Array.prototype.map()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


```js
map(callbackFn)
map(callbackFn, thisArg)
```

### 参数

`callback`

产生新的类型化数组的元素的函数，接受三个函数：

`currentValue`

类型化数组中要处理的当前元素

`index`

类型化数组中要处理的当前元素的下标

`array`

`map`在其上调用的类型化数组


`thisArg`

可选，执行`callback`时作为`this`的值。

### 返回值

新的类型化数组

描述
--

`map`方法对类型化数组中的元素调用提供的 `callback`函数，按照顺序，并且会从结果构造新的类型化数组。 `callback` 只对拥有值的类型化数组下标调用。它不会对未定义的，被删除的或者没有赋值的下标调用。

`callback` 以三个参数调用：元素的值，元素下标，和被遍历的类型化数组。

如果将 `thisArg` 参数提供给 `map`，它会在调用时传递给 `callback`，作为它的 `this` 值。否则，会传递 `undefined` 作为它的 `this` 值。`callback` 最终观测到的 `this` 值由用于决定函数可见的 `this` 值的一般规则来决定。

`map` 不改变在其上调用的类型化数组（虽然如果调用了`callback`可能会这样做）。

由 `map`处理的元素范围在`callback`调用之前就确定了。在 `map`调用之后添加到数组的元素不会由 `callback`访问。如果类型化数组的现有元素被改变，或被删除，它们传给`callback`的值是`map` 访问它们时候的值。已删除的元素不会被访问。

示例
--

### 将类型数组映射被平方根的类型数组

下面的代码接受一个类型数组，并创建一个新的类型数组，含有第一个类型数组中元素的平方根。


```js
var numbers = new Uint8Array([1, 4, 9]);
var roots = numbers.map(Math.sqrt);
// roots is now: Uint8Array [1, 2, 3],
// numbers is still Uint8Array [1, 4, 9]
```

### 使用含有参数的函数来映射类型数组

下面的代码展示了，当使用需要一个参数的函数时，`map`的工作方式。在`map`遍历原始数组的过程中，参数会自动赋值为类型化数组的每个元素。


```js
var numbers = new Uint8Array([1, 4, 9]);
var doubles = numbers.map(function (num) {
  return num \* 2;
});
// doubles is now Uint8Array [2, 8, 18]
// numbers is still Uint8Array [1, 4, 9]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.map |

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

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

另见
--

* `TypedArray.prototype.filter()`
* `Array.prototype.map()`
TypedArray.prototype[@@iterator]()
==================================

@@iterator 的初始值是和 `values` 属性的初始值相同的对象。

尝试一下
----

语法
--
```

arr[Symbol.iterator]()
```

### 返回值

数组的 **迭代器** 函数，通常是 `values()`函数。

示例
--

### 使用`for...of` 循环的迭代


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
// 你的浏览器必须支持 for..of 循环
// 以及 for 循环中的 let 区域变量
for (let n of arr) {
  console.log(n);
}
```

### 备选迭代


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // 10
console.log(eArr.next().value); // 20
console.log(eArr.next().value); // 30
console.log(eArr.next().value); // 40
console.log(eArr.next().value); // 50
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype-@@iterator |

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

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

See also
--------

* JavaScript typed arrays
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
TypedArray.prototype.findIndex()
================================

如果某个元素满足所提供的测试函数，**`findIndex()`** 方法返回类型化数组中的**下标**，否则返回 -1。*TypedArray* 是这里的类型化数组类型之一。

同时请参见 `find()` 方法，它返回了类型化数组中所发现元素的**值**，而不是它的下标。

语法
--


```js
findIndex(callbackFn)
findIndex(callbackFn, thisArg)
```

### 参数

`callback`

用于在类型化数组中的每个元素上执行的函数，接受三个参数：

`element`

要处理的类型化数组的当前元素。

`index`

要处理的当前元素在类型化数组中的下标

`array`

`find` 在其上调用的类型化数组


`thisArg`

可选，执行`callback`时的`this`值。

### 返回值

如果元素通过了测试，则为数组下标，否则为 -1。

描述
--

`findIndex` 方法对类型化数组中的每个元素执行一次 `callback` 函数，直到它找到一个使 `callback` 返回 *true*的元素。如果发现了一个这样的元素，`find` 方法将会立即返回该元素的下标。否则，`findIndex` 方法会返回 -1。`callback` 只会对那些已经被赋值的索引调用。不会对那些被删除或从来没被赋值的索引调用。

`callback` 以三个参数调用：元素的值，元素索引，以及要遍历的数组对象。

如果将`thisArg`参数提供给`findIndex`，它会在调用时传递给`callback`，作为它的 `this`值。如果没有提供，会使用`undefined`。

`findIndex` 不修改在其上调用的类型化数组。

由 `findIndex`处理的元素范围在`callback`调用之前就确定了。在 `findIndex`调用之后添加到数组的元素不会由 `callback`访问。如果类型化数组的现有元素被改变，或被删除，它们传给`callback`的值是`findIndex` 访问它们时候的值。已删除的元素不会被访问。

示例
--

### 在类型化数组中寻找质数的下标

下面的示例在类型化数组中寻找质数元素的下标（如果没有质数则返回 -1）.


```js
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

var uint8 = new Uint8Array([4, 6, 8, 12]);
var uint16 = new Uint16Array([4, 6, 7, 12]);

console.log(uint8.findIndex(isPrime)); // -1，未发现
console.log(uint16.findIndex(isPrime)); // 2
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.findindex |

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

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

参见
--

* `core-js` 中 `TypedArray.prototype.findIndex` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.findLast()` (en-US)
* `TypedArray.prototype.findLastIndex()` (en-US)
* `TypedArray.prototype.indexOf()`
* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.findIndex()`
TypedArray.prototype.sort()
===========================

**`sort()`** 方法*原地*排序类型化数组的元素，并且返回类型化数组。这个方法的算法和`Array.prototype.sort()` 相同。*TypedArray* 是这里的类型化数组类型 之一。

语法
--


```js
sort()
sort(compareFn)
```

### 参数

`compareFunction` 可选

指定定义排序顺序的函数

### 返回值

排序后的类型化数组。

示例
--

更多示例请参考 `Array.prototype.sort()` 方法。


```js
var numbers = new Uint8Array([40, 1, 5, 200]);
numbers.sort();
// Uint8Array [ 1, 5, 40, 200 ]
// 在这里，按数值排序数值时，
// 不需要比较函数。

var numbers = [40, 1, 5, 200];
numbers.sort();
// 将元素作为字符串来排序。
// [1, 200, 40, 5]

function compareNumbers(a, b) {
  return a - b;
}

numbers.sort(compareNumbers);
// [ 1, 5, 40, 200 ]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.sort |

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

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

另见
--

* `Array.prototype.sort()`
TypedArray.prototype.reduce()
=============================

**`reduce()`** 方法接受一个函数作为参数，这个函数作为一个累加器，从左到右遍历整个类型数组，最后返回一个单一的值。这个方法和`Array.prototype.reduce()`使用了同样的算法。*TypedArray* 是一个 类型数组.

语法
--


```js
reduce(callbackFn)
reduce(callbackFn, initialValue)
```

### 参数

`callback`

对类型数组的每一个值应用的函数，它接受以下参数：

`previousValue`

在上一次迭代中，调用 callback 的返回值，或者是提供的 `initialValue`。

`currentValue`

类型化数组中当前要处理的值。

`index`

类型化数组中要处理的当前元素的下标

`array`

`reduce` 在其上调用的类型化数组。


`initialValue`

可选。用作 `callback` 首次调用`的第一个参数的对象。

### 返回值

由归约返回的结果。

描述
--

`reduce`方法对类型化数组中出现的每个元素执行`callback`函数，除了类型化数组的空隙。它接受四个参数：初始值（或者来自之前`callback`调用的值），当前元素的值，当前下标，以及被遍历的类型化数组。

第一次调用回调函数的时候， `previousValue` 和 `currentValue` 可以是两个值之一。如果 `initialValue` 在`reduce`的调用中提供， `previousValue` 会等于`initialValue` 并且`currentValue` 会等于类型化数组的第一个值。如果 `initialValue` 没有提供，则`previousValue`等于类型化数组的第一个值，`currentValue`会等于第二个值。

如果类型化数组为空并且没有提供 `initialValue`，会抛出 `TypeError` 。如果类型化数组中只有一个元素（无论位置）并且没有提供`initialValue` ，或者如果提供了`initialValue` 但是类型化数组为空，会返回唯一的值，但不会调用 `callback`。

示例
--

### 累加数组中的所有值


```js
var total = new Uint8Array([0, 1, 2, 3]).reduce(function (a, b) {
  return a + b;
});
// total == 6
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.reduce |

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

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

另见
--

* `TypedArray.prototype.reduceRight()`
* `Array.prototype.reduce()`
TypedArray.prototype.includes()
===============================

**`includes()`** 方法判断类型化数组中是否含有特定元素，并相应返回 `true` 或者 `false`，这个方法的算法和 `Array.prototype.includes()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


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

### 参数

`searchElement`

要搜索的元素。

`fromIndex`

可选，数组中的位置，在这里开始搜索 `searchElement`；默认为 0。

### 返回值

`Boolean`。

示例
--


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.includes(2); // true
uint8.includes(4); // false
uint8.includes(3, 3); // false

// NaN 的处理（仅仅对 Float32 和 Float64 为 true）
new Uint8Array([NaN]).includes(NaN); // false，因为 NaN 传递给构造器时转换为 0
new Float32Array([NaN]).includes(NaN); // true;
new Float64Array([NaN]).includes(NaN); // true;
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.includes |

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

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

另见
--

* `Array.prototype.includes()`
* `String.prototype.includes()`
* `TypedArray.prototype.indexOf()`
TypedArray.prototype.subarray()
===============================

`subarray()` 返回一个新的、基于相同 `ArrayBuffer`、元素类型也相同的的 *TypedArray*。开始的索引将会被包括，而结束的索引将不会被包括。*TypedArray* 是指 typed array types 的其中之一。尝试一下
----

用法
--


```js
subarray()
subarray(begin)
subarray(begin, end)
```

### 参数

begin 可选

元素开始的索引，开始索引的元素将会被包括。若该值没有传入，将会返回一个拥有全部元素的数组。

end 可选

元素结束的索引，结束索引的元素将**不会**被包括。若该值没有传入，从 `begin` 所指定的那一个元素到数组末尾的所有元素都将会被包含进新数组中。

### 返回值

一个新的 `TypedArray` 对象。

说明
--

* 被 `begin` 和 `end` 指定的范围将会收束与当前数组的有效索引
* 若计算后得出的长度是负数，将会被收束成 0
* 若 `begin` 或 `end` 是负数，将会被当做成是从数组末端读取的索引

需要注意的是，使用该方法返回的新数组还是建立在原有的 Buffer 之上的，所以，改动数组的内容将会影响到原数组，反之亦然。

Examples
--------

### Using the `subarray` method


```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);

console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]

var sub = uint8.subarray(0, 4);

console.log(sub); // Uint8Array [ 1, 2, 3, 0 ]
```

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.subarray |

Browser compatibility
---------------------

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

See also
--------

* JavaScript typed arrays
* `TypedArray`
* `ArrayBuffer`
Object.prototype.\_\_defineSetter\_\_()
=======================================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

**备注：** 此特性已弃用，建议使用对象初始化语法或 `Object.defineProperty()` API 来定义 setter。该方法的行为只针对 Web 兼容性进行了规定，在任何平台上都不需要实现该方法。它可能无法在所有地方正常工作。

**`__defineSetter__()`** 方法将一个对象的属性绑定到一个函数上，当该属性被赋值时，该函数将被调用。

语法
--


```js
\_\_defineSetter\_\_(prop, func)
```

### 参数

`prop`

`func` 所绑定的 setter 函数所对应的属性名称，以字符串形式表示。

`func`

当试图设置指定属性时要调用的函数。该函数接收以下参数：

`val`

试图赋给 `prop` 的值。


### 返回值

`undefined`。

### 异常

`TypeError`

如果 `func` 不是函数，则抛出。

描述
--

所有继承自 `Object.prototype` 的对象（也就是除了 `null` 原型对象的对象）都会继承 `__defineSetter__()` 方法。该方法允许在一个已存在的对象上定义一个 setter。这相当于使用 `Object.defineProperty(obj, prop, { set: func, configurable: true, enumerable: true })` 方法，这意味着该属性是可枚举和可配置的，而且如果存在，则保留任何现有的 getter。

`__defineSetter__()` 在规范中被定义为“可选规范”，这意味着不需要任何实现来实现它。然而，所有主要的浏览器都实现了它，并且由于它的持续使用，它不太可能被删除。如果一个浏览器实现了 `__defineSetter__()`，那么它还需要实现 `__lookupGetter__()`、`__lookupSetter__()` 和 `__defineGetter__()` 方法。

示例
--

### 使用 \_\_defineSetter\_\_()


```js
const o = {};
o.\_\_defineSetter\_\_("value", function (val) {
  this.anotherValue = val;
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

### 以标准方式定义 setter 属性

在对象首次初始化时，你可以使用 `set` 语法来定义一个 setter。


```js
const o = {
  set value(val) {
    this.anotherValue = val;
  },
};
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```


你也可以使用 `Object.defineProperty()` 在对象创建后为其定义一个 setter。与 `__defineSetter__()` 相比，此方法允许你控制 setter 的可枚举性和可配置性，以及定义 symbol 属性。`Object.defineProperty()` 方法也适用于 `null` 原型对象，因为它们没有继承 `Object.prototype`，所以没有 `__defineSetter__()` 方法。


```js
const o = {};
Object.defineProperty(o, "value", {
  set(val) {
    this.anotherValue = val;
  },
  configurable: true,
  enumerable: true,
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineSetter\_\_ |

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

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

参见
--

* `core-js` 中 `Object.prototype.__defineSetter__` 的 polyfill
* `Object.prototype.__defineGetter__()`
* `set` 语法
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* JS 指南：定义 Getter 和 Setter
* [博文] \_\_defineGetter\_\_ 和 \_\_defineSetter\_\_ 已被弃用
* Firefox bug 647423
Object.is()
===========

**`Object.is()`** 静态方法确定两个值是否为相同值。

尝试一下
----

语法
--


```js
Object.is(value1, value2)
```

### 参数

`value1`

要比较的第一个值。

`value2`

要比较的第二个值。

### 返回值

一个布尔值，指示两个参数是否为相同的值。

描述
--

`Object.is()` 确定两个值是否为相同值。如果以下其中一项成立，则两个值相同：

* 都是 `undefined`
* 都是 `null`
* 都是 `true` 或者都是 `false`
* 都是长度相同、字符相同、顺序相同的字符串
* 都是相同的对象（意味着两个值都引用了内存中的同一对象）
* 都是 BigInt 且具有相同的数值
* 都是 symbol 且引用相同的 symbol 值
* 都是数字且
    + 都是 `+0`
    + 都是 `-0`
    + 都是 `NaN`
    + 都有相同的值，非零且都不是 `NaN`

`Object.is()` 与 `==` 运算符并不等价。`==` 运算符在测试相等性之前，会对两个操作数进行类型转换（如果它们不是相同的类型），这可能会导致一些非预期的行为，例如 `"" == false` 的结果是 `true`，但是 `Object.is()` 不会对其操作数进行类型转换。

`Object.is()` 也*不*等价于 `===` 运算符。`Object.is()` 和 `===` 之间的唯一区别在于它们处理带符号的 0 和 `NaN` 值的时候。`===` 运算符（和 `==` 运算符）将数值 `-0` 和 `+0` 视为相等，但是会将 `NaN` 视为彼此不相等。

示例
--

### 使用 Object.is()


```js
// 案例 1：评估结果和使用 === 相同
Object.is(25, 25); // true
Object.is("foo", "foo"); // true
Object.is("foo", "bar"); // false
Object.is(null, null); // true
Object.is(undefined, undefined); // true
Object.is(window, window); // true
Object.is([], []); // false
const foo = { a: 1 };
const bar = { a: 1 };
const sameFoo = foo;
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(foo, sameFoo); // true

// 案例 2: 带符号的 0
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true

// 案例 3: NaN
Object.is(NaN, 0 / 0); // true
Object.is(NaN, Number.NaN); // true
```

规范
--

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

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

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

参见
--

* `core-js` 中 `Object.is` 的 Polyfill
* JavaScript 中的相等性判断——三种内置相等性工具的比较
Object.groupBy()
================

Limited availability
--------------------

This feature is not Baseline because it does not work in some of the most widely-used browsers.

* Learn more
* See full compatibility
* Report feedback
**实验性:** **这是一项实验性技术**  
在将其用于生产之前，请仔细检查浏览器兼容性表格。

**备注：** 在某些浏览器的某些版本中，此方法被实现为 `Array.prototype.group()` 方法。由于 web 兼容性问题，它现在以静态方法实现。参见浏览器兼容性表格以获取更多信息。

**`Object.groupBy()`** 静态方法根据提供的回调函数返回的字符串值对给定可迭代对象中的元素进行分组。返回的对象具有每个组的单独属性，其中包含组中的元素的数组。

当分组名称可以用字符串表示时，应使用此方法。如果你需要使用某个任意值作为键来对元素进行分组，请改用 `Map.groupBy()` 方法。

语法
--


```js
Object.groupBy(items, callbackFn)
```

### 参数

`items`

一个将进行元素分组的可迭代对象（例如 `Array`）。

`callbackFn`

对可迭代对象中的每个元素执行的函数。它应该返回一个值，可以被强制转换成属性键（字符串或 symbol），用于指示当前元素所属的分组。该函数被调用时将传入以下参数：

`element`

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

`index`

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


### 返回值

一个带有所有分组属性的 `null` 原型对象，每个属性都分配了一个包含相关组元素的数组。

描述
--

`Object.groupBy()` 为可迭代对象中的每个元素调用一次提供的 `callbackFn` 函数。回调函数应返回一个字符串或 symbol（不属于这两种类型的值会被强制转换为字符串），用于指示元素所属的分组。`callbackFn` 的返回值会被用作 `Map.groupBy()` 返回的对象的键。每个键都有一个相关联的数组，其中包含回调函数返回相同值的所有元素。

返回的对象中的元素和原始可迭代对象中的元素相同（不是深拷贝）。更改元素的内部结构将反映在原始可迭代对象和返回的对象中。

示例
--

### 使用 Object.groupBy()

首先，我们定义一个包含代表各种食品库存的对象的数组。每种食品都有一个 `type` 和一个 `quantity` 属性。


```js
const inventory = [
  { name: "芦笋", type: "蔬菜", quantity: 5 },
  { name: "香蕉", type: "水果", quantity: 0 },
  { name: "山羊", type: "肉", quantity: 23 },
  { name: "樱桃", type: "水果", quantity: 5 },
  { name: "鱼", type: "肉", quantity: 22 },
];
```


下面的代码根据元素的 `type` 属性的值对元素进行分组。


```js
const result = Object.groupBy(inventory, ({ type }) => type);

/\* 结果是：
{
 蔬菜: [
 { name: "芦笋", type: "蔬菜", quantity: 5 },
 ],
 水果: [
 { name: "香蕉", type: "水果", quantity: 0 },
 { name: "樱桃", type: "水果", quantity: 5 }
 ],
 肉: [
 { name: "山羊", type: "肉", quantity: 23 },
 { name: "鱼", type: "肉", quantity: 22 }
 ]
}
\*/
```


箭头函数每次被调用时都只返回每个数组元素的 `type` 属性。请注意，函数参数 `{ type }` 是一个函数参数的对象解构语法的基本示例。这会解构传递为参数的对象的 `type` 属性，并将其赋值给函数体中名为 `type` 的变量。这是一种非常简洁的访问函数中相关元素的值的方式。

我们还可以创建根据元素的一个或多个属性中的值推断的分组。下面是一个非常类似的示例，根据 `quantity` 字段的值将项目分为 `ok` 或 `restock` 组。


```js
function myCallback({ quantity }) {
  return quantity > 5 ? "ok" : "restock";
}

const result2 = Object.groupBy(inventory, myCallback);

/\* 结果是：
{
 restock: [
 { name: "芦笋", type: "蔬菜", quantity: 5 },
 { name: "香蕉", type: "水果", quantity: 0 },
 { name: "樱桃", type: "水果", quantity: 5 }
 ],
 ok: [
 { name: "山羊", type: "肉", quantity: 23 },
 { name: "鱼", type: "肉", quantity: 22 }
 ]
}
\*/
```

规范
--

| Specification |
| --- |
| Array Grouping # sec-object.groupby |

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

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

参见
--

* `core-js` 中 `Object.groupBy` 的 polyfill
* 索引集合类
* `Array.prototype.reduce()`
* `Object.fromEntries()`
* `Map.groupBy()`