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

**`push()`** 方法會添加一個或多個元素至陣列的末端，並且回傳陣列的新長度。

嘗試一下
----

語法
--


```js
arr.push(element1[, ...[, elementN]])
```

### 參數

`elementN`

欲添加至陣列末端的元素。

### 回傳值

呼叫此方法之物件的新 `length` 屬性值。

描述
--

`push` 方法會將一或多個值加入至一個陣列中。

`push` 方法被刻意設計為具通用性；此方法可以藉由 `call()` 或 `apply()` 應用於類似陣列的物件上。`push` 方法憑借著物件的 `length` 屬性來判斷從何處開始插入給定的值。如果 `length` 屬性無法被轉為數字，則索引值會使用 0。這包括了 `length` 可能不存在的狀況，在這個情況下 `length` 屬性也將被建立於物件中。

唯一的原生類陣列（array-like）物件為字串，但他們不適合用於此方法，因為字串是不可變的（immutable）。

範例
--

### 將複數個元素添加至陣列

以下的程式碼會建立含有兩個元素的陣列 `sports`，接著再增加兩個元素至陣列中。新的長度以變數 `total` 表示。


```js
var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");

console.log(sports); // ['soccer', 'baseball', 'football', 'swimming']
console.log(total); // 4
```

### 合併兩個陣列

這個範例使用 `apply()` 自第二個陣列中增加所有的元素至第一個陣列。

如果第二個陣列（範例中的 `moreVegs`）非常大，就不要使用這個方法。因為一個函式能取得的參數之最大數量是受到實作限制的。詳細請參閱 `apply()`。


```js
var vegetables = ["parsnip", "potato"];
var moreVegs = ["celery", "beetroot"];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']
```

### 以類陣列（array-like）的方式操作物件

正如上面所提到的，`push` 被刻意設計為具通用性，我們可以善用這個優勢來處理物件。`Array.prototype.push` 可以在物件上運作良好，如本範例所示。請注意，我們不會建立一個陣列來儲存收集到的物件。相反地，我們將物件集合（collection）儲存於物件自己身上，並使用 `call` 來呼叫`Array.prototype.push` 使其認為我們正在處理一個陣列，讓方法可以繼續運作。感謝 JavaScript 允許我們使用這個方式去執行上下文。


```js
var obj = {
  length: 0,

  addElem: function addElem(elem) {
    // obj.length is automatically incremented
    // every time an element is added.
    [].push.call(this, elem);
  },
};

// Let's add some empty objects just to illustrate.
obj.addElem({});
obj.addElem({});
console.log(obj.length);
// → 2
```


請注意雖然 `obj` 不是一個陣列，但 `push` 方法成功增加了 `obj` 的 `length` 屬性，就像我們在處理一個真正的陣列一樣。

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
Array.prototype.shift()
=======================

**`shift()`** 方法會移除並回傳陣列的**第一個**元素。此方法會改變陣列的長度。

嘗試一下
----

語法
--


```js
arr.shift()
```

### 回傳值

自陣列中移除的元素；若陣列為空，則為 `undefined` (en-US)。

描述
--

`shift` 方法會移除並回傳陣列中索引值為零之元素（即第一個元素），並將隨後的其他索引值減一。假如 `length` 屬性值為 0，則會回傳 `undefined` (en-US)。

`shift` 方法被刻意設計為具通用性；此方法可以藉由 called 或 applied 應用於類似陣列的物件上。若欲應用此方法的物件不包含代表一系列啟始為零之數字屬性序列長度的 `length` 屬性，可能是不具任何意義的行為。

範例
--

### 自陣列中移除一個元素

以下的程式碼會印出 `myFish` 陣列在移除第一個元素之前跟之後的內容，也印出了被移除的元素：


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

console.log("myFish before:", JSON.stringify(myFish));
// myFish before: ['angel', 'clown', 'mandarin', 'surgeon']

var shifted = myFish.shift();

console.log("myFish after:", myFish);
// myFish after: ['clown', 'mandarin', 'surgeon']

console.log("Removed this element:", shifted);
// Removed this element: angel
```

### 於 while 迴圈中使用 shift() 方法

`shift()` 方法常被用在 while 迴圈中的條件判斷。在下面的例子，每一次迭代都將會自陣列中移除下一個元素，直到陣列空了為止：


```js
var names = ["Andrew", "Edward", "Paul", "Chris", "John"];

