javascript Array方法總結（下篇）

每個方法都有相應的描述、語法、參數、返回值、注意項（可選）、例子（可選）。
語法中的[]裏面中的內容表示參數爲可選參數。

原文出自：https://fxss5201.github.io/practical-code-snippet/js/javascript/Array.html

Array.prototype.lastIndexOf()

描述：返回從數組中逆向找到給定元素的第一個索引，如果不存在，則返回-1。

語法：

number = old_array.lastIndexOf(searchElement[, fromIndex]);

參數：

1. old_array：原數組。
2. searchElement：需要查找的元素值。
3. fromIndex：從該索引處開始逆向查找searchElement。默認值從array.length - 1，即整個數組都被查找。如果該值大於或等於數組的長度，則整個數組會被查找。如果爲負值，則從array.length + fromIndex索引出開始逆向查找。如果負值的絕對值大於數組長度，則方法返回 -1，即數組不會被查找。

返回值：

1. number：返回從數組中逆向找到給定元素的第一個索引，如果不存在，則返回-1。

注意項：

1. lastIndexOf使用嚴格等於進行判斷（僅當兩個操作數的類型相同且值相等才爲true）。

例子：

[2, 5, 9].lastIndexOf(2); // 0
[2, 5, 9].lastIndexOf('2'); // -1

Array.prototype.map()

描述：創建一個新數組，其結果是該數組中的每個元素都調用提供函數後返回的結果。

語法：

new_array = old_array.map(callback(element[, index[, array]])[, thisArg]);

參數：

1. old_array：原數組。
2. callback：原數組中的每個元素都執行的回調函數，然後返回新數組中對應索引處的元素。
   1. element：當前在數組中處理的元素。
   2. index：當前在數組中處理的元素的索引。
   3. array：當前數組。
3. thisArg：執行回調函數時的this對象。

返回值：

1. new_array：callback每次執行後的返回值（包括undefined）組合起來形成一個新數組。

注意項：

1. map遍歷的元素範圍在第一次調用callback之前就已經確定了。在調用map之後新添加到數組中的元素不會被callback訪問到。如果數組中存在的元素被更改，則他們傳入callback的值是map訪問到他們那一刻的值。從來沒被賦過值或被刪除的元素將不會被訪問到。

例子：

[2, 5, 9].map(x => x * x); // [4, 25, 81]

["1", "2", "3"].map(parseInt); // [1, NaN, NaN]
["1", "2", "3"].map(x => parseInt(x)); // [1, 2, 3]

Array.prototype.pop()

描述：從數組中刪除最後一個元素，並返回該元素的值。

語法：

last_element = old_array.pop();

參數：

1. old_array：原數組。

返回值：

1. last_element：數組的最後一個元素。

注意項：

1. 在空數組上調用pop()，返回undefined。
2. Array(7)等稀疏數組上調用pop()，返回undefined。
3. 此方法會改變原數組。

例子：

[2, 5, 9].pop(); // 9
[2, 5, [9, 10]].pop(); // [9, 10]

[].pop(); // undefined
Array(7).pop(); // undefined

Array.prototype.push()

描述：將一個或多個元素添加到數組的末尾，並返回該數組的新長度。

語法：

new_array_length = old_array.push(element1, ..., elementN);

參數：

1. old_array：原數組。
2. elementN：被添加到數組末尾的元素。

返回值：

1. new_array_length：返回數組添加元素之後的新長度。

例子：

var arr = [1, 2, 3];
arr.push(4, 5); // 5
console.log(arr); // [1, 2, 3, 4, 5]

Array.prototype.reduce()

描述：對數組中的每個元素執行提供的reducer函數(升序執行)，將其結果彙總爲單個返回值。

語法：

number = old_array.reduce(callback(accumulator, element[[, index], array])[, initialValue]);

參數：

1. old_array：原數組。
2. callback：原數組中的每個元素都執行的回調函數。
   1. accumulator：上一次調用回調的返回值，或提供的initialValue。
   2. element：當前在數組中處理的元素。
   3. index：當前在數組中處理的元素的索引。
   4. array：當前數組。
3. initialValue：用作第一次調用callback的參數值。如果未提供初始值，則將使用數組中的第一個元素。空數組在沒有初始值時調用reduce()拋出TypeError。

返回值：

1. number：對數組中的每個元素執行提供的reducer函數(升序執行)，將其結果彙總爲單個返回值。

注意項：

1. reduce爲數組中的每一個元素依次執行callback函數，不包括數組中被刪除或從未被賦值的元素。
2. 如果調用reduce時提供了initialValue，accumulator取值爲initialValue，element取數組中的第一個值；如果沒有提供initialValue，那麼accumulator取數組中的第一個值，element取數組中的第二個值。
3. 如果沒有提供initialValue，reduce會從索引 1 的地方開始執行callback方法，跳過第一個索引。如果提供initialValue，從索引 0 開始。
4. 如果數組僅有一個元素（無論位置如何）並且沒有提供initialValue，或者有提供initialValue但是數組爲空，那麼此唯一值將被返回並且callback不會被執行。

