recursal/MDN huggingface dataset:
Math.round()
============

**`Math.round()`** 函數回傳四捨五入後的近似值.

表達式
---
```

Math.round(x)
```

### 參數

`x`

數字.

描述
--

如果小數位的部分值大於 0.5, 這個值將會進位. 如果小數位的部分值小於 0.5, 這個值將不會進位.

由於 `round()` 是靜態的方法, 所以總是得這樣使用 `Math.round()`, 而非作為 `Math` 物件的一個方法 (`Math`並沒有建構子).

範例
--

### 使用 `Math.round()`


```js
// Returns the value 20
x = Math.round(20.49);

// Returns the value 21
x = Math.round(20.5);

// Returns the value -20
x = Math.round(-20.5);

// Returns the value -21
x = Math.round(-20.51);

// Returns the value 1 (!)
// Note the rounding error because of inaccurate floating point arithmetics
// Compare this with Math.round10(1.005, -2) from the example below
x = Math.round(1.005 \* 100) / 100;
```

### 十進位近似值


```js
// 閉包含數
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005\*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.round |

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

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

參見
--

* `Math.abs()` (en-US)
* `Math.ceil()`
* `Math.floor()`
* `Math.sign()` (en-US) 
實驗性質
* `Math.trunc()` (en-US) 
實驗性質
Math.random()
=============

函數 **`Math.random()`** 會回傳一個偽隨機小數 (pseudo-random) 介於 0 到 1 之間(包含 0，不包含 1) ，大致符合數學與統計上的均勻分佈 (uniform distribution) ，你可以選定想要的數字區間，它會透過演算法被產生並且不允許使用者自行跳選或重設成特定數字。

嘗試一下
----

**備註：** `Math.random()` 所產生的偽隨機小數不符合加密學安全性要求。*請勿使用於任何加密、資安相關領域。*

*如有加密需求建議參考 Web Crypto API*`window.crypto.getRandomValues()` (en-US)

語法
--
```

Math.random()
```

### 回傳值 Return value

回傳一個偽隨機小數 (pseudo-random)，小數也稱浮點數； 介於 0 到 1 之間(包含 0，不包含 1) 。

範例
--

請留意 JavaScript 中的數字與許多語言一樣使用 IEEE 754 floating point numbers with round-to-nearest-even behavior, the ranges claimed for the functions below (excluding the one for `Math.random()` itself) aren't exact. If extremely large bounds are chosen (2^53 or higher), it's possible in *extremely* rare cases to calculate the usually-excluded upper bound.

### Getting a random number between 0 (inclusive) and 1 (exclusive)


```js
function getRandom() {
  return Math.random();
}
```

### Getting a random number between two values

This example returns a random number between the specified values. The returned value is no lower than (and may possibly equal) `min`, and is less than (and not equal) `max`.


```js
function getRandomArbitrary(min, max) {
  return Math.random() \* (max - min) + min;
}
```

### Getting a random integer between two values

This example returns a random *integer* between the specified values. The value is no lower than `min` (or the next integer greater than `min` if `min` isn't an integer), and is less than (but not equal to) `max`.


```js
function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min) + min); //The maximum is exclusive and the minimum is inclusive
}
```


**備註：** might be tempting to use `Math.round()` to accomplish that, but doing so would cause your random numbers to follow a non-uniform distribution, which may not be acceptable for your needs.

### Getting a random integer between two values, inclusive

While the `getRandomInt()` function above is inclusive at the minimum, it's exclusive at the maximum. What if you need the results to be inclusive at both the minimum and the maximum? The `getRandomIntInclusive()` function below accomplishes that.


```js
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min + 1) + min); //The maximum is inclusive and the minimum is inclusive
}
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.random |

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

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

其他參考資料
------

* `window.crypto.getRandomValues()` (en-US)
Math.ceil()
===========

**`Math.ceil()`** 函式會回傳大於等於所給數字的最小整數。

嘗試一下
----

語法
--
```

Math.ceil(x)
```

### 參數

`x`

一個數字。

### 回傳值

一個大於等於指定數字的最小整數。

描述
--