while ((i = names.shift()) !== undefined) {
  console.log(i);
}
// Andrew, Edward, Paul, Chris, John
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
Array.prototype.pop()
=====================

**`pop()`** 方法會移除並回傳陣列的**最後一個**元素。此方法會改變陣列的長度。

嘗試一下
----

語法
--
```

arr.pop()
```

### 回傳值

自陣列中移除的元素；若陣列為空，則為 `undefined` (en-US)。

描述
--

`pop` 方法會移除陣列中的最後一個元素，並將該值回傳給呼叫者。

`pop` 方法被刻意設計為具通用性；此方法可以藉由 called 或 applied 應用於類似陣列的物件上。若欲應用此方法的物件不包含代表一系列啟始為零之數字屬性序列長度的 `length` 屬性，可能是不具任何意義的行為。

如果於空陣列呼叫 `pop()`，將會回傳 `undefined` (en-US)。

範例
--

### 移除陣列的最後一個元素

下面的程式碼為一個包含四個元素的 `myFish` 陣列，接著移除此陣列的最後一個元素。


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];

var popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ]

console.log(popped); // 'sturgeon'
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Array.isArray()
===============

**`Array.isArray()`** 函式會檢查傳入的值是否為一個 `Array`。


```js
Array.isArray([1, 2, 3]); // true
Array.isArray({ foo: 123 }); // false
Array.isArray("foobar"); // false
Array.isArray(undefined); // false
```

語法
--


```js
Array.isArray(obj)
```

### 參數

`obj`

要檢查的物件。

### 回傳值

若物件為 `Array` 回傳 `true`；否則回傳 `false`。

描述
--

檢查傳入的物件是否為陣列（`Array`），如果是便回傳 `true`，否則回傳 `false`。

更多細節請參考 「Determining with absolute accuracy whether or not a JavaScript object is an array」。

範例
--


```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({ \_\_proto\_\_: Array.prototype });
```

### `instanceof` vs `isArray`

當檢查 `Array` 實例時，`Array.isArray` 相較於 `instanceof` 更加推薦，因為它可以穿透 `iframes`。


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

// 正確地檢查陣列型態
Array.isArray(arr); // true
// 有害地，因為它不能在 iframes 之間正常運作
arr instanceof Array; // false
```

Polyfill
--------

如果 `Array.isArray()` 不存在於你的環境，在其他程式碼前執行下列程式碼可建置 `Array.isArray()`。


```js
if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
}
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array`
Array.prototype.entries()
=========================

**`entries()`** 方法會回傳一個包含陣列中每一個索引之鍵值對（key/value pairs）的新陣列迭代器（**`Array Iterator`**）物件。

嘗試一下
----

語法
--


```js
entries()
```

### 回傳值

一個新的 `Array` 迭代器物件。

範例
--

### 使用 for...of 進行迭代


```js
var a = ["a", "b", "c"];
var iterator = a.entries();

for (let e of iterator) {
  console.log(e);
}
// [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.

參見
--

* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype.forEach()` (en-US)
* `Array.prototype.every()` (en-US)
* `Array.prototype.some()` (en-US)
* for...of (en-US)
* 迭代協議
Array.prototype[@@iterator]()
=============================

**`@@iterator`** 屬性的初始值與 `values()` 屬性的初始值為相同的的函式物件。

語法
--
```

arr[Symbol.iterator]()
```

### 回傳值

陣列的**迭代器**（iterator）函式，預設與 `values()` 函式相同。

範例
--

### 使用 `for...of` 迴圈進行迭代


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
// your browser must support for..of loop
// and let-scoped variables in for loops
for (let letter of eArr) {
  console.log(letter);
}
```

### 另一種迭代方式


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@iterator |

瀏覽器相容性
------

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

