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

这个 **`some()`** 方法检测 *TypedArray* 的一些元素是否通过所提供函数的测试。这个方法和 `Array.prototype.some()` *相同。* *TypedArray* 是 typed array types 之一。

尝试一下
----

语法
--


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

### 参数

`callback`

一个测试每个元素的函数，有 3 个参数：

`currentValue`

在 typed array 中，正在被测试的元素。

`index`

在 typed array 中，正在被测试元素的索引。

`array`

正在被调用的 typed array 本身。


`thisArg`

可选的。`callback` 回调函数的 `this` 值 .

### 返回值

**`true`** 如果 callback 函数以任一数组元素为参数调用时，返回 truthy; 否则，**`false`**.

描述
--

对于 typed array 中的每个元素，`some`方法执行一次 `callback`，直到找到一个`callback` 返回 true 的元素。如果一个元素被找到，`some` 立即返回 `true`. 否则，`some` 返回 `false`.

`callback` 期望 3 个参数：元素的值，元素的索引，和被遍历的数组对象。

如果 `some` 提供 `thisArg`, 那么`thisArg`会作为 `callback` 调用时的`this 值`. 否则，`callback` 调用时的 `this` 是 `undefined`. `callback` 最终可观测的`this` 是根据 确定函数 this 的通常规则 所确定的。

`some` 被调用不会改变 typed array .

### 示例

### 测试类型化数组所有元素的大小

以下示例测试 typed array 中的所有元素都大于 10.


```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
new Uint8Array([2, 5, 8, 1, 4]).some(isBiggerThan10); // false
new Uint8Array([12, 5, 8, 1, 4]).some(isBiggerThan10); // true
```

规范
--

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

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

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

参见
--

* `core-js` 中 `TypedArray.prototype.some` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.forEach()`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.includes()`
* `Array.prototype.some()`
TypedArray.prototype.reverse()
==============================

**`reverse()`** 方法原地翻转类型化数组。类型化数组的第一个元素变为最后一个，最后一个变为第一个。这个方法的算法和 `Array.prototype.reverse()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


```js
reverse()
```

### 返回值

翻转的数组。

示例
--


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.reverse();

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

规范
--

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

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

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

另见
--

* `Array.prototype.reverse()`
TypedArray.prototype.keys()
===========================

**`keys()`** 方法返回新的 `Array Iterator` 对象，包含数组中每个下标的键。

语法
--


```js
keys()
```

### 返回值

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

示例
--

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


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.keys();
// 你的浏览器必须支持 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.keys();
console.log(eArr.next().value); // 0
console.log(eArr.next().value); // 1
console.log(eArr.next().value); // 2
console.log(eArr.next().value); // 3
console.log(eArr.next().value); // 4
```

规范
--

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

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

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

另见
--

* JavaScript 类型化数组
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
* for...of
* 迭代协议
TypedArray.prototype.every()
============================

**`every()`** 方法测试类型化数组的所有元素是否都能够通过由提供函数实现的测试。这个方法的算法与 `Array.prototype.every()`相同。*TypedArray* 是这里的 类型化数组类型 之一。

语法
--


```js
every(callbackFn)
every(callbackFn, thisArg)
```

### 参数

`callback`

用于测试每个元素的函数，接受三个参数：

`currentValue`

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

`index`

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

`array`

every 在其上调用的类型化数组


`thisArg`

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

### 返回值

如果函数对数组每个元素返回 truthy ，则为\*\*`true`\*\*，否则为 **`false`**。

描述
--

`every` 方法为类型化数组中的每个元素执行一次 `callback` 函数，直到它找到一个使 `callback` 返回 *false*（表示可转换为布尔值 false 的值）的元素。如果发现了一个这样的元素，`every` 方法将会立即返回 `false`。否则，`callback` 为每一个元素返回 `true`，`every` 就会返回 `true`。`callback` 只会为那些已经被赋值的索引调用。不会为那些被删除或从来没被赋值的索引调用。

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

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

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

示例
--

### 测试类型化数组所有元素的大小

下面的示例测试了类型化数组所有元素是否大于 10。


