常用方法速覽：
接下來是比較全的、詳細的方法用法
1. Array.from()
該方法從一個類似數(shù)組或可迭代對象中創(chuàng)建一個新的，淺拷貝的數(shù)組實例丁稀。
語法：
Array.from(arrayLike[, mapFn[, thisArg]])
參數(shù)：
arrayLike -- 想要轉(zhuǎn)換成數(shù)組的偽數(shù)組對象或可迭代對象肥卡。
mapFn -- (可選參數(shù)) 如果指定了該參數(shù)臂聋，新數(shù)組中的每個元素會執(zhí)行該回調(diào)函數(shù)霜医。
thisArg -- (可選參數(shù)) 可選參數(shù)，執(zhí)行回調(diào)函數(shù) mapFn 時 this 對象驳规。
返回值：一個新的數(shù)組實例肴敛。
console.log(Array.from('foo')); // ["f", "o", "o"]
console.log(Array.from([1, 2, 3], x => x + x)); // [2, 4, 6]
2. Array.isArray()
用于確定傳遞的值是否是一個 Array。
Array.isArray([1, 2, 3]);
// true
Array.isArray({foo: 123});
// false
Array.isArray("foobar");
// false
Array.isArray(undefined);
// false
3. Array.of()
創(chuàng)建一個具有可變數(shù)量參數(shù)的新數(shù)組實例吗购，而不考慮參數(shù)的數(shù)量或類型医男。
Array.of() 和 Array 構(gòu)造函數(shù)之間的區(qū)別在于處理整數(shù)參數(shù)：Array.of(7) 創(chuàng)建一個具有單個元素 7 的數(shù)組，而 Array(7) 創(chuàng)建一個長度為7的空數(shù)組（注意：這是指一個有7個空位(empty)的數(shù)組捻勉，而不是由7個undefined組成的數(shù)組）。
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
4. concat()
用于合并兩個或多個數(shù)組踱启。此方法不會更改現(xiàn)有數(shù)組报账，而是返回一個新數(shù)組。
語法：
var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
var array1 = ['a', 'b', 'c'];
var array2 = ['d', 'e', 'f'];
var arr = array1.concat(array2);
console.log(arr); // ["a", "b", "c", "d", "e", "f"]
console.log(array1); // ["a", "b", "c"]
5. copyWithin()
淺復(fù)制數(shù)組的一部分到同一數(shù)組中的另一個位置，并返回它，不會改變原數(shù)組的長度脑融，但是會(同返回值)窿侈。
語法：
arr.copyWithin(target[, start[, end]])
參數(shù)：
target -- 0 為基底的索引肛著，復(fù)制序列到該位置超凳。如果是負數(shù)，target 將從末尾開始計算。如果 target 大于等于 arr.length系奉，將會不發(fā)生拷貝。如果 target 在 start 之后，復(fù)制的序列將被修改以符合 arr.length赁严。
start -- 0 為基底的索引劝枣，開始復(fù)制元素的起始位置。如果是負數(shù)采桃，start 將從末尾開始計算。如果 start 被忽略拘荡，copyWithin 將會從0開始復(fù)制蟋定。
end -- 0 為基底的索引屠凶，開始復(fù)制元素的結(jié)束位置。copyWithin 將會拷貝到該位置钠乏，但不包括 end 這個位置的元素惕艳。如果是負數(shù)， end 將從末尾開始計算憔恳。
返回值：改變后的數(shù)組。
var array1 = ['a', 'b', 'c', 'd', 'e'];
console.log(array1.copyWithin(0, 3, 4)); // ["d", "b", "c", "d", "e"]
console.log(array1); // ["d", "b", "c", "d", "e"]
console.log(array1.copyWithin(1, 3)); // ["d", "d", "e", "d", "e"]
let numbers = [1, 2, 3, 4, 5];
numbers.copyWithin(-2); // [1, 2, 3, 1, 2]
numbers.copyWithin(0, 3); // [4, 5, 3, 4, 5]
numbers.copyWithin(0, 3, 4); // [4, 2, 3, 4, 5]
numbers.copyWithin(-2, -3, -1); // [1, 2, 3, 3, 4]
6. entries()
該方法返回一個新的Array Iterator對象哥童，該對象包含數(shù)組中每個索引的鍵/值對。
var array1 = ['a', 'b', 'c'];
var iterator1 = array1.entries();
console.log(iterator1.next().value); // [0, "a"]
console.log(iterator1.next().value); // [1, "b"]
var arr = ["a", "b", "c"];
var iterator = arr.entries();
for (let e of iterator) {
console.log(e);
}
// [0, "a"]
// [1, "b"]
// [2, "c"]
7. every()
該方法測試一個數(shù)組內(nèi)的所有元素是否都能通過某個指定函數(shù)的測試躲因。它返回一個布爾值荐类。若收到一個空數(shù)組饶号，此方法在一切情況下都會返回 true濒生。
語法：
arr.every(callback[, thisArg])
參數(shù)：
callback -- 用來測試每個元素的函數(shù)，它可以接收三個參數(shù)：
element ： 用于測試的當前值幔欧。
index ：可選罪治，用于測試的當前值的索引。
array：可選礁蔗，調(diào)用 every 的當前數(shù)組觉义。
thisArg -- 執(zhí)行 callback 時使用的 this 值。
返回值：如果回調(diào)函數(shù)的每一次返回都為 truthy 值浴井，返回 true 晒骇，否則返回 false。
every 方法為數(shù)組中的每個元素執(zhí)行一次 callback 函數(shù)磺浙，直到它找到一個會使 callback 返回 falsy 的元素洪囤。如果發(fā)現(xiàn)了一個這樣的元素，every 方法將會立即返回 false撕氧。否則瘤缩，callback 為每一個元素返回 true，every 就會返回 true伦泥。callback 只會為那些已經(jīng)被賦值的索引調(diào)用骗污。不會為那些被刪除或從未被賦值的索引調(diào)用否过。
const val = [12, 5, 8, 130, 44].every((x,i,array) => {
console.log(x,i,array);
return x >= 10;
});
// 12 0 [12, 5, 8, 130, 44]
// 5 1 [12, 5, 8, 130, 44]
console.log(val); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true
8. some()
測試是否至少有一個元素可以通過被提供的函數(shù)方法累驮。該方法返回一個Boolean類型的值惩系。
[2, 5, 8, 1, 4].some(x => x > 10); // false
[12, 5, 8, 1, 4].some(x => x > 10); // true
9. fill()
用一個固定值填充一個數(shù)組中從起始索引到終止索引內(nèi)的全部元素。不包括終止索引防楷。(同返回值)
語法：
arr.fill(value[, start[, end]])
value -- 用來填充數(shù)組元素的值牺丙。
start -- 起始索引，默認值為0复局。
end -- 終止索引赘被，默認值為 this.length是整。
返回值：改變后的數(shù)組。
var arr = [1, 2, 3];
arr.fill(4); // [4, 4, 4]
console.log(arr); // [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]
10. filter()
創(chuàng)建一個新數(shù)組, 其包含通過所提供函數(shù)實現(xiàn)的測試的所有元素民假。
語法：
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
返回值：一個新的浮入、由通過測試的元素組成的數(shù)組，如果沒有任何數(shù)組元素通過測試羊异，則返回空數(shù)組事秀。
var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = words.filter(val => val.length > 6);
console.log(result); // ["exuberant", "destruction", "present"]
console.log(words); // ["spray", "limit", "elite", "exuberant", "destruction", "present"]
11. find()
返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的值。否則返回undefined野舶。
語法：
arr.find(callback[, thisArg])
返回值：數(shù)組中第一個滿足所提供測試函數(shù)的元素的值易迹，否則返回 undefined。
find方法對數(shù)組中的每一項元素執(zhí)行一次 callback 函數(shù)平道，直至有一個 callback 返回 true睹欲。當找到了這樣一個元素后，該方法會立即返回這個元素的值一屋，否則返回 undefined窘疮。
var array1 = [5, 12, 8, 130, 44];
var found = array1.find((element,i) => {
console.log(i); // 0 1
return element > 10;
});
console.log(found); // 12
12. findIndex()
返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的索引。否則返回-1冀墨。
var array1 = [5, 12, 8, 130, 44];
var found = array1.findIndex((element,i) => {
console.log(i); // 0 1
return element > 10;
});
console.log(found); // 1
13. flat()
按照一個可指定的深度遞歸遍歷數(shù)組闸衫，并將所有元素與遍歷到的子數(shù)組中的元素合并為一個新數(shù)組返回。不改變原數(shù)組诽嘉。
語法：
var newArray = arr.flat(depth)
返回值：一個包含將數(shù)組與子數(shù)組中所有元素的新數(shù)組蔚出。
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]
//使用 Infinity 作為深度，展開任意深度的嵌套數(shù)組
arr3.flat(Infinity); // [1, 2, 3, 4, 5, 6]
flat() 方法會移除數(shù)組中的空項:
var arr4 = [1, 2, , 4, 5];
arr4.flat(); // [1, 2, 4, 5]
14. flatMap()
首先使用映射函數(shù)映射每個元素虫腋，然后將結(jié)果壓縮成一個新數(shù)組骄酗。它與 map 和 深度值1的 flat 幾乎相同，但 flatMap 通常在合并成一種方法的效率稍微高一些悦冀。
語法：
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
// 返回新數(shù)組的元素
}[, thisArg])
返回值：一個新的數(shù)組趋翻，其中每個元素都是回調(diào)函數(shù)的結(jié)果，并且結(jié)構(gòu)深度 depth 值為1雏门。
var arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]); // [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]); // [2, 4, 6, 8]
// 只會將 flatMap 中的函數(shù)返回的數(shù)組 “壓平” 一層
arr1.flatMap(x => [[x * 2]]); // [[2], [4], [6], [8]]
15. forEach()
對數(shù)組的每個元素執(zhí)行一次提供的函數(shù)嘿歌。
var arr1 = ['a', 'b', 'c', 'd'];
arr1.forEach((ele, i) => {
console.log(ele,i);
});
// a 0
// b 1
// c 2
// d 3
16. includes()
用來判斷一個數(shù)組是否包含一個指定的值掸掏，根據(jù)情況茁影，如果包含則返回 true，否則返回false丧凤。使用 includes()比較字符串和字符時是區(qū)分大小寫募闲。
注意：對象數(shù)組不能使用includes方法來檢測。
語法：
arr.includes(valueToFind[, fromIndex])
參數(shù)：
valueToFind -- 需要查找的元素值愿待。
fromIndex -- 可選浩螺。從fromIndex 索引處開始查找 valueToFind靴患。如果為負值，則按升序從 array.length + fromIndex 的索引開始搜 （即使從末尾開始往前跳 fromIndex 的絕對值個索引要出，然后往后搜尋）鸳君。默認為 0。
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
17. indexOf()
返回在數(shù)組中可以找到一個給定元素的第一個索引患蹂，如果不存在或颊，則返回-1。
語法：
arr.indexOf(searchElement[, fromIndex = 0])
參數(shù)：
searchElement -- 要查找的元素传于。
fromIndex -- 開始查找的位置囱挑。如果該索引值大于或等于數(shù)組長度，意味著不會在數(shù)組里查找沼溜，返回-1平挑。如果參數(shù)中提供的索引值是一個負值，則將其作為數(shù)組末尾的一個抵消系草，即-1表示從最后一個元素開始查找通熄，-2表示從倒數(shù)第二個元素開始查找 ，以此類推悄但。 注意：如果參數(shù)中提供的索引值是一個負值棠隐，并不改變其查找順序，查找順序仍然是從前向后查詢數(shù)組檐嚣。如果抵消后的索引值仍小于0助泽，則整個數(shù)組都將會被查詢。其默認值為0.
返回值：首個被找到的元素在數(shù)組中的索引位置; 若沒有找到則返回 -1嚎京。
var array = [2, 5, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0
18. join()
將一個數(shù)組（或一個類數(shù)組對象）的所有元素連接成一個字符串并返回這個字符串嗡贺。如果數(shù)組只有一個項目，那么將返回該項目而不使用分隔符鞍帝。
注意：如果一個元素為 undefined 或 null诫睬，它會被轉(zhuǎn)換為空字符串。
var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join(); // myVar1的值變?yōu)?Wind,Rain,Fire"
var myVar2 = a.join(', '); // myVar2的值變?yōu)?Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值變?yōu)?Wind + Rain + Fire"
var myVar4 = a.join(''); // myVar4的值變?yōu)?WindRainFire"
var b = ['Wind', 'Rain', null, 'Fire', undefined, 6];
console.log(b.join('/')); // Wind/Rain//Fire//6
console.log(b); // ["Wind", "Rain", null, "Fire", undefined, 6]
19. lastIndexOf()
返回指定元素（也即有效的 JavaScript 值或變量）在數(shù)組中的最后一個的索引帕涌，如果不存在則返回 -1摄凡。從數(shù)組的后面向前查找，從 fromIndex 處開始蚓曼。
語法：
arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
參數(shù)：
searchElement -- 被查找的元素亲澡。
fromIndex -- 從此位置開始逆向查找。默認為數(shù)組的長度減 1纫版，即整個數(shù)組都被查找床绪。如果該值大于或等于數(shù)組的長度，則整個數(shù)組會被查找。如果為負值癞己，將其視為從數(shù)組末尾向前的偏移膀斋。即使該值為負，數(shù)組仍然會被從后向前查找痹雅。如果該值為負時仰担，其絕對值大于數(shù)組長度，則方法返回 -1绩社，即數(shù)組不會被查找惰匙。
返回值：數(shù)組中最后一個元素的索引，如未找到返回-1铃将。
var array = [2, 5, 9, 2];
var index = array.lastIndexOf(2); // index is 3
index = array.lastIndexOf(7); // index is -1
index = array.lastIndexOf(2, 3); // index is 3
index = array.lastIndexOf(2, 2); // index is 0
index = array.lastIndexOf(2, -2); // index is 0
index = array.lastIndexOf(2, -1); // index is 3
20. map()
創(chuàng)建一個新數(shù)組项鬼，其結(jié)果是該數(shù)組中的每個元素都調(diào)用一個提供的函數(shù)后返回的結(jié)果。
語法：
var new_array = arr.map((currentValue, index, array) => {
// Return element for new_array
}, thisArg)
var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
return num * 2;
});
// doubles數(shù)組的值為： [2, 8, 18]
// numbers數(shù)組未被修改： [1, 4, 9]
21. pop()
從數(shù)組中刪除最后一個元素劲阎，并返回該元素的值绘盟。此方法。
let myFish = ["angel", "clown", "mandarin", "surgeon"];
let popped = myFish.pop();
console.log(myFish); // ["angel", "clown", "mandarin"]
console.log(popped); // surgeon
22. push()
將一個或多個元素添加到數(shù)組的末尾悯仙，并返回該數(shù)組的新長度龄毡。此方法。
var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");
console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total); // 4
23. shift()
從數(shù)組中刪除第一個元素锡垄，并返回該元素的值沦零。此方法。
let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
console.log(myFish); // ["angel", "clown", "mandarin", "surgeon"]
var shifted = myFish.shift();
console.log(myFish); // ["clown", "mandarin", "surgeon"]
console.log('被刪除的元素: ', shifted); // 被刪除的元素: angel
24. unshift()
將一個或多個元素添加到數(shù)組的開頭货岭，并返回該數(shù)組的新長度路操，該方法。
arr.unshift(element1, ..., elementN)
let arr = [1, 2];
arr.unshift(0); // result of the call is 3, which is the new array length
// arr is [0, 1, 2]
arr.unshift(-2, -1); // the new array length is 5
// arr is [-2, -1, 0, 1, 2]
arr.unshift([-4, -3]); // the new array length is 6
// arr is [[-4, -3], -2, -1, 0, 1, 2]
arr.unshift([-7, -6], [-5]); // the new array length is 8
// arr is [ [-7, -6], [-5], [-4, -3], -2, -1, 0, 1, 2 ]
25. reverse()
將數(shù)組中元素的位置顛倒千贯，并返回該數(shù)組屯仗。該方法。
var sourceArray = ['one', 'two', 'three'];
var reverseArray = sourceArray.reverse();
console.log(sourceArray ) // ['three', 'two', 'one']
console.log(sourceArray === reverseArray); // true
26. sort()
用原地算法對數(shù)組的元素進行排序搔谴，并返回數(shù)組魁袜。默認排序順序是在將元素轉(zhuǎn)換為字符串，然后比較它們的UTF-16代碼單元值序列時構(gòu)建的敦第。該方法峰弹。
arr.sort([compareFunction])
參數(shù)：
compareFunction -- 可選。用來指定按某種順序進行排列的函數(shù)芜果。如果省略鞠呈，元素按照轉(zhuǎn)換為的字符串的各個字符的Unicode位點進行排序。
firstEl：第一個用于比較的元素师幕。
secondEl：第二個用于比較的元素粟按。
返回值：排序后的數(shù)組。請注意霹粥，數(shù)組已原地排序灭将，并且不進行復(fù)制。
如果指明了 compareFunction 后控，那么數(shù)組會按照調(diào)用該函數(shù)的返回值排序庙曙。即 a 和 b 是兩個將要被比較的元素：
- 如果 compareFunction(a, b) 小于 0 ，那么 a 會被排列到 b 之前浩淘；
- 如果 compareFunction(a, b) 等于 0 捌朴， a 和 b 的相對位置不變。備注： ECMAScript 標準并不保證這一行為张抄，而且也不是所有瀏覽器都會遵守（例如 Mozilla 在 2003 年之前的版本）砂蔽；
- 如果 compareFunction(a, b) 大于 0 ， b 會被排列到 a 之前署惯。
- compareFunction(a, b) 必須總是對相同的輸入返回相同的比較結(jié)果左驾，否則排序的結(jié)果將是不確定的。
//升序
var numbers = [4, 2, 5, 1, 3];
var num = numbers.sort((a, b) => a - b);
console.log(numbers,num); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
// 降序
var number1 = [4, 2, 5, 1, 3];
var num1 = number1.sort((a, b) => b - a);
console.log(number1,num1); // [5, 4, 3, 2, 1] [5, 4, 3, 2, 1]
var arr = ['s', 2,'d',23];
arr.sort();
console.log(arr); // [2, 23, "d", "s"] 按照ASCII 字符編碼排序极谊。
27. slice()
返回被提取的數(shù)組對象诡右，這一對象是一個由 begin 和 end 決定的原數(shù)組的淺拷貝，包括 begin轻猖，不包括end帆吻。原始數(shù)組不會被改變。
arr.slice([begin[, end]])
參數(shù)：
begin -- 可選咙边。提取起始處的索引猜煮，從該索引開始提取原數(shù)組元素，默認為 0败许。
- 如果該參數(shù)為負數(shù)友瘤，則表示從原數(shù)組中的倒數(shù)第幾個元素開始提取，slice(-2) 表示提取原數(shù)組中的倒數(shù)第二個元素到最后一個元素（包含最后一個元素）檐束。
- 如果省略 begin辫秧，則 slice 從索引 0 開始。如果 begin 大于原數(shù)組的長度被丧，則會返回空數(shù)組盟戏。
end -- 可選。提取終止處的索引甥桂，在該索引處結(jié)束提取原數(shù)組元素柿究，默認為數(shù)組的長度。slice 會提取原數(shù)組中索引從 begin 到 end 的所有元素（包含 begin黄选，但不包含 end）蝇摸。
- slice(1,4) 會提取原數(shù)組中從第二個元素開始一直到第四個元素的所有元素 （索引為 1, 2, 3的元素）婶肩。
- 如果該參數(shù)為負數(shù)， 則它表示在原數(shù)組中的倒數(shù)第幾個元素結(jié)束抽取貌夕。 slice(-2,-1) 表示抽取了原數(shù)組中的倒數(shù)第二個元素到最后一個元素（不包含最后一個元素律歼，也就是只有倒數(shù)第二個元素）。
- 如果 end 被省略啡专，則slice 會一直提取到原數(shù)組末尾险毁。
- 如果 end 大于數(shù)組的長度，slice 也會一直提取到原數(shù)組末尾们童。
var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3);
// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']
28. splice()
通過刪除或替換現(xiàn)有元素或者原地添加新的元素來修改數(shù)組,并以數(shù)組形式返回被修改的內(nèi)容畔况。此方法會。
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
參數(shù)：
start -- 指定修改的開始位置（從0計數(shù)）慧库。如果超出了數(shù)組的長度跷跪，則從數(shù)組末尾開始添加內(nèi)容；如果是負值齐板，則表示從數(shù)組末位開始的第幾位（從-1計數(shù)域庇，這意味著-n是倒數(shù)第n個元素并且等價于array.length-n）；如果負數(shù)的絕對值大于數(shù)組的長度覆积，則表示開始位置為第0位听皿。
deleteCount -- 可選。整數(shù)宽档，表示要移除的數(shù)組元素的個數(shù)尉姨。如果 deleteCount 大于 start 之后的元素的總數(shù)，則從 start 后面的元素都將被刪除（含第 start 位）吗冤。
如果 deleteCount 被省略了又厉，或者它的值大于等于array.length - start(也就是說，如果它大于或者等于start之后的所有元素的數(shù)量)椎瘟，那么start之后數(shù)組的所有元素都會被刪除覆致。
如果 deleteCount 是 0 或者負數(shù)，則不移除元素肺蔚。這種情況下煌妈，至少應(yīng)添加一個新元素。
item1, item2, ... -- 可選宣羊。要添加進數(shù)組的元素,從start 位置開始璧诵。如果不指定，則 splice() 將只刪除數(shù)組元素仇冯。
返回值：由被刪除的元素組成的一個數(shù)組之宿。如果只刪除了一個元素，則返回只包含一個元素的數(shù)組苛坚。如果沒有刪除元素比被，則返回空數(shù)組色难。
//*************刪除
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
var removed = myFish.splice(3, 1);
// myFish: ["angel", "clown", "drum", "sturgeon"]
// removed: ["mandarin"]
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2);
// myFish: ["angel", "clown"]
// removed: ["mandarin", "sturgeon"]
//*************添加
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2, 0, 'drum', 'guitar');
// myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
// removed: []
//*************替換
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2, 1, 'drum', );
// myFish: ["angel", "clown", "drum", "sturgeon"]
// removed: ["mandarin"]
29. reduce()
對數(shù)組中的每個元素執(zhí)行一個由您提供的reducer函數(shù)(升序執(zhí)行)，將其結(jié)果匯總為單個返回值等缀。
語法：
arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
reducer 函數(shù)接收4個參數(shù):
- Accumulator (acc) (累計器) -- 累計回調(diào)的返回值; 它是上一次調(diào)用回調(diào)時返回的累積值枷莉，或initialValue（見于下方）。
- Current Value (cur) (當前值)
- Current Index (idx) (當前索引) -- 數(shù)組中正在處理的當前元素的索引项滑。 如果提供了initialValue，則起始索引號為0涯贞，否則為1枪狂。
-
Source Array (src) (源數(shù)組) -- 調(diào)用reduce()的數(shù)組
reducer 函數(shù)的返回值分配給累計器，該返回值在數(shù)組的每個迭代中被記住宋渔，并最后成為最終的單個結(jié)果值州疾。
回調(diào)函數(shù)第一次執(zhí)行時，accumulator 和currentValue的取值有兩種情況：如果調(diào)用reduce()時提供了initialValue皇拣，accumulator取值為initialValue严蓖，currentValue取數(shù)組中的第一個值；如果沒有提供 initialValue氧急，那么accumulator取數(shù)組中的第一個值颗胡，currentValue取數(shù)組中的第二個值。
注意：如果沒有提供initialValue吩坝，reduce 會從索引1的地方開始執(zhí)行 callback 方法毒姨，跳過第一個索引。如果提供initialValue钉寝，從索引0開始弧呐。
const arr = [13, 2, 23, 4];
const val = arr.reduce((acc, curVal, i) => {
console.log(acc); // 13 13 23
console.log(curVal); // 2 23 4
console.log(i); // 1 2 3
return Math.max(acc,curVal);
});
console.log(val); // 23
30. toString()
返回一個字符串，表示指定的數(shù)組及其元素嵌纲。
var array1 = [1, 2, 'a', '1a'];
console.log(array1.toString()); // 1,2,a,1a
console.log(array1); // [1, 2, "a", "1a"]