參見
--

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()` (en-US)
* `Array.prototype.every()` (en-US)
* `Array.prototype.some()` (en-US)
* `Array.prototype.values()`
Array.of()
==========

**`Array.of()`** 方法會由引數（arguments）的數量來建立一個新的 `Array` 實體，而不管引數的數量或類型為何。

**`Array.of()`** 與 **`Array`** 建構式之間的不同在於如何處理整數引數：**`Array.of(7)`** 會建立一個擁有單個元素—`7`—的陣列，而 **`Array(7)`** 會建立一個 `length` 屬性值為 7 的空陣列（\*\*註：\*\*這意味著這個陣列有 7 個空缺欄位（empty slots），而非 7 個值為 `undefined` 的欄位）。

嘗試一下
----

語法
--


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

### 參數

`elementN`

要用來成為新建立之陣列的元素。

### 回傳值

一個新的 `Array` 實體。

描述
--

此函式是 ECMAScript 2015 標準的一部分。更多資訊可參考 `Array.of` and `Array.from` proposal 以及 `Array.of` polyfill。

範例
--

### 使用 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 }
```


When the `this` value is not a constructor, a plain `Array` object is returned.


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

Polyfill
--------

若所有執行環境沒有原生支援，可以在其他程式之前先執行以下程式碼來建立 `Array.of()`。


```js
if (!Array.of) {
  Array.of = function () {
    return Array.prototype.slice.call(arguments);
  };
}
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* Polyfill of `Array.of` in `core-js`
* `Array()` (en-US)
* `Array.from()`
* `TypedArray.of()` (en-US)
Array.prototype.flat()
======================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
**實驗性質:** **這是一個實驗中的功能 (en-US)**  
此功能在某些瀏覽器尚在開發中，請參考兼容表格以得到不同瀏覽器用的前輟。

**`flat()`** 函數以遞迴方式將特定深度的子陣列重新串接成為一新的陣列

嘗試一下
----

語法
--


```js
var newArray = arr.flat([depth]);
```

### 參數

`depth` 選擇性

指定巢狀陣列展開的深度。預設為 1。

### 回傳值

函數將會回傳一個由原先陣列的子陣列串接而成的新陣列。

範例
--

### 展開巢狀陣列


```js
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
```

### 當遭遇空元素時

`flat()` 函數會自動清除陣列中空的元素


```js
var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]
```

替代方案
----

### `reduce` 與 `concat`


```js
var arr1 = [1, 2, [3, 4]];
arr1.flat();

//展開單層陣列
arr1.reduce((acc, val) => acc.concat(val), []); // [1, 2, 3, 4]
```



```js
//欲展開更深層的巢狀結構請使用reduce與concat的遞迴
function flattenDeep(arr1) {
  return arr1.reduce(
    (acc, val) =>
      Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val),
    [],
  );
}
flattenDeep(arr1); // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
```



```js
//使用stack來實作非遞迴的展開
var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]];
function flatten(input) {
  const stack = [...input];
  const res = [];
  while (stack.length) {
    // pop value from stack
    const next = stack.pop();
    if (Array.isArray(next)) {
      // push back array items, won't modify the original input
      stack.push(...next);
    } else {
      res.push(next);
    }
  }
  //reverse to restore input order
  return res.reverse();
}
flatten(arr1); // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
```



```js
// 递归版本的反嵌套
function flatten(array) {
  var flattend = [];
  (function flat(array) {
    array.forEach(function (el) {
      if (Array.isArray(el)) flat(el);
      else flattend.push(el);
    });
  })(array);
  return flattend;
}
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array.prototype.flatMap()` (en-US)
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`
Array.length
============

**`length`** 為 `Array` 物件的屬性，可供設定或回傳該陣列實體中包含的元素個數。其值必為一大於零、32 位元、且恆大於該陣列最大索引數的正整數。


```js
var items = ["shoes", "shirts", "socks", "sweaters"];
items.length;

// returns 4
```

描述
--

`length` 屬性的值必為一正整數，其值必介於 0 ～ 2^32 (不包含)之間.


```js
var namelistA = new Array(4294967296); //2^32 = 4294967296
var namelistC = new Array(-100); //負數

console.log(namelistA.length); //RangeError: Invalid array length
console.log(namelistC.length); //RangeError: Invalid array length

var namelistB = [];
namelistB.length = Math.pow(2, 32) - 1; //將長度設定介於 0 ~ 2^32 -1
console.log(namelistB.length);

//4294967295
```


