docs: update array methods

Author: tsejx

docs/standard-built-in-objects/indexed-collections/array/array.md

@@ -12,36 +12,57 @@ order: 3
 
 # Array.from()
 
-`Array.from()` 方法用于将一个类数组对象或可迭代对象转换成一个新的数组实例。
+⭐️ `ES2015(ES6)新特性`
 
-该方法为 ECMAScript 2015 新添加的数组方法。
+`Array.from()` 方法用于将一个类数组对象或可迭代对象转换成一个新的数组实例。
 
 ## 语法
 
+语法：
+
 ```js
-Array.from(typedArr [, fn [, arg]])
+Array.from(arrayLike [, mapfn [, thisArg]])
+```
+
+类型声明：
+
+```ts
+interface ArrayLike<T> {
+  readonly length: number;
+  readonly [n: number]: T;
+}
+
+interface ArrayConstructor {
+  from<T>(arrayLike: ArrayLike<T>): T[];
+
+  from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+}
 ```
 
-| 参数       | 说明                                                           | 类型        |
-| ---------- | -------------------------------------------------------------- | ----------- |
-| `typedArr` | 想要转换成数组的伪数组对象或可迭代对象                         | typed array |
-| `fn`       | （可选）如果指定了该参数，新数组中的每个元素会执行该回调函数。 | function    |
-| `arg`      | （可选）执行回调函数 `mapFn` 时 `this` 对象                    | object      |
+参数说明：
+
+| 参数      | 说明                                                           | 类型        |
+| :-------- | :------------------------------------------------------------- | :---------- |
+| arrayLike | 想要转换成数组的伪数组对象或可迭代对象                         | typed array |
+| mapfn     | （可选）如果指定了该参数，新数组中的每个元素会执行该回调函数。 | function    |
+| thisArg   | （可选）执行回调函数 `mapFn` 时 `this` 对象                    | object      |
 
-**返回值：** 一个新的数组实例。
+返回值：
 
-## 描述
+返回一个新的数组实例。
+
+## 方法说明
 
 - 具备以下两种条件的的对象可以通过 `Array.from()` 方法转换成真正的数组：
   - 类数组对象：即拥有 `length` 属性和若干索引属性的任意对象
   - 可迭代对象：即部署了 Iterator 接口的对象，可以获取对象中的元素，如 `Map` 和 `Set` 等
-- `Array.from()` 方法有一个可选参数 `fn`，让你可以在最后生成的数组上再执行一次 `Array.prototype.map` 方法后再返回。也就是说 `Array.from(typedArr, fn, arg)` 就相当于 `Array.from(typedArr).map(fn, arg)` ，除非创建的不是可用的中间数组。 这对一些数组的子类，如对[类型化数组](../../typed-array-objects/typed-array-objects)来说很重要，因为中间数组的值在调用 `map()` 时需要是适当的类型。
+- `Array.from()` 方法有一个可选参数 `mapfn`，让你可以在最后生成的数组上再执行一次 `Array.prototype.map` 方法后再返回。也就是说 `Array.from(arrayLike, mapfn, thisArg)` 就相当于 `Array.from(arrayLike).map(mapfn, thisArg)` ，除非创建的不是可用的中间数组。 这对一些数组的子类，如对[类型化数组](../../typed-array-objects/typed-array-objects)来说很重要，因为中间数组的值在调用 `map()` 时需要是适当的类型。
 - `from()` 的 `length` 属性为 1 ，即 `Array.from.length === 1`。
 - 在 ES2015 中， `Class` 语法允许我们为内置类型（比如 `Array`）和自定义类新建子类（比如叫 `SubArray`）。这些子类也会继承父类的静态方法，比如 `SubArray.from()`，调用该方法后会返回子类 `SubArray` 的一个实例，而不是 `Array` 的实例。
 
-## 示例
+## 代码示例
 
-### 代码示例
+### 基本用法
 
 ```js
 const bar = ['a', 'b', 'c'];
@@ -114,9 +135,9 @@ const m = [1, 2, 2],
 console.log(combine(m, n)); // [1, 2, 3]
 ```
 
----
-
-**参考资料：**
+## 参考资料
 