```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).every(isBigEnough); // false
new Uint8Array([12, 54, 18, 130, 44]).every(isBigEnough); // true
```

### 使用箭头函数测试类型化数组的元素

箭头函数为相同测试提供了更短的语法。


```js
new Uint8Array([12, 5, 8, 130, 44]).every((elem) => elem >= 10); // false
new Uint8Array([12, 54, 18, 130, 44]).every((elem) => elem >= 10); // true
```

规范
--

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

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

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

另见
--

* `TypedArray.prototype.some()`
* `Array.prototype.every()`
TypedArray.BYTES\_PER\_ELEMENT
==============================

概要
--

**`TypedArray.BYTES_PER_ELEMENT`** 属性代表了强类型数组中每个元素所占用的字节数。

| `TypedArray.BYTES_PER_ELEMENT` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

语法
--
```

TypedArray.BYTES_PER_ELEMENT;
```

描述
--

强类型数组对象用来解释为单个元素的字节数是不一样的。常量 `BYTES_PER_ELEMENT` 表示了特定强类型数组中每个元素所占用的字节数。

示例
--


```js
Int8Array.BYTES\_PER\_ELEMENT; // 1
Uint8Array.BYTES\_PER\_ELEMENT; // 1
Uint8ClampedArray.BYTES\_PER\_ELEMENT; // 1
Int16Array.BYTES\_PER\_ELEMENT; // 2
Uint16Array.BYTES\_PER\_ELEMENT; // 2
Int32Array.BYTES\_PER\_ELEMENT; // 4
Uint32Array.BYTES\_PER\_ELEMENT; // 4
Float32Array.BYTES\_PER\_ELEMENT; // 4
Float64Array.BYTES\_PER\_ELEMENT; // 8
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray.bytes\_per\_element |

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

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

参见
--

* JavaScript 强类型数组
* `TypedArray`
TypedArray.prototype.indexOf()
==============================

**`indexOf()`** 方法返回在类型数组中可以找到给定元素的第一个索引，如果不存在，则返回 -1。方法具有与 `Array.prototype.indexOf()` 相同的算法。TypedArray 是这里的类型化数组类型之一。

语法
--


```js
indexOf(searchElement)
indexOf(searchElement, fromIndex)
```

### 参数

`searchElement`

需要在类型化数组中定位的元素

`fromIndex`

搜索的起始下标。如果下标大于等于类型化数组长度，则返回 -1，意思是类型化数组不会被搜索。如果提供的下标值是负数，则被当做距离类型化数组尾部的偏移。注：如果提供的下标是负数，类型化数组仍然从前到后搜索。如果计算出来的下标小于 0，则会搜索整个类型化数组。默认为 0（搜索整个类型化数组）。

### 返回值

数组中元素的第一个下标；没有找到则返回\*\*-1\*\* 。

描述
--

`indexOf`使用严格相等 (en-US) （由 === 或三等号运算符使用的相同方法）比较`searchElement`和类型化数组的元素。

示例
--


```js
let uint8 = new Uint8Array([2, 5, 9]);
uint8.indexOf(2); // 0
uint8.indexOf(7); // -1
uint8.indexOf(9, 2); // 2
uint8.indexOf(2, -1); // -1
uint8.indexOf(2, -3); // 0
```

规范
--

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

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

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

另见
--

* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.indexOf()`
TypedArray.of()
===============

`TypedArray.of()` 方法创建一个具有可变数量参数的新类型数组。此方法几乎与 `Array.of()` 相同。

语法
--


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

### 参数

`elementN`

创建类型数组的元素。

### 返回值

一个新的 `TypedArray` 实例。

描述
--

`Array.of()` 和 `TypedArray.of()` 之间的一些细微区别：

* 如果传递给 TypedArray.of 的这个值不是构造函数，TypedArray.of 将抛出一个`TypeError` ，其中 Array.of 默认创建一个新的 `Array`。
* `TypedArray.of` 使用 [[Put]] 其中 Array.of 使用 [[DefineProperty]]。因此，当使用`Proxy` 对象时，它调用 `handler.set` 创建新的元素，而不是 `handler.defineProperty`。
范例
--