你可以透過改變 `length` 屬性來改變陣列的長度。當你透過 `length` 屬性來增加陣列的長度時，陣列中實際的元素也會隨之增加。舉例來說，當你將 array.length 由 2 增加為 3，則改動後該陣列即擁有 3 個元素，該新增的元素則會是一個不可迭代(non-iterable)的空槽(empty slot)。
```

const arr = [1, 2];
console.log(arr);
// [ 1, 2 ]

arr.length = 5; // 將arr的length由2改成5
console.log(arr);
// [ 1, 2, <3 empty items> ]

arr.forEach(element => console.log(element)); // 空元素無法被迭代
// 1
// 2
```


如上所見，`length` 屬性不盡然代表陣列中所有已定義的元素個數。詳見 length 與數值屬性的關係。

| `Array.length` 的屬性特性 |
| --- |
| 可寫 | 是 |
| 可列舉 | 否 |
| 可配置 | 否 |

* `Writable`: 如果此屬性值為`false`，則該屬性的內容值無法被改動。
* `Configurable`: 如果此屬性值為`false`，任何刪除屬性或更改其屬性的操作(`Writable`, `Configurable`, or `Enumerable`)皆會失敗。
* `Enumerable`: 如果此屬性值為`true`，該內容值可倍 for 或 for..in 迴圈迭代處理。
範例
--

### 對陣列進行迭代處理

以下範例中, 陣列 `numbers` 透過 `length` 屬性進行迭代操作，並將其內容值加倍。


```js
var numbers = [1, 2, 3, 4, 5];
var length = numbers.length;
for (var i = 0; i < length; i++) {
  numbers[i] \*= 2;
}
// numbers 內容值變為 [2, 4, 6, 8, 10]
```

### 縮減陣列

以下範例中, 陣列 `numbers` 的長度若大於 3，則將其長度縮減至 3。


```js
var numbers = [1, 2, 3, 4, 5];

if (numbers.length > 3) {
  numbers.length = 3;
}

console.log(numbers); // [1, 2, 3]
console.log(numbers.length); // 3
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

瀏覽器相容性
------

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

參見
--

* `Array`
Array.prototype.values()
========================

**`values()`** 方法會回傳一個包含陣列中的每一個索引之對應值（value）的新 **`Array Iterator`** 物件。


```js
var a = ["w", "y", "k", "o", "p"];
var iterator = a.values();

console.log(iterator.next().value); // w
console.log(iterator.next().value); // y
console.log(iterator.next().value); // k
console.log(iterator.next().value); // o
console.log(iterator.next().value); // p
```

語法
--


```js
arr.values()
```

### 回傳值

一個新的 `Array` 迭代器（iterator）物件。

範例
--

### 使用 for...of 迴圈進行迭代


```js
var arr = ["w", "y", "k", "o", "p"];
var iterator = arr.values();

for (let letter of iterator) {
  console.log(letter);
}
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()` (en-US)
* `Array.prototype.every()` (en-US)
* `Array.prototype.some()` (en-US)
Array.prototype.copyWithin()
============================

**`copyWithin()`** 方法會對陣列的一部分進行淺拷貝至同一陣列的另一位置並回傳此陣列，而不修改其大小。

嘗試一下
----

語法
--
```

arr.copyWithin(target)
arr.copyWithin(target, start)
arr.copyWithin(target, start, end)
```

### 參數

`target`

要複製序列（sequence）至該位置的索引（起始為 0）。若為負數，`target` 將會自陣列末項開始計算。假如 `target` 大於等於 `arr.length`，則沒有項目會被複製。如果 `target` 的索引在 `start` 之後，則拷貝的序列將會被修剪以符合 `arr.length`。

`start` 選擇性

開始拷貝的起始元素索引（起始為 0）。若為負數，`start` 將會自陣列末項開始計算。如果省略 `start`，`copyWithin` 將會自陣列首項開始複製（預設為 0）。

`end` 選擇性

結束拷貝的結尾元素索引（起始為 0）。`copyWithin` 會拷貝至此索引，但不包含 `end`。若為負數，`end` 將會自陣列末項開始計算。如果省略 `end`，`copyWithin` 將會一路拷貝至陣列末項（預設至 `arr.length`）。

### 回傳值

被修改後的陣列。

描述
--

The `copyWithin` works like C and C++'s `memmove`, and is a high-performance method to shift the data of an `Array`. This especially applies to the `TypedArray` (en-US) method of the same name. The sequence is copied and pasted as one operation; pasted sequence will have the copied values even when the copy and paste region overlap.

The `copyWithin` function is intentionally *generic*, it does not require that its this value be an `Array` object.

The `copyWithin` method is a mutable method. It does not alter the length of `this`, but will change its content and create new properties if necessary.

範例
--


```js
[1, 2, 3, 4, 5].copyWithin(-2);
// [1, 2, 3, 1, 2]