Because `ceil()` is a static method of `Math`, you always use it as `Math.ceil()`, rather than as a method of a `Math` object you created (`Math` is not a constructor).

範例
--

### 使用 `Math.ceil()`

The following example shows example usage of `Math.ceil()`.


```js
Math.ceil(0.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7
```

### Decimal adjustment


```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ceil |

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

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

參見
--

* `Math.abs()` (en-US)
* `Math.floor()`
* `Math.round()`
* `Math.sign()` (en-US)
* `Math.trunc()` (en-US)
Math.floor()
============

**`Math.floor()`** 函式會回傳小於等於所給數字的最大整數。

嘗試一下
----

語法
--
```

Math.floor(x)
```

### 參數

`x`

數字型態。

### 回傳值

小於等於所給數字的最大整數。

描述
--

`floor()` 是 `Math`的靜態函式, 所以不需實體化`Math` 物件, 只要直接呼叫 `Math.floor()`就能使用。

(此外`Math` 並不是建構子).

範例
--

### 使用 `Math.floor()`


```js
Math.floor(45.95); // 45
Math.floor(45.05); // 45
Math.floor(4); // 4
Math.floor(-45.05); // -46
Math.floor(-45.95); // -46
```

### Decimal adjustment


```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.floor |

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

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

參見
--

* `Math.abs()` (en-US)
* `Math.ceil()`
* `Math.round()`
* `Math.sign()` (en-US)
* `Math.trunc()` (en-US)
Error.prototype.columnNumber
============================

**非標準:** This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

「行數」屬性含括了檔案中引起錯誤的所在行數。

範例
--

### 使用 `columnNumber`


```js
var e = new Error("Could not parse input");
throw e;
console.log(e.columnNumber); // 0
```

規格
--

不是任何規格的一部份，尚未標準化。

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

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

參見
--

* `Error.prototype.stack` (en-US) 
非標準
* `Error.prototype.lineNumber` (en-US) 
非標準
* `Error.prototype.fileName` (en-US) 
非標準
JSON.parse()
============

**`JSON.parse()`** 方法把會把一個 JSON 字串轉換成 JavaScript 的數值或是物件。另外也可選擇使用 reviver 函數讓這些數值或是物件在被回傳之前做轉換。

語法
--


```js
JSON.parse(text[, reviver])
```

### 參數

`text`

要解析成 JSON 的字串。針對 JSON 語法的描述，請參見 `JSON` 物件。

`reviver` 選擇性

為選擇性的參數，用來描述 JSON 字串中的值該如何被解析並回傳的函式(function)

### 回傳值

從給定的 JSON `text` 回傳對應的 `Object` (en-US)。

### 例外

如果解析的字串不是合法的 JSON 格式會丟出一個 `SyntaxError` (en-US) 例外

範例
--

### 使用 `JSON.parse()`


```js
JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null
```

### 使用 **`reviver`** 參數

如果 `reviver` 函數有被指定，字串解析後產生出來的值會在函式回傳前經過轉換。 具體來講，解析後的值或是物件屬性會一個接一個地被這個 reviver 函數過濾（順序是由巢狀架構中最深的到最淺的），而當一個屬性即將被過濾時，該屬性的名稱（字串形態）以及值會被當作參數傳入 reviver 函數。如果 reviver 函數回傳了 `undefined` (en-US)（或是沒有回傳值，例如：函式提早結束），則該屬性會從物件中被刪除；反之如果成功的話，該屬性的值就會被新的回傳值取代。

如果 reviver 只需轉換某些特定的值，請記得將其他不須特別轉換的值以原來的值回傳，否則這些值會從回傳的結果物件中刪除。


```js
JSON.parse('{"p": 5}', function (k, v) {
  if (typeof v === "number") {
    return v \* 2; // return v \* 2 for numbers
  }
  return v; // return everything else unchanged
});

// { p: 10 }

JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', function (k, v) {
  console.log(k); // log the current property name, the last is "".
  return v; // return the unchanged property value.
});

// 1
// 2
// 4
// 6
// 5
// 3
// ""
```