例子：（代碼註釋中的->表示執行一次的結果）

[0, 1, 2, 3, 4].reduce(function(accumulator, element, index, array){
  console.log(accumulator); // 0 -> 1 -> 3 -> 6
  return accumulator + element;
}); // 10
[0, 1, 2, 3, 4].reduce(function(accumulator, element, index, array){
  console.log(accumulator); // 10 -> 10 -> 11 -> 13 -> 16
  return accumulator + element;
}, 10); // 20

Array.prototype.reduceRight()

描述：從右到左對數組中的每個元素執行提供的reduceRight函數，將其結果彙總爲單個返回值。

語法：

number = old_array.reduceRight(callback(previousValue, element[[, index], array])[, initialValue]);

參數：

1. old_array：原數組。
2. callback：原數組中的每個元素都執行的回調函數。
   1. previousValue：上一次調用回調的返回值，或提供的initialValue。
   2. element：當前在數組中處理的元素。
   3. index：當前在數組中處理的元素的索引。
   4. array：當前數組。
3. initialValue：用作第一次調用reduceRight的參數值。如果未提供初始值，則將使用數組中的最後一個元素。空數組在沒有初始值時調用reduceRight()拋出TypeError。

返回值：

1. number：從右到左對數組中的每個元素執行提供的reduceRight函數，將其結果彙總爲單個返回值。

注意項：

1. reduceRight爲數組中的每一個元素依次執行callback函數，不包括數組中被刪除或從未被賦值的元素。
2. 如果調用reduceRight時提供了initialValue，previousValue取值爲initialValue，element取數組中的最後一個值；如果沒有提供initialValue，那麼previousValue取數組中的最後一個值，element取數組中的倒數第二個值。
3. 如果數組僅有一個元素（無論位置如何）並且沒有提供initialValue，或者有提供initialValue但是數組爲空，那麼此唯一值將被返回並且callback不會被執行。

例子：

[0, 1, 2, 3, 4].reduceRight(function(accumulator, element, index, array){
  console.log(accumulator); // 4 -> 7 -> 9 -> 10
  return accumulator + element;
}); // 10
[0, 1, 2, 3, 4].reduceRight(function(accumulator, element, index, array){
  console.log(accumulator); // 10 -> 14 -> 17 -> 19 -> 20
  return accumulator + element;
}, 10); // 20

Array.prototype.reverse()

描述：將數組中元素的位置顛倒。

語法：

new_array = old_array.reverse();

參數：

1. old_array：原數組。

返回值：

1. new_array：顛倒數組中元素的位置，並返回該數組的引用。

例子：

var arr = ['one', 'two', 'three'];
var reversed = arr.reverse();
console.log('reversed: ', reversed); // ["three", "two", "one"]
console.log('arr: ', arr); // ["three", "two", "one"]

Array.prototype.shift()

描述：從數組中刪除第一個元素，並返回該元素的值。此方法更改數組的長度。

語法：

first_element = old_array.shift();

參數：

1. old_array：原數組。

返回值：

1. first_element：數組中的第一個元素。

注意項：

1. 如果數組的length屬性的值爲 0 (長度爲 0)，則返回undefined。

例子：

var arr = ['one', 'two', 'three'];
var shift = arr.shift();
console.log('shift: ', shift); // one
console.log('arr: ', arr); // ['two', 'three']

[].shift(); // undefined

Array.prototype.slice()

描述：slice不修改原數組，只會返回一個淺複製了原數組中的元素的一個新數組。

語法：