[1, 2, 3, 4, 5].copyWithin(0, 3);
// [4, 5, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
// [4, 2, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(-2, -3, -1);
// [1, 2, 3, 3, 4]

[].copyWithin.call({ length: 5, 3: 1 }, 0, 3);
// {0: 1, 3: 1, length: 5}

// ES2015 Typed Arrays are subclasses of Array
var i32a = new Int32Array([1, 2, 3, 4, 5]);

i32a.copyWithin(0, 2);
// Int32Array [3, 4, 5, 4, 5]

// On platforms that are not yet ES2015 compliant:
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]
```

Polyfill
--------


```js
if (!Array.prototype.copyWithin) {
  Array.prototype.copyWithin =
    // Array: Number[, Number[, Number]]
    function copyWithin(target, start, stop) {
      var positiveT = target >= 0,
        positiveS = (start = start | 0) >= 0,
        length = this.length,
        zero = 0,
        r = function () {
          return (+new Date() \* Math.random()).toString(36);
        },
        delimiter = "\b" + r() + "-" + r() + "-" + r() + "\b",
        hold;

      stop = stop || this.length;
      hold = this.slice
        .apply(
          this,
          positiveT ? [start, stop] : positiveS ? [start, -target] : [start],
        )
        .join(delimiter);

      return (
        this.splice.apply(
          this,
          positiveT
            ? [target, stop - start, hold]
            : positiveS
              ? [target, stop, hold]
              : [target, start, hold],
        ),
        this.join(delimiter).split(delimiter).slice(zero, length)
      );
    };
}
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `Array`
Array.prototype.splice()
========================

**`splice()`** 方法可以藉由刪除既有元素並／或加入新元素來改變一個陣列的內容。

嘗試一下
----

語法
--


```js
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
```

### 參數

`start`

陣列中要開始改動的元素索引（起始為 0）。若索引大於陣列長度，則實際開始的索引值會被設為陣列長度。若索引為負，則會從陣列中最後一個元素開始往前改動（起始為 -1）且若其絕對值大於陣列的長度，則會被設為 0。

`deleteCount` 選擇性

一個表示欲刪除的原陣列元素數量的整數。若省略了 `deleteCount`，或假如其值大於 `array.length - start`（也就是 `deleteCount` 大於 `start` 算起的剩餘元素數量），則所有從 `start` 開始到陣列中最後一個元素都會被刪除。若 `deleteCount` 為 0 或是負數，則不會有元素被刪除。 因此，你應該給定至少一個欲加入的新元素（見下方說明）。

`item1, item2, ...` 選擇性

從 `start` 開始，要加入到陣列的元素。 如果你沒有指定任何元素，則 `splice()` 只會依照 `start` 和 `deleteCount` 刪除陣列的元素。

### 回傳值

一個包含被刪除的元素陣列。如果只有一個元素被刪除，依舊是回傳包含一個元素的陣列。 倘若沒有元素被刪除，則會回傳空陣列。

說明
--

如果你插入的元素數量和刪除的數量不同，則回傳的陣列長度也會和原先的不同。

範例
--

### 從索引 2 的位置開始，刪除 0 個元素並插入「drum」


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");

// myFish 為 ["angel", "clown", "drum", "mandarin", "sturgeon"]
// removed 為 [], 沒有元素被刪除
```

### 從索引 3 的位置開始，刪除 1 個元素


```js
var myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];
var removed = myFish.splice(3, 1);

// removed 為 ["mandarin"]
// myFish 為 ["angel", "clown", "drum", "sturgeon"]
```

### 從索引 2 的位置開始，刪除 1 個元素並插入「trumpet」


```js
var myFish = ["angel", "clown", "drum", "sturgeon"];
var removed = myFish.splice(2, 1, "trumpet");