```js
Uint8Array.of(1); // Uint8Array [ 1 ]
Int8Array.of("1", "2", "3"); // Int8Array [ 1, 2, 3 ]
Float32Array.of(1, 2, 3); // Float32Array [ 1, 2, 3 ]
Int16Array.of(undefined); // IntArray [ 0 ]
```

规范
--

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

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

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

参见
--

* `TypedArray.from()`
* `Array.of()`
TypedArray.prototype.forEach()
==============================

**`forEach()`** 方法对类型化数组的每个元素调用提供的函数。这个方法的算法和 `Array.prototype.forEach()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


```js
forEach(callbackFn)
forEach(callbackFn, thisArg)
```

### 参数

`callback`

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

`currentValue`

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

`index`

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

`array`

`forEach()`在其上调用的类型化数组


`thisArg`

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

### 返回值

`undefined`.

描述
--

`forEach`方法对类型化数组中的元素按升序调用提供的 `callback`函数。它不会对删除或者省略的下标调用，但是会对存在并且值为`undefined`的元素调用。

`callback` 以 **三个参数**调用：

* the **元素的值**
* the **元素下标**
* the **被遍历的类型化数组**

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

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

`forEach()`对每个数组元素执行一次`callback` 函数；不像 `every()` 和`some()`，它始终返回 `undefined`。

示例
--

### 记录类型化数组的内容

下面的代码为数组中的每个元素记录一行日志：


```js
function logArrayElements(element, index, array) {
  console.log("a[" + index + "] = " + element);
}

new Uint8Array([0, 1, 2, 3]).forEach(logArrayElements);
// 日志：
// a[0] = 0
// a[1] = 1
// a[2] = 2
// a[3] = 3
```

规范
--

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

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

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

另见
--

* `TypedArray.prototype.map()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.forEach()`
TypedArray.prototype.byteOffset
===============================

**`byteOffset`** 访问器属性表示类型化数组距离其`ArrayBuffer`起始位置的偏移（字节数）。

语法
--
```

typedarray.byteOffset
```

描述
--

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

示例
--

### 使用`byteOffset` 属性


```js
var buffer = new ArrayBuffer(8);

var uint8 = new Uint8Array(buffer);
uint8.byteOffset; // 0 (没有指定 oddfet)

var uint8 = new Uint8Array(buffer, 3);
uint8.byteOffset; // 3 (在构造 Uint8Array 时指定)
```

规范
--

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

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

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

另见
--

* JavaScript 类型化数组
* `TypedArray`
TypedArray.prototype.length
===========================

**`length`** 访问器属性表示类型化数组的长度（元素数）。

尝试一下
----

描述
--

`length` 是一个访问器属性，它的 set 访问器函数是`undefined`，意思是你只能够读取这个属性。它的值在*TypedArray*构造时建立，不能被修改。如果 *TypedArray* 没有指定`byteOffset` 或者 `length`，会返回所引用的`ArrayBuffer` 的`length`。*TypedArray* 是这里的 TypedArray 对象之一。

示例
--

### 使用`length` 属性


```js
var buffer = new ArrayBuffer(8);

var uint8 = new Uint8Array(buffer);
uint8.length; // 8 (符合 buffer 的 length)

var uint8 = new Uint8Array(buffer, 1, 5);
uint8.length; // 5 (在 Uint8Array 构造时指定)

var uint8 = new Uint8Array(buffer, 2);
uint8.length; // 6 (根据被构造的 Uint8Array 的 offset)
```

规范
--

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

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

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

另见
--

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

**`toLocaleString()`** 方法返回一个字符串，表示该类型化数组的元素。这些元素被转化为字符串并由一个区域设置指定的分隔符（例如逗号“,”）分隔。这个方法与 `Array.prototype.toLocaleString()` 拥有相同的算法。同时，由于类型化数组的元素都是数字，将每个元素转化为字符串的算法与 `Number.prototype.toLocaleString()` 是相同的。*类型化数组*需要是类型化数组类型中的一种类型。

语法
--


```js
toLocaleString()
toLocaleString(locales)
toLocaleString(locales, options)
```

### 参数

`locales` 和 `options` 参数用于自定义函数的行为，并让应用程序指定应该使用的格式约定的语言。在忽略 `locales` 和 `options` 参数的实现中，使用的语言环境和返回的字符串形式完全取决于实现。

 参见 `Intl.NumberFormat()` (en-US)
 构造函数，以了解这些参数的详细信息，以及如何使用它们。

### 返回值

一个字符串，表示该类型化数组内的元素。

示例
--

### 使用 toLocaleString


```js
const uint = new Uint32Array([2000, 500, 8123, 12, 4212]);