### `JSON.parse()` 不容許尾部有逗號


```js
// 這兩個都會拋出 SyntaxError
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{"foo" : 1, }');
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

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

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

Gecko 相關
--------

從 Gecko 29 版本開始，錯誤格式的 JSON 字串會產生更詳細的錯誤訊息，包含造成解析錯誤的行數及列數。這在針對大量 JSON 資料進行除錯時會很有幫助。


```js
JSON.parse("[1, 2, 3, 4,]");
// SyntaxError: JSON.parse: unexpected character at
// line 1 column 13 of the JSON data
```

參見
--

* `JSON.stringify()` (en-US)
Array.prototype.fill()
======================

**`fill()`** 方法會將陣列中索引的第一個到最後一個的每個位置全部填入一個靜態的值。

嘗試一下
----

語法
--
```

arr.fill(value[, start[, end]])
```

### 參數

`value`

欲填入陣列的值。

`start` 選擇性

起始的索引值，預設為 0。

`end` 選擇性

結束的索引值，預設為 `this.length`（即陣列的長度）。

### 回傳值

修改後的陣列。

說明
--

要填入的元素區間為 [`start`, `end`)，意即包含 `start` 但不包含 `end`。

**`fill`** 方法採用了三個傳入引數（arguments），分別為`value`、`start` 及 `end`。`start` 和 `end` 為可選引數，其預設值分別為 `0` 和 `this` 物件（該陣列）的 `length`。

若 `start` 為負數，則此方法會將其換算成 `length+start`，`length` 即該陣列的長度。同理，若 `end` 為負數，其會被換算成 `length+end`。

**`fill`** 函式刻意地被設計成通用的函式，它不需要 `this` 物件一定是一個陣列物件。此外，它是可變動的（mutable）方法，意即會修改 `this` 物件本身並回傳，而非只是回傳拷貝。

當 **`fill`** 方法獲得一個傳入的物件，會將傳入的物件位置進行複製，並把其參考值（reference）之拷貝填入陣列中。

範例
--


```js
[1, 2, 3].fill(4); // [4, 4, 4]
[1, 2, 3].fill(4, 1); // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2); // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1); // [1, 2, 3]
[1, 2, 3].fill(4, 3, 3); // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2); // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3]
[1, 2, 3].fill(4, 3, 5); // [1, 2, 3]
Array(3).fill(4); // [4, 4, 4]
[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3}

// Objects by reference.
var arr = Array(3).fill({}); // [{}, {}, {}];
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
```

Polyfill
--------


```js
if (!Array.prototype.fill) {
  Object.defineProperty(Array.prototype, "fill", {
    value: function (value) {
      // 步驟 1 - 2。
      if (this == null) {
        throw new TypeError("this is null or not defined");
      }

      var O = Object(this);

      // 步驟 3 - 5。
      var len = O.length >>> 0;

      // 步驟 6 - 7。
      var start = arguments[1];
      var relativeStart = start >> 0;

      // 步驟 8。
      var k =
        relativeStart < 0
          ? Math.max(len + relativeStart, 0)
          : Math.min(relativeStart, len);

      // 步驟 9 - 10。
      var end = arguments[2];
      var relativeEnd = end === undefined ? len : end >> 0;

      // 步驟 11。
      var final =
        relativeEnd < 0
          ? Math.max(len + relativeEnd, 0)
          : Math.min(relativeEnd, len);

      // 步驟 12。
      while (k < final) {
        O[k] = value;
        k++;
      }

      // 步驟 13。
      return O;
    },
  });
}
```


如果你需要支援實際上棄用的 JavaScript 引擎且其不支援 `Object.defineProperty` 的話，最好不要採用上述的工具來填充方法至 `Array.prototype`，因為你不能將這個方法設定為不可列舉（non-enumerable）的屬性。

規範
--

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

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

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

參見
--

* `Array`
* `TypedArray.prototype.fill()` (en-US)
Array.prototype.reverse()
=========================

**`reverse()`** 方法會*原地*（in place）反轉（reverse）一個陣列。陣列中的第一個元素變為最後一個，而最後一個元素則變成第一個。

嘗試一下
----

語法
--


```js
a.reverse()
```

### 回傳值

反轉後的陣列。

描述
--

`reverse` 方法將原地（in place）變換（transposes）呼叫此方法的陣列物件之元素至其顛倒的位置，改變原陣列後，並回傳此陣列之參考位址（reference）。

範例
--

### 反轉陣列中之元素

下列範例建立了一個包含三個元素的陣列 `a`，接著反轉此陣列。呼叫 `reverse()` 會回傳一個反轉後的原陣列 `a` 之參考。


```js
var a = ["one", "two", "three"];
var reversed = a.reverse();