+- [MDN: Array.from](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/from)
+- [TypeScript: lib.es2015.core.d.ts](https://github.com/microsoft/TypeScript/blob/main/lib/lib.es2015.core.d.ts)
 - [Array.from 的妙用](https://segmentfault.com/a/1190000004450221)
 - [Array.from 的性能测试](https://jsperf.com/constarray/4)

docs/standard-built-in-objects/indexed-collections/array/constructor/from.md

@@ -16,56 +16,75 @@ order: 4
 
 ### 语法
 
+语法：
+
 ```js
-Array.isArray( value )
+Array.isArray(arg);
 ```
 
-| 参数    | 说明         | 类型 |
-| ------- | ------------ | ---- |
-| `value` | 需要检测的值 | any  |
+类型声明：
+
+```ts
+interface ArrayConstructor {
+  isArray(arg: any): arg is any[];
+}
+
+declare var Array: ArrayConstructor;
+```
+
+参数说明：
+
+| 参数 | 说明         | 类型 |
+| :--- | :----------- | :--- |
+| arg  | 需要检测的值 | any  |
+
+返回值：
 
-**返回值：** 如果对象是 `Array` 的实例，则返回 `true` ；否则为 `false`。
+如果对象是 `Array` 的实例，则返回 `true` ；否则为 `false`。
 
-### 示例
+### 代码示例
 
 下面的函数调用都返回 `true`
 
 ```js
-Array.isArray([])
+Array.isArray([]);
 
-Array.isArray([1])
+Array.isArray([1]);
 
-Array.isArray(new Array())
+Array.isArray(new Array());
 
-Array.isArray(Array.prototype)
+Array.isArray(Array.prototype);
 ```
 
 鲜为人知的事实：其实 `Array.prototype` 也是一个数组。
 
 ```js
-Array.isArray(Array.prototype)
+Array.isArray(Array.prototype);
 ```
 
 下面的函数调用都返回 `false`。
 
 ```js
-Array.isArray()
+Array.isArray();
 
-Array.isArray({})
+Array.isArray({});
 
-Array.isArray(null)
+Array.isArray(null);
 
-Array.isArray(undefined)
+Array.isArray(undefined);
 
-Array.isArray(17)
+Array.isArray(17);
 
-Array.isArray('Array')
+Array.isArray('Array');
 
-Array.isArray(true)
+Array.isArray(true);
 
-Array.isArray(false)
+Array.isArray(false);
 
-Array.isArray({ __proto__: Array.prototype })
+Array.isArray({ __proto__: Array.prototype });
 ```
 
+## 参考资料
 
+- [MDN: Array.isArry](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
+- [TypeScript: lib.es5.d.ts](https://github.com/microsoft/TypeScript/blob/main/lib/lib.es5.d.ts)

docs/standard-built-in-objects/indexed-collections/array/constructor/isArray.md

@@ -16,17 +16,31 @@ order: 5
 
 ### 语法
 
+语法：
+
 ```js
 Array.of( ele0[, ele1[, ...[, eleN ] ] ] )
 ```
 
-| 参数       | 说明                                           | 类型 |
-| ---------- | ---------------------------------------------- | ---- |
-| `elementN` | 任意个参数，将按**顺序**成为返回数组中的元素。 | any  |
+类型声明：
+
+```ts
+interface ArrayConstructor {
+  of<T>(...items: T[]): T[];
+}
+```
+
+参数说明：
 
-**返回值：**新的 `Array` 实例。
+| 参数     | 说明                                             | 类型 |
+| :------- | :----------------------------------------------- | :--- |
+| elementN | 任意个参数，将按 **顺序** 成为返回数组中的元素。 | any  |
 
-### 描述
+返回值：
+
+新的 `Array` 实例。
+
+### 方法说明
 
 `Array.of()` 和 `Array` 构造函数之间的区别在于处理整数参数。
 
@@ -41,10 +55,15 @@ Array(7); // [ , , , , , , ]
 Array(1, 2, 3); // [1, 2, 3]
 ```
 
-### 示例
+### 代码示例
 
 ```js
 Array.of(1); // [1]
 Array.of(1, 2, 3); // [1, 2, 3]
 Array.of(undefined); // [undefined]
 ```
+
+## 参考资料
+
+- [MDN: Array.of](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+- [TypeScript: lib.es2015.core.d.ts](https://github.com/microsoft/TypeScript/blob/main/lib/lib.es2015.core.d.ts)

docs/standard-built-in-objects/indexed-collections/array/constructor/of.md

@@ -16,18 +16,41 @@ order: 10
 
 ## 语法
 
+语法：
+
 ```js
 const new_array = old_array.concat( item1[, itemN ] )
 ```
 
-| 参数    | 描述                                         | 类型 |
-| ------- | -------------------------------------------- | ---- |
-| `item1` | 添加到当前数组末尾处的数据项                 | any  |
-| `itemN` | 要添加到当前数组末尾处的其他项，可以有多个。 | any  |
+类型声明：
+
+```ts
+interface ConcatArray<T> {
+  readonly length: number;
+  readonly [n: number]: T;
+  join(separator?: string): string;
+  slice(start?: number, end?: number): T[];
+}
+
+interface Array<T> {
+  concat(...items: ConcatArray<T>[]): T[];
+
+  concat(...items: (T | ConcatArray<T>)[]): T[];
+}
+```
+
+参数说明：
+
+| 参数  | 描述                                         | 类型 |
+| :---- | :------------------------------------------- | :--- |
+| item1 | 添加到当前数组末尾处的数据项                 | any  |
+| itemN | 要添加到当前数组末尾处的其他项，可以有多个。 | any  |
+
+返回值：
 
-**返回值：** 新的 `Array` 实例。
+返回合并后新的 `Array` 实例。
 
-## 描述
+## 方法说明
 
 `concat` 方法创建一个新的数组，它由被调用的对象中的元素组成，每个参数的顺序依次是该参数的元素（如果参数是数组）或参数本身（如果参数不是数组）。它不会递归到嵌套数组参数中。
 
@@ -38,7 +61,7 @@ const new_array = old_array.concat( item1[, itemN ] )
 
 **注意**：数组/值在连接时保持不变。此外，对于新数组的任何操作（仅当元素不是对象引用时）都不会对原始数组产生影响，反之亦然。
 
-## 示例
+## 代码示例
 
 ### 连接两个数组
 
@@ -48,7 +71,8 @@ const new_array = old_array.concat( item1[, itemN ] )
 const alpha = ['a', 'b', 'c'];
 const numeric = [1, 2, 3];
 
-alpha.concat(numeric); // Outputs: ['a', 'b', 'c', 1, 2, 3]
+alpha.concat(numeric);
+// Outputs: ['a', 'b', 'c', 1, 2, 3]
 ```
 
 ### 连接三个数组
@@ -62,7 +86,8 @@ const num1 = [1, 2, 3],
 
 const nums = num1.concat(num2, num3);
 
-console.log(nums); // Outputs: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+console.log(nums);
+// Outputs: [1, 2, 3, 4, 5, 6, 7, 8, 9]
 ```
 
 ### 将值连接到数组
@@ -74,7 +99,8 @@ var alpha = ['a', 'b', 'c'];
 
 var alphaNumeric = alpha.concat(1, [2, 3]);
 
-console.log(alphaNumeric); // Outputs: ['a', 'b', 'c', 1, 2, 3]
+console.log(alphaNumeric);
+// Outputs: ['a', 'b', 'c', 1, 2, 3]
 ```
 
 ### 合并嵌套数组
@@ -87,20 +113,29 @@ var num2 = [2, [3]];
 
 var nums = num1.concat(num2);
 
-console.log(nums); // Outputs: [[1], 2, [3]]
+console.log(nums);
+// Outputs: [[1], 2, [3]]
 
 // modify the first element of num1
 num1[0].push(4);
 
-console.log(nums); // Outputs: [[1, 4], 2, [3]]
+console.log(nums);
+// Outputs: [[1, 4], 2, [3]]
 ```
 
 ### 将对象合并为数组
 
 ```js
 var newArray = Array.prototype.concat.call({ a: 1 }, { b: 2 });
 
-console.log(newArray); // [{ a: 1 }, { b: 2 }]
+console.log(newArray);
+// [{ a: 1 }, { b: 2 }]
 
-console.log(newArray[0].a); // 1
+console.log(newArray[0].a);
+// 1
 ```
+
+## 参考资料
+
+- [MDN: Array.prototype.concat](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)
+- [TypeScript: lib.es5.d.ts](https://github.com/microsoft/TypeScript/blob/main/lib/lib.es5.d.ts)

docs/standard-built-in-objects/indexed-collections/array/prototype/accessor-methods/concat.md

@@ -0,0 +1,44 @@
+---
+nav:
+  title: 内置对象
+  order: 2
+group:
+  title: Array
+  path: /indexed-collections/array/
+  order: 11
+title: Array.prototype.copyWithin
+order: 18
+---
+
+# Array.prototype.copyWithin()
+
+`Array.prototype.copyWithin()` 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
+
+## 语法
+
+语法：
+
+```js
+arr.copyWithin( target [, start [, end]]);
+```
+
+类型声明：
+
+```ts
+interface Array<T> {
+  copyWithin(target: number, start: number, end?: number): this;
+}
+```
+
+参数说明：
+
+| 参数   | 说明                                                                                                                                                                                                                   | 类型   |
+| :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----- |
+| target | 0 为基底的索引，复制序列到该位置。如果是负数，`target` 将从末尾开始计算。如果 `target` 大于等于数组长度，将不会发生拷贝。如果 `target` 在 `start` 之后，复制的序列将被修改以复合数组长度                               | number |
+| start  | 0 为基底的索引，开始复制元素的起始位置。如果是负数，`start` 将从末尾开始计算。如果 `start` 被忽略，`copyWithin` 将会从 0 开始复制。                                                                                    | number |
+| end    | 0 为基底的索引，开始复制元素的结束位置。`copyWithin` 将会拷贝到该位置，但不包括 `end` 这个位置的元素。如果是负数，`end` 将从末尾开始计算。如果 `end` 被忽略，`copyWithin` 方法将会一直复制至数组结尾（默认为数组长度） | number |
+
+## 参考资料
+
+- [MDN: Array.prototype.copyWithin](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin)
+- [TypeScript: lib.es2015.core.d.ts](https://github.com/microsoft/TypeScript/blob/main/lib/lib.es2015.core.d.ts)