uint.toLocaleString();
// 如果在 de-DE 区域设置下运行
// "2.000,500,8.123,12,4.212"

uint.toLocaleString("en-US");
// "2,000,500,8,123,12,4,212"

uint.toLocaleString("ja-JP", { style: "currency", currency: "JPY" });
// "￥2,000,￥500,￥8,123,￥12,￥4,212"
```

规范
--

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

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

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

参见
--

* `Array.prototype.toLocaleString()`
* `Number.prototype.toLocaleString()`
TypedArray.prototype.join()
===========================

**`join()`** 方法将数组中所有元素连接为一个字符串。这个方法的算法和 `Array.prototype.join()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


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

### 参数

`separator`

可选。指定分隔每个元素的字符串。分隔符按需转换为字符串。如果没有，类型化数组的元素会以逗号 (",") 分隔。

### 返回值

所有元素连接后的字符串。

示例
--


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.join(); // '1,2,3'
uint8.join(" / "); // '1 / 2 / 3'
uint8.join(""); // '123'
```

规范
--

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

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

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

参见
--

* `core-js` 中 `TypedArray.prototype.join` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `TypedArray.prototype.toString()`
* `Array.prototype.join()`
* `String.prototype.split()`
TypedArray.prototype.values()
=============================

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

语法
--
```

arr.values()
```

### 返回值

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

示例
--

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


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.values();
// 你的浏览器必须支持 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.values();
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.values |

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

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

另见
--

* JavaScript 类型化数组
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype[@@iterator]()`
TypedArray.prototype.fill()
===========================

`fill() 方法将`类型化数组中的从起始索引到终止索引内的全部元素。这个方法的算法和 `Array.prototype.fill()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


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

### 参数

`value`

用来填充类型化数组元素的值。

`start`

可选参数。起始索引，默认值为 0。

`end`

可选参数。终止索引（填充范围不包含此索引），默认值为 `this.length`。

### 返回值

修改后的类型化数组。

描述
--

将被元素填充的区间是 [`start`, `end`)。

**`fill`** 方法接受三个参数 `value`，`start` 以及 `end`。`start` 和 `end` 参数是可选的，默认值分别为 `0` 和 `this.length`。

如果 `start` 参数是负值，它会被视为 `length+start`，其中 `length` 是类型化数组的长度。如果 `end` 参数是负值，它会被视为 `length+end`。

示例
--


```js
new Uint8Array([1, 2, 3]).fill(4); // Uint8Array [4, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1); // Uint8Array [1, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1, 2); // Uint8Array [1, 4, 3]
new Uint8Array([1, 2, 3]).fill(4, 1, 1); // Uint8Array [1, 2, 3]
new Uint8Array([1, 2, 3]).fill(4, -3, -2); // Uint8Array [4, 2, 3]
```

兼容实现
----

由于并没有一个名为 *TypedArray* 的全局变量，我们必须“按需添加”兼容实现。请配合`Array.prototype.fill()`的兼容实现使用以下的“兼容实现”


```js
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill
if (!Uint8Array.prototype.fill) {
  Uint8Array.prototype.fill = Array.prototype.fill;
}
```

规范
--

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

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

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

相关
--

* `Array.prototype.fill()`
TypedArray.prototype.filter()
=============================

**`filter()`** 创建新的类型化数组，含有所有通过了测试的元素，测试由提供的函数实现。这个方法的算法和 `Array.prototype.filter()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


```js
filter(callbackFn)
filter(callbackFn, thisArg)
```

### 参数

`callback`