// myFish 為 ["angel", "clown", "trumpet", "sturgeon"]
// removed 為 ["drum"]
```

### 從索引 0 的位置開始，刪除 2 個元素並插入「parrot」、「anemone」和「blue」


```js
var myFish = ["angel", "clown", "trumpet", "sturgeon"];
var removed = myFish.splice(0, 2, "parrot", "anemone", "blue");

// myFish 為 ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
// removed 為 ["angel", "clown"]
```

### 從索引 2 的位置開始，刪除 2 個元素


```js
var myFish = ["parrot", "anemone", "blue", "trumpet", "sturgeon"];
var removed = myFish.splice(myFish.length - 3, 2);

// myFish 為 ["parrot", "anemone", "sturgeon"]
// removed 為 ["blue", "trumpet"]
```

### 從索引 -2 的位置開始，刪除 1 個元素


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(-2, 1);

// myFish 為 ["angel", "clown", "sturgeon"]
// removed 為 ["mandarin"]
```

### 從索引 2 的位置開始，刪除所有元素（含索引 2）


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2);

// myFish 為 ["angel", "clown"]
// removed 為 ["mandarin", "sturgeon"]
```

規範
--

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

瀏覽器相容性
------

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

參見
--

* `push()` / `pop()` — add/remove elements from the end of the array
* `unshift()` / `shift()` — add/remove elements from the beginning of the array
* `concat()` — returns a new array comprised of this array joined with other array(s) and/or value(s)
Promise.resolve()
=================

**`Promise.resolve(value)`** 方法回傳一個以 value 判定結果的 `Promise` 物件。若 value 是個 thenable（例如，具有 `then()` 方法，則回傳的 promise 將依其結果採取其最終狀態；若 value 是 promise，則作為呼叫 Promise.resolve 之結果；其他情形都將回傳以 value 實現的 promise。

語法
--


```js
Promise.resolve(value);
Promise.resolve(promise);
Promise.resolve(thenable);
```

### 參數

value

將被 `Promise` 實現的引數（argument）。可以是個 `Promise` 或待解決的 thenable。

### 回傳值

以 value 或作為 value 的 promise 解決的 `Promise`。

描述
--

`靜態函式` `Promise.resolve` 回傳判定後的 `Promise。`

範例
--

### 使用 `Promise.resolve` 靜態方法


```js
Promise.resolve("Success").then(
  function (value) {
    console.log(value); // "Success"
  },
  function (value) {
    // not called
  },
);
```

### 判定陣列


```js
var p = Promise.resolve([1, 2, 3]);
p.then(function (v) {
  console.log(v[0]); // 1
});
```

### 判定另一個 `Promise`


```js
var original = Promise.resolve(33);
var cast = Promise.resolve(original);
cast.then(function (value) {
  console.log("value: " + value);
});
console.log("original === cast ? " + (original === cast));

// logs, in order:
// original === cast ? true
// value: 33
```


由於 handler 是非同步地被調用而導致相反的紀錄順序。經由這篇文章了解 then 如何運作。

### 判定 thenable 及拋出 Error


```js
// Resolving a thenable object
var p1 = Promise.resolve({
  then: function (onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true, object casted to a Promise

p1.then(
  function (v) {
    console.log(v); // "fulfilled!"
  },
  function (e) {
    // not called
  },
);

// Thenable throws before callback
// Promise rejects
var thenable = {
  then: function (resolve) {
    throw new TypeError("Throwing");
    resolve("Resolving");
  },
};

var p2 = Promise.resolve(thenable);
p2.then(
  function (v) {
    // not called
  },
  function (e) {
    console.log(e); // TypeError: Throwing
  },
);

// Thenable throws after callback
// Promise resolves
var thenable = {
  then: function (resolve) {
    resolve("Resolving");
    throw new TypeError("Throwing");
  },
};

var p3 = Promise.resolve(thenable);
p3.then(
  function (v) {
    console.log(v); // "Resolving"
  },
  function (e) {
    // not called
  },
);
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.resolve |

瀏覽器相容性
------

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

參見
--

* `Promise`