創建數組

• Array.of(...elements): 創建一個包含所有傳入參數的新數組。
• Array.from(arrayLike, mapFn, thisArg): 從類數組對象或可迭代對象創建一個新數組。

  let arr = Array.of(1, 2, 3); // [1, 2, 3]let arr = Array.from('hello'); // ['h', 'e', 'l', 'l', 'o']
  

訪問和修改數組（長度 ＆ 元素）

• arr.length: 獲取或設置數組的長度。
• arr[index]: 訪問或修改數組指定位置的元素。

  let arr = [1, 2, 3];
  console.log(arr.length); // 3
  arr.length = 2;
  console.log(arr); // [1, 2]let arr = [1, 2, 3];
  console.log(arr[1]); // 2
  arr[1] = 4;
  console.log(arr); // [1, 4, 3]
  

添加和刪除元素

• arr.push(...elements): 向數組末尾添加一個或多個元素，返回新的長度。
• arr.pop(): 刪除并返回數組的最后一個元素。
• arr.unshift(...elements): 向數組開頭添加一個或多個元素，返回新的長度。
• arr.shift(): 刪除并返回數組的第一個元素。

  let arr = [1, 2];
  arr.push(3, 4); // [1, 2, 3, 4]let arr = [1, 2, 3];
  let last = arr.pop(); // 3
  console.log(arr); // [1, 2]let arr = [1, 2];
  arr.unshift(0); // [0, 1, 2]let arr = [1, 2, 3];
  let first = arr.shift(); // 1
  console.log(arr); // [2, 3]
  

• arr.splice(start, deleteCount, ...items): 從數組中刪除或添加元素。

  let arr = [1, 2, 3];
  arr.splice(1, 1, 'a'); // [1, 'a', 3]
  

數組遍歷

• arr.forEach(callback, thisArg): 對數組的每個元素執行一次提供的函數

  let arr = [1, 2, 3];
  arr.forEach((item, index) => {console.log(index, item);
  });
  

元素查找

• arr.indexOf(searchElement, fromIndex): 返回數組中第一次找到的指定元素的索引，沒有則返回 -1。
• arr.lastIndexOf(searchElement, fromIndex): 返回數組中最后一次找到的指定元素的索引，沒有則返回 -1。
• arr.includes(searchElement, fromIndex): 判斷數組是否包含指定的元素。

  let arr = [1, 2, 3];
  arr.indexOf(2); // 1let arr = [1, 2, 3, 2];
  arr.lastIndexOf(2); // 3let arr = [1, 2, 3];
  arr.includes(2); // true
  

• arr.find(callback, thisArg): 返回數組中滿足提供的測試函數的第一個元素的值。
• arr.findIndex(callback, thisArg): 返回數組中滿足提供的測試函數的第一個元素的索引。

  let arr = [1, 2, 3];
  let found = arr.find(item => item > 1); // 2let arr = [1, 2, 3];
  let index = arr.findIndex(item => item > 1); // 1
  

過濾和映射

• arr.filter(callback, thisArg): 創建一個新數組，其中包含所有通過提供函數實現的測試的元素。
• arr.map(callback, thisArg): 創建一個新數組，其中每個元素是對原數組中的每個元素調用一個提供函數后的返回值。

  let arr = [1, 2, 3];
  let filtered = arr.filter(item => item > 1); // [2, 3]let arr = [1, 2, 3];
  let mapped = arr.map(item => item * 2); // [2, 4, 6]
  

歸并和縮減

• arr.reduce(callback, initialValue): 對數組中的每個元素執行一個由您提供的 reducer 函數（升序執行），將其結果匯總為單個返回值。
• arr.reduceRight(callback, initialValue): 與 reduce 類似，但從右到左執行。

  let arr = [1, 2, 3];
  let sum = arr.reduce((acc, item) => acc + item, 0); // 6let arr = [1, 2, 3];
  let sum = arr.reduceRight((acc, item) => acc + item, 0); // 6
  

數組的連接

• arr.concat(...arrays): 合并兩個或多個數組，不改變現有數組，返回一個新數組。
• arr.join(separator): 將數組的所有元素連接成一個字符串。

  let arr1 = [1, 2];
  let arr2 = [3, 4];
  let merged = arr1.concat(arr2); // [1, 2, 3, 4]let arr = [1, 2, 3];
  let joined = arr.join('-'); // '1-2-3'
  

數組的扁平化

• arr.flat(depth): 按照指定深度遞歸地將數組扁平化。
• arr.flatMap(callback, thisArg): 首先使用映射函數映射每個元素，然后將結果壓縮成一個新數組。

  let arr = [1, [2, [3, 4]]];
  let flat = arr.flat(2); // [1, 2, 3, 4]let arr = [1, 2, 3];
  let flatMapped = arr.flatMap(item => [item, item * 2]); // [1, 2, 2, 4, 3, 6]
  

數組的排序

• arr.sort(compareFunction): 原地對數組的元素進行排序，并返回此數組。（其中，(a, b) => b - a 表示降序，(b, a) => a - b 表示升序）

  let arr = [3, 1, 2];
  arr.sort(); // [1, 2, 3]
  arr.sort((a, b) => b - a); // [3, 2, 1]
  

數組的反轉

• arr.reverse(): 原地反轉數組中元素的順序。

  let arr = [1, 2, 3];
  arr.reverse(); // [3, 2, 1]
  

數組的復制

• arr.slice(start, end): 返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組對象。
• arr.copyWithin(target, start, end): 淺復制數組的一部分到同一數組中的另一個位置，并返回它，不會改變原數組的長度。

  let arr = [1, 2, 3];
  let sliced = arr.slice(1, 3); // [2, 3]let arr = [1, 2, 3, 4];
  arr.copyWithin(0, 2, 4); // [3, 4, 3, 4]
  

數組的測試

• Array.isArray(value): 判斷一個值是否為數組。

  Array.isArray([1, 2, 3]); // true
  Array.isArray('hello'); // false
  

• arr.every(callback, thisArg): 測試數組的所有元素是否都通過了指定函數的測試。
• arr.some(callback, thisArg): 測試數組中的某些元素是否至少有一個通過了指定函數的測試。

  let arr = [1, 2, 3];
  let allPositive = arr.every(item => item > 0); // truelet arr = [1, 2, 3];
  let somePositive = arr.some(item => item > 2); // true
  

數組的填充

• arr.fill(value, start, end): 用一個固定值填充數組中**從起始索引到終止索引（不包括）**的全部元素。

  let arr = [1, 2, 3];
  arr.fill(0, 1, 3); // [1, 0, 0]