# 数组

¥Array

泛型类型的可随机访问的值序列。

¥A randomly accessible sequence of values of a generic type.

Array API 与 JavaScript 的 (MDN (opens new window)) 非常相似，但显着的区别是，如果 T 是不可为空的引用类型，则必须确保不存在 null 值。示例：

¥The Array API is very similar to JavaScript's (MDN (opens new window)), with the notable difference that one must make sure that there are no null values if T is a non-nullable reference type. Example:

var arr = new Array<string>(10)
// arr[0]; // would error 😢
for (let i = 0; i < arr.length; ++i) {
  arr[i] = ""
}
arr[0]; // now it works 😊

# 构造函数

¥Constructor

```
new Array<T>(capacity?: i32)
```
构造一个新数组。

¥Constructs a new array.

# 静态成员

¥Static members

```
function isArray(value: U): bool
```
测试值是否为数组。

¥Tests if a value is an array.

# 实例成员

¥Instance members

# 字段

¥Fields

```
var length: i32
```
该数组的长度。将长度设置为大于内部容量的值将自动增长数组。

¥The length of this array. Setting the length to a value larger than internal capacity will automatically grow the array.

# 方法

¥Methods

```
function concat(other: Array<T>): Array<T>
```
按此顺序将这个数组和另一个数组的值连接到一个新数组。

¥Concatenates the values of this and the other array to a new array, in this order.
```
function copyWithin(target: i32, start: i32, end?: i32): this
```
将数组值的区域复制到从目标位置开始的相应值上。

¥Copies a region of an array's values over the respective values starting at the target location.
```
function every(fn: (value: T, index: i32, self: Array<T>) => bool): bool
```
使用数组的每个值调用指定的函数，直到找到函数返回 false 的第一个值。如果所有函数都返回 true 或数组为空，则返回 true，否则返回 false。

¥Calls the specified function with every value of the array until it finds the first value for which the function returns false. Returns true if all functions returned true or the array is empty, otherwise false.
```
function fill(value: T, start?: i32, end?: i32): this
```
将数组中从 start（含）到 end（不含）的值替换为指定值，返回该数组。

¥Replaces the values of the array from start inclusive to end exclusive in place with the specified value, returning the array.
```
function filter(fn: (value: T, index: i32, self: Array<T>) => bool): Array<T>
```
使用数组的每个值调用指定的函数，返回一个新数组，其中包含函数返回 true 的所有值。

¥Calls the specified function with every value of the array, returning a new array with all values for which the function returned true.
```
function findIndex(fn: (value: T, index: i32, self: Array<T>) => bool): i32
```
使用数组的每个值调用指定的函数，直到找到该函数返回 true 的第一个值，并返回其索引。如果情况并非如此，则返回 -1。

¥Calls the specified function with every value of the array until it finds the first value for which the function returns true, returning its index. Returns -1 if that's never the case.
```
function findLastIndex(fn: (value: T, index: i32, self: Array<T>) => bool): i32;
```
使用从末尾开始的数组的每个值调用指定的函数，直到找到该函数返回 true 的第一个值，并返回其索引。如果情况并非如此，则返回 -1。

¥Calls the specified function with every value of the array starting at the end until it finds the first value for which the function returns true, returning its index. Returns -1 if that's never the case.
```
function flat(): valueof<T>[]
```
将数组的数组展平为一维数组。null 条目将被忽略。

¥Flattens an array of arrays to a one-dimensional array. null entries are ignored.
```
function forEach(fn: (value: T, index: i32, self: Array<T>) => void): void
```
使用数组的每个值调用指定的函数。

¥Calls the specified function with every value of the array.
```
function includes(value: T, fromIndex?: i32): bool
```
测试数组是否包含指定值，可以选择提供起始索引。

¥Tests if the array includes the specified value, optionally providing a starting index.
```
function indexOf(value: T, fromIndex?: i32): i32
```
获取可以在数组中找到指定值的第一个索引。如果未找到则返回 -1。

¥Gets the first index where the specified value can be found in the array. Returns -1 if not found.
```
function join(separator?: string): string
```
将数组的所有值连接到一个字符串，并用指定的分隔符分隔（默认值：,）。