测试类型化数组每个元素的函数，以参数 `(element, index, typedarray)`调用。如果返回 `true`则保留该元素，如果返回`false`则相反。

`thisArg 可选`

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

### 返回值

新的类型化数组，含有通过测试的元素

描述
--

`filter`方法对类型化数组中的元素调用提供的 `callback`函数，并且会为`callback`返回 true 的那些元素构造新的类型化数组。 `callback` 只对拥有值的类型化数组下标调用。它不会对未定义的，被删除的或者没有赋值的下标调用。没有传给`callback`的类型化数组的元素只是简单跳过，不会包含在新数组中。

`callback`以三个参数调用：

1. 元素的值
2. 元素下标
3. 被遍历的类型化数组对象

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

`filter()`不改变在其上调用的类型化数组。

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

示例
--

### 过滤所有较小的值

下面的示例使用了 `filter()` 来创建过滤后的类型化数组，小于 10 的元素都被移除了。


```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).filter(isBigEnough);
// Uint8Array [ 12, 130, 44 ]
```

### 使用箭头函数过滤类型化数组的元素

箭头函数 为相同测试提供了更短的语法。


```js
new Uint8Array([12, 5, 8, 130, 44]).filter((elem) => elem >= 10);
// Uint8Array [ 12, 130, 44 ]
```

规范
--

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

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

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

另见
--

* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.filter()`
TypedArray.prototype.lastIndexOf()
==================================

**`lastIndexOf()`** 方法返回在类型数组中可以找到给定元素的最后一个索引，如果不存在，则返回 -1。方法具有与 `Array.prototype.lastIndexOf()` 相同的算法。TypedArray 是这里的类型化数组类型之一。

语法
--


```js
lastIndexOf(searchElement)
lastIndexOf(searchElement, fromIndex)
```

### 参数

`searchElement`

需要在类型化数组中定位的元素

`fromIndex`

可选。反向搜索的起始下标。默认为数组的长度，即会搜索整个类型化数组。如果下标大于等于类型化数组长度，会搜索整个类型化数组。如果是负数，则被当做距离类型化数组尾部的偏移。注：如果提供的下标是负数，类型化数组仍然从后到前搜索。如果计算出来的下标小于 0，则会返回 -1，即不会搜索类型化数组。

### 返回值

数组中元素的最后一个下标；没有找到则返回 **-1** 。

描述
--

`lastIndexOf`使用严格相等 (en-US) （由 === 或三等号运算符使用的相同方法）比较`searchElement`和类型化数组的元素。

示例
--


```js
var uint8 = new Uint8Array([2, 5, 9, 2]);
uint8.lastIndexOf(2); // 3
uint8.lastIndexOf(7); // -1
uint8.lastIndexOf(2, 3); // 3
uint8.lastIndexOf(2, 2); // 0
uint8.lastIndexOf(2, -2); // 0
uint8.lastIndexOf(2, -1); // 3
```

规范
--

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

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

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

另见
--

* `TypedArray.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
TypedArray.prototype.set()
==========================

**`set()`** 方法用于从指定数组中读取值，并将其存储在类型化数组中。

语法
--


```js
set(array)
set(array, targetOffset)

set(typedarray)
set(typedarray, targetOffset)
```

### 参数

`array`

拷贝数据的源数组，源数组的所有值都会被复制到目标数组中，除非源数组的长度加上偏移量超过目标数组的长度，而在这种情况下会抛出异常。参数 array 是源数组，指定从哪里拷贝值。源数组中的所有值都会被拷贝到目标数组中去。如果源数组的长度加上偏移值 offset 的结果超过目标数组的长度，则会抛出异常错误。

`typedarray`

如果源数组是一个类型化数组（typed array），则源数组和目标数组可以共享同一个底层的`ArrayBuffer`；JavaScript 引擎会智能地将 buffer 的指定区段拷贝到目标区段中去。

`offset` 可选

偏移量参数 offset 指定从什么地方开始使用源数组 `array` 的值进行写入操作。如果忽略该参数，则默认为 0（也就是说，从目标数组的下标为 0 处开始，使用源数组 `array` 的值覆盖重写）。

### 异常

`RangeError`