console.log(a); // ['three', 'two', 'one']
console.log(reversed); // ['three', 'two', 'one']
```

規範
--

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

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

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

參見
--

* `Array.prototype.join()`
* `Array.prototype.sort()`
* `TypedArray.prototype.reverse()` (en-US)
Array.prototype.join()
======================

**`join()`** 方法會將陣列（或一個類陣列（array-like）物件 (en-US)）中所有的元素連接、合併成一個字串，並回傳此字串。

嘗試一下
----

語法
--
```

arr.join([separator])
```

### 參數

`separator` 選擇性

用來隔開陣列中每個元素的字串。如果必要的話，separator 會自動被轉成字串型態。如果未傳入此參數，陣列中的元素將預設用英文逗號（「,」）隔開。如果 `separator` 是空字串，合併後，元素間不會有任何字元。

### 回傳值

一個合併所有陣列元素的字串。假如 `arr.length` 為 `0`，將回傳空字串。

描述
--

將所有陣列中的元素轉成字串型態後，連接合併成一個字串。任何 `undefined` 或 `null` 的元素都會被視為空字串處理。

範例
--

### 舉例四種合併用法

下方的範例中，首先宣告一個陣列—`a`，其中有三個元素。接著分別用：預設值、逗號、加號和空字串將陣列連接。


```js
var a = ["Wind", "Rain", "Fire"];
a.join(); // 'Wind,Rain,Fire'
a.join(", "); // 'Wind, Rain, Fire'
a.join(" + "); // 'Wind + Rain + Fire'
a.join(""); // 'WindRainFire'
```

### 合併一個類陣列（array-like）物件

下方的範例將合併一個類陣列（array-like）物件（`arguments` (en-US)），藉由 `Function.prototype.call` 來呼叫 `Array.prototype.join`。


```js
function f(a, b, c) {
  var s = Array.prototype.join.call(arguments);
  console.log(s); // '1,a,true'
}
f(1, "a", true);
//expected output: "1,a,true"
```

規範
--

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

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

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

參見
--

* `String.prototype.split()` (en-US)
* `Array.prototype.toString()`
* `TypedArray.prototype.join()` (en-US)
Array.prototype.concat()
========================

**`concat()`** 方法被用來合併兩個或多個陣列。此方法不會改變現有的陣列，回傳一個包含呼叫者陣列本身的值，作為代替的是回傳一個新陣列。

嘗試一下
----

語法
--
```

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
```

### 參數

`valueN`

陣列以及／或者值，用來合併成一個新的陣列。請參閱下方詳細資訊描述。

### 回傳值

一個新的`陣列`實體。

描述
--

`concat` 產生一個由呼叫者陣列自己的元素，以及對每一個參數按照順序，合併參數的元素（如果參數是個陣列）或者是參數自己本身（如果參數不是一個陣列）成為一個新的陣列。`concat` 方法不會遞迴巢狀陣列參數。

`concat` 方法不會改變 `this` 自己本身或是任何被提供當做參數的陣列，取而代之則是回傳一個淺層複製（shallow copy）包含了與原始的陣列中一樣的元素的副本。原始陣列的元素被複製到新的陣列的規則如下所示：

* 物件參考（並非為實際的物件）：`concat` 複製物件的參考至新的陣列。不管是原始的還是新的陣列都參考到相同的物件。也就是說，如果一個被參照的物件被修改了，變動會同時反映到新的以及原始的陣列中。
* 資料型態為字串、數值或是布林（非 `String`、`Number` 及 `Boolean` 物件）：`concat` 複製字串及數值的值到新的陣列。

**備註：** 合併（多個）陣列／（多個）值將讓原始的陣列不會被受到影響。此外，任何對新陣列（只有在元素不是物件參考的情況下）的操作都不會影響原始的陣列，反之亦然。

範例
--

### 合併兩個陣列

下面的程式碼為合併兩個陣列：


```js
var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];