¥Concatenates all values of the array to a string, separated by the specified separator (default: ,).
```
function lastIndexOf(value: T, fromIndex?: i32): i32
```
获取可以在数组中找到指定值的最后一个索引。如果未找到则返回 -1。

¥Gets the last index where the specified value can be found in the array. Returns -1 if not found.
```
function map(fn: (value: T, index: i32, self: Array<T>) => U): Array
```
使用数组的每个值调用指定的函数，返回函数返回值的新数组。

¥Calls the specified function with every value of the array, returning a new array of the function's return values.
```
function pop(): T
```
删除并返回数组的最后一个值。修改 Array#length。如果数组为空，则抛出 RangeError。

¥Removes and returns the last value of the array. Modifies Array#length. Throws a RangeError if the array is empty.
```
function push(value: T): i32
```
向数组末尾添加一个值并返回数组的新长度。修改 Array#length。

¥Adds one more value to the end of the array and returns the Array's new length. Modifies Array#length.
```
function reduce(
 fn: (accumValue: U, currentValue: T, index: i32, self: Array<T>) => U,
 initialValue: U
): U
```
使用数组的每个值调用指定的缩减器函数，从而产生单个返回值。各个前一个 reducer 函数的返回值被记住在 accumValue 中，从 initialValue 开始，成为该过程中的最终返回值。

¥Calls the specified reducer function with each value of the array, resulting in a single return value. The respective previous reducer function's return value is remembered in accumValue, starting with initialValue, becoming the final return value in the process.
```
function reduceRight(
 fn: (accumValue: U, currentValue: T, index: i32, self: Array<T>) => U,
 initialValue: U
): U
```
使用数组的每个值从右到左调用指定的缩减器函数，从而产生单个返回值。请参阅 Array#reduce 了解 reducer 函数的签名。

¥Calls the specified reducer function with each value of the array, from right to left, resulting in a single return value. See Array#reduce for the reducer function's signature.
```
function reverse(): this
```
就地反转数组的值，在返回数组之前修改数组。

¥Reverses an array's values in place, modifying the array before returning it.
```
function shift(): T
```
删除并返回数组的第一个值。修改 Array#length。

¥Removes and returns the first value of the array. Modifies Array#length.
```
function slice(start?: i32, end?: i32): Array<T>
```
返回从 begin（含）到 end（不含）的数组值的浅表副本，作为新数组。如果省略，end 默认为数组末尾。

¥Returns a shallow copy of the array's values from begin inclusive to end exclusive, as a new array. If omitted, end defaults to the end of the array.
```
function some(fn: (value: T, index: i32, self: Array<T>) => bool): bool
```
使用数组的每个值调用指定的函数，直到找到函数返回 true 的第一个值，然后返回 true。否则或如果数组为空，则返回 false。

¥Calls the specified function with every value of the array until it finds the first value for which the function returns true, returning true. Returns false otherwise or if the array is empty.
```
function sort(fn?: (a: T, b: T) => i32): this
```
使用指定的比较器函数对数组的值进行就地排序，并在返回数组之前修改数组。比较器返回负值表示 a < b，返回正值表示 a > b 和 0 表示两者相等。与 JavaScript 中执行到字符串的隐式转换不同，比较器默认比较两个 T 类型的值。

¥Sorts the values of the array in place, using the specified comparator function, modifying the array before returning it. The comparator returning a negative value means a < b, a positive value means a > b and 0 means that both are equal. Unlike in JavaScript, where an implicit conversion to strings is performed, the comparator defaults to compare two values of type T.
```
function splice(start: i32, deleteCount?: i32): Array<T>
```
从数组中删除 deleteCount（默认为所有剩余）值，从索引 start 开始，就地修改数组，返回删除的值。

¥Removes deleteCount (defaults to all remaining) values from the array, starting at index start, modifying the array in place, returning the removed values.
```
function toString(): string
```
返回 Array#join() 的结果。

¥Returns the result of Array#join().
```
function unshift(value: T): i32
```
在数组的开头添加一个值并返回数组的新长度。修改 Array#length。

¥Adds one more value to the start of the array and returns the Array's new length. Modifies Array#length.

← 全局变量 ArrayBuffer →