new_array = old_array.slice([start[, end]);

參數：

1. old_array：原數組。
2. start：從該索引處開始複製原數組中的元素（包含該索引處的值），索引以0開始，如果指定負數，將從數組的末尾開始往回算。默認值爲：0。
3. end：在該索引處結束複製原數組元素（不包含該索引處的值），索引以0開始，如果指定負數，將從數組的末尾開始往回算。默認值爲：old_array.length。

返回值：

1. new_array：返回淺複製的新數組。

注意項：

1. 如果原數組中當前複製元素是對象引用 （不是實際的對象），slice會拷貝這個對象引用到新的數組裏。兩個對象引用都引用了同一個對象。如果被引用的對象發生改變，則新的和原來的數組中的這個元素都會發生改變。
2. 對於字符串、數字及布爾值來說（不是String、Number或者Boolean對象），slice會拷貝這些值到新的數組裏。在別的數組裏修改這些字符串或數字或是布爾值，將不會影響其他數組。

例子：

var arr1 = [1, 2, 3],
    arr2 = [arr1, 4, 5, 6], // [[1, 2, 3], 4, 5, 6]
    arr3 = arr2.slice(0, 2), // [[1, 2, 3], 4]
    arr4 = arr2.slice(1, 3); // [4, 5]
arr1[0] = 7;
arr2[1] = 8;
console.log(arr2); // [[7, 2, 3], 8, 5, 6]
console.log(arr3); // [[7, 2, 3], 4]
console.log(arr4); // [4, 5]

Array.prototype.some()

描述：測試是否至少有一個元素通過提供的函數的測試。

語法：

boolean = old_array.some(callback(element[, index[, array]])[, thisArg]);

參數：

1. old_array：原數組。
2. callback：用來測試數組的每個元素的函數，符合條件則返回true，否則返回false。
   1. element：當前在數組中處理的元素。
   2. index：當前在數組中處理的元素的索引。
   3. array：當前數組。
3. thisArg：執行callback時使用的this值。

返回值：

1. boolean：如果至少有一個元素符合條件則返回true，否則返回false。

注意項：

1. 空數組調用some方法返回false。
2. some爲數組中的每一個元素執行一次callback函數，直到找到一個使得callback返回一個true或Truthy。如果找到了這樣一個值，some()將會立即返回 true，否則返回false。callback只會在那些”有值“的索引上被調用，不會在那些被刪除或從來未被賦值的索引上調用。
3. some遍歷的元素範圍在第一次調用callback之前就已經確定了。在調用some之後新添加到數組中的元素不會被callback訪問到。如果數組中存在的元素被更改，則他們傳入callback的值是some訪問到他們那一刻的值。那些被刪除的元素或從來未被賦值的元素將不會被訪問到。

例子：

[].some(x => x > 0); // false

[1, 2, 3].some(x => x > 2); // true

Array.prototype.sort()

描述：對數組的元素進行排序，並返回數組。默認排序順序是根據字符串Unicode排序。

語法：

new_array = old_array.sort([compareFunction]);

參數：

1. old_array：原數組。
2. compareFunction：用來指定按某種順序進行排列的函數。如果省略，元素按照轉換爲的字符串的各個字符的Unicode進行排序。

返回值：

1. new_array：排序後的數組。

例子：

[1, 20, 8, 16].sort(); // [1, 16, 20, 8]

[1, 20, 8, 16].sort((a,b) => a - b); // [1, 8, 16, 20]

Array.prototype.splice()

描述：通過刪除現有元素和 / 或添加新元素來修改數組，並以數組返回原數組中被刪除的內容。

語法：

new_array = old_array.splice(start[, deleteCount[, item1[, item2[, ...]]]]);

參數：

1. old_array：原數組。
2. start：從該索引處開始刪除現有元素和 / 或添加新元素來修改數組，索引以0開始，如果指定負數，將從數組的末尾開始往回算。默認值爲：0。
3. deleteCount：整數，表示要移除的數組元素的個數。
   1. 如果deleteCount是 0或者負數，則不移除元素。這種情況下，至少應添加一個新元素。
   2. 如果deleteCount大於start之後的元素的總數，則從start後面的元素都將被刪除（含第start位）。
   3. 如果deleteCount被省略，則其相當於old_array.length - start。
4. itemN：從start索引開始添加進數組的元素。如果不指定，則splice將只刪除數組元素。

返回值：

1. new_array：由被刪除的元素組成的一個數組。如果只刪除了一個元素，則返回只包含一個元素的數組。如果沒有刪除元素，則返回空數組。

例子：

[1, 20, 8, 16].splice(1); // [20, 8, 16]
[1, 20, 8, 16].splice(1, 2); // [20, 8]

var arr1 = [1, 20, 8, 16],
    arr2 = arr1.splice(1, 2, 2, 3, 4);
console.log(arr1); // [1, 2, 3, 4, 16]
console.log(arr2); // [20, 8]

Array.prototype.toString()

描述：返回一個字符串，表示指定的數組及其元素。

語法：

str = old_array.toString();

參數：

1. old_array：原數組。

返回值：

1. str：返回一個字符串，表示指定的數組及其元素。

例子：

[1, 20, 8, 16].toString(); // "1,20,8,16"

[1, [20, [10, 15], 8], 16].toString(); // "1,20,10,15,8,16"

Array.prototype.unshift()

描述：將一個或多個元素添加到數組的開頭，並返回該數組的新長度。

語法：

new_array_length = old_array.unshift(element1, ..., elementN);

參數：

1. old_array：原數組。
2. elementN：要添加到數組開頭的元素。

返回值：

1. new_array_length：將一個或多個元素添加到數組的開頭，並返回該數組的新長度。

例子：

var arr1 = [1, 20, 8, 16],
    len = arr1.unshift(-1, 0);
console.log(arr1); // [-1, 0, 1, 20, 8, 16]
console.log(len); // 6

Array.prototype.values()

描述：返回一個新的 Array Iterator 對象，該對象包含數組每個索引的值。

語法：

new_iterator = old_array.values();

參數：

1. old_array：原數組。
2. elementN：要添加到數組開頭的元素。

返回值：

1. new_iterator：返回一個新的 Array Iterator 對象，該對象包含數組每個索引的值。

例子：

var iterator = ['a', 'b', 'c'].values();
iterator.next();   // {value: "a",done: false}
iterator.next();   // {value: "b",done: false}
iterator.next();   // {value: "c",done: false}
iterator.next();   // {value: undefined,done: true}