alpha.concat(numeric);
// 結果: ['a', 'b', 'c', 1, 2, 3]
```

### 合併三個陣列

下面的程式碼為合併三個陣列：


```js
var num1 = [1, 2, 3],
  num2 = [4, 5, 6],
  num3 = [7, 8, 9];

var nums = num1.concat(num2, num3);

console.log(nums);
// 結果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

### 合併值到一個陣列

下面的程式碼為合併三個值到一個陣列中：


```js
var alpha = ["a", "b", "c"];

var alphaNumeric = alpha.concat(1, [2, 3]);

console.log(alphaNumeric);
// 結果：['a', 'b', 'c', 1, 2, 3]
```

### 合併巢狀陣列

下面的程式碼為合併巢狀陣列，並證明保留了原本的參考（references）：


```js
var num1 = [[1]];
var num2 = [2, [3]];

var nums = num1.concat(num2);

console.log(nums);
// results in [[1], 2, [3]]

// modify the first element of num1
num1[0].push(4);

console.log(nums);
// results in [[1, 4], 2, [3]]
```

規格
--

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

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

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

參見
--

* `push` / `pop` — 從陣列的尾端加入/移除元素
* `unshift` / `shift` — 從陣列的前端加入/移除元素
* `splice` — 從陣列特定的位置加入/移除元素
* `String.prototype.concat()`
* `Symbol.isConcatSpreadable` (en-US) – 控制扁平化
Array.prototype.toString()
==========================

**`toString()`** 方法將回傳一個可以表達該陣列及其元素的字串。

嘗試一下
----

語法
--


```js
toString()
```

### 回傳值

一個表達該陣列及該陣列中元素的字串。

描述
--

`Array` 覆寫了 `Object` (en-US) 中的 `toString` 方法。
 陣列的 `toString` 方法會將陣列中的每個元素用逗號串接起來成為一個字串，並回傳該字串。

當你在會以文字型態表示的地方使用了陣列，或是在字串的串接中使用到了陣列，JavaScript 會自動為該陣列使用`toString` 方法。

### ECMAScript 5 語義

 始於 JavaScript 1.8.5 (Firefox 4)，並且和 ECMAScript 5 的語義一致。
 `toString()` 方法是通用的，任何的物件都可以使用。 `Object.prototype.toString()` (en-US) 會被呼叫，並回傳結果。

範例
--

### 如何使用 toString


```js
const array1 = [1, 2, "a", "1a"];

console.log(array1.toString());
// expected output: "1,2,a,1a"
```

規範
--

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

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

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

參見
--

* `Array.prototype.join()`
* `Object.prototype.toSource()` (en-US)
Array.prototype.keys()
======================

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

嘗試一下
----

語法
--
```

arr.keys()
```

### 回傳值

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

範例
--

### 鍵迭代器不會乎略陣列中的空元素


```js
var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys); // [0, 1, 2]
```

規範
--

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

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

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

參見
--

* `Array.prototype.values()`
* `Array.prototype.entries()`
* 迭代協議
Array.prototype.unshift()
=========================

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

嘗試一下
----

語法
--
```

arr.unshift(element1[, ...[, elementN]])
```

### 參數

`elementN`

欲添加至陣列開頭的元素。

### 回傳值

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

描述
--

`unshift` 方法會將一或多個給定值插入至一個類陣列（array-like）物件的開頭。

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

範例
--


```js
var arr = [1, 2];

arr.unshift(0); // 執行後的結果是3，其代表處理後的陣列長度
// arr is [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr is [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr is [[-3], -2, -1, 0, 1, 2]
```

規範
--

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

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

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

參見
--

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.concat()`