如果指定的偏移量超出了类型化数组的范围，则该异常会被抛出。

示例
--

### 使用 `set()`


```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);

uint8.set([1, 2, 3], 3);

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

规范
--

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

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

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

另见
--

* JavaScript typed arrays
* `TypedArray`
* `ArrayBuffer`
TypedArray.prototype.byteLength
===============================

**`byteLength`** 访问器属性表示类型化数组的长度（字节数）。

语法
--
```

typedarray.byteLength
```

描述
--

`byteLength` 是一个访问器属性，它的 set 访问器函数是 `undefined`，意思是你只能够读取这个属性。它的值在 *TypedArray* 构造时建立，不能被修改。如果 *TypedArray* 没有指定 `byteOffset` 或者 `length`，会返回所引用的 `ArrayBuffer` 的 `length`。*TypedArray* 是这里的 TypedArray 对象之一。

示例
--

### 使用 `byteLength` 属性


```js
var buffer = new ArrayBuffer(8);

var uint8 = new Uint8Array(buffer);
uint8.byteLength; // 8 (符合 buffer 的 byteLength)

var uint8 = new Uint8Array(buffer, 1, 5);
uint8.byteLength; // 5 (在 Uint8Array 构造时指定)

var uint8 = new Uint8Array(buffer, 2);
uint8.byteLength; // 6 (根据被构造的 Uint8Array 的 offset)
```

规范
--

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

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

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

另见
--

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

**`reduceRight()`** 在累加器和类型化数组的每个元素上（从右到左）调用函数，使其归约为单一的值。这个方法的算法和 `Array.prototype.reduceRight()` 相同。*TypedArray* 是这里的类型化数组类型之一。

语法
--


```js
reduceRight(callbackFn)
reduceRight(callbackFn, initialValue)
```

### 参数

`callback`

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

`previousValue`

回调函数上一次调用所返回的值，或者是提供的 `initialValue`。

`currentValue`

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

`index`

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

`array`

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


`initialValue`

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

### 返回值

由归约返回的结果。

描述
--

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

`reduceRight`回调函数的调用是这样：


```js
typedarray.reduceRight(
  function (previousValue, currentValue, index, typedarray) {
    // ...
  },
);
```


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

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

示例
--

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


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

规范
--

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

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

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

另见
--

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

**`slice()`** 方法将一个类型化数组的一部分浅拷贝到一个新的类型化数组对象中并返回。此方法采用与 `Array.prototype.slice()` 相同的算法。*TypedArray* 指类型化数组的类型中的一员。

尝试一下
----

语法
--


```js
slice()
slice(start)
slice(start, end)
```

参数
--

`begin` 可选

从 0 开始的索引位置。可以使用负值索引，表示从数组末尾往前的偏移量。`slice(-2)` 表示提取数组中的末尾两个元素。如果没有设定起始位置，则将从开始位置开始截取。

`end` 可选

从 0 开始到尾元素前的索引值。 `slice` 取出的元素到此位置之前，不包含该位置。例，`slice(1,4)` 表示读取第 2 个元素到第 4 个元素 (元素索引：1, 2, 3)。可以使用负值索引，表示从数组末尾往前的偏移量。 `slice(2,-1)` 表示取出数组中的第 3 个到倒数第 2 个元素。如果没有设定结束位置，则将从开始位置截取到序列尾部。(默认值为`typedarray.length`).

### 返回值

包含取出元素的新 typed array。

描述
--

`slice`方法并不会改变原数组的内容，它只是返回从原数组中取出的元素的浅复制集合。

如果一个新元素被添加到它们任何一个数组中去，另外一个数组不会受到影响。

示例
--

### 返回已存在类型数组的一部分片段


```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.slice(1); // Uint8Array [ 2, 3 ]
uint8.slice(2); // Uint8Array [ 3 ]
uint8.slice(-2); // Uint8Array [ 2, 3 ]
uint8.slice(0, 1); // Uint8Array [ 1 ]
```

规范
--

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

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

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

参见
--

* `core-js` 中 `TypedArray.prototype.slice` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `Array.prototype.slice()`
* `String.prototype.slice()`