【12】數組的常用方法有那些？ · 高先生_前端題庫

**9改變8不變12遍歷** ## 改變原數組的方法(9個): ``` let a = [1,2,3]; ``` ### ES5: a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort() ## ES6: a.copyWithin() / a.fill ## 不改變原數組的方法(8個): ### ES5： join、toLocateString、toStrigin、slice、cancat、indexOf、lastIndexOf、 ### ES7： includes ## 遍歷方法(12個): ### ES5： forEach、every 、some、 fliter、map、reduce、reduceRight、 ### ES6： find、findIndex、keys、values、entries # 各方法詳解 ## 改變原數組的方法(9個): let a = [1,2,3]; ES5: a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort() ES6: a.copyWithin() / a.fill 對于這些能夠改變原數組的方法，要注意避免在循環遍歷中改變原數組的選項，比如: 改變數組的長度，導致遍歷的長度出現問題。 pop() 刪除一個數組中的最后的一個元素定義: pop() 方法刪除一個數組中的最后的一個元素，并且返回這個元素。參數: 無。 ``` let a = [1,2,3]; let item = a.pop(); // 3 console.log(a); // [1,2] ``` shift() 刪除數組的第一個元素定義: shift()方法刪除數組的第一個元素，并返回這個元素。參數: 無。 ``` let a = [1,2,3]; let item = a.shift(); // 1 console.log(a); // [2,3] ``` push() 向數組的末尾添加元素定義：push() 方法可向數組的末尾添加一個或多個元素，并返回新的長度。參數: item1, item2, …, itemX ,要添加到數組末尾的元素 ``` let a = [1,2,3]; let item = a.push('末尾'); // 4 console.log(a); // [1,2,3,'末尾'] ``` unshift() 定義：unshift() 方法可向數組的開頭添加一個或更多元素，并返回新的長度。參數: item1, item2, …, itemX ,要添加到數組開頭的元素 ``` let a = [1,2,3]; let item = a.unshift('開頭'); // 4 console.log(a); // ['開頭',1,2,3] ``` reverse() 顛倒數組中元素的順序定義: reverse() 方法用于顛倒數組中元素的順序。參數: 無 let a = [1,2,3]; a.reverse(); console.log(a); // [3,2,1] splice() 添加/刪除數組元素定義： splice() 方法向/從數組中添加/刪除項目，然后返回被刪除的項目語法： array.splice(index,howmany,item1,.....,itemX) 參數: index：必需。整數，規定添加/刪除項目的位置，使用負數可從數組結尾處規定位置。 howmany：必需。要刪除的項目數量。如果設置為 0，則不會刪除項目。 item1, …, itemX：可選。向數組添加的新項目。返回值: 如果有元素被刪除,返回包含被刪除項目的新數組。 ``` let a = [1, 2, 3, 4, 5, 6, 7]; let item = a.splice(0, 3); // [1,2,3] console.log(a); // [4,5,6,7] // 從數組下標0開始，刪除3個元素 let item = a.splice(-1, 3); // [7] ``` // 從最后一個元素開始刪除3個元素，因為最后一個元素，所以只刪除了7 eg2: 刪除并添加 ``` let a = [1, 2, 3, 4, 5, 6, 7]; let item = a.splice(0,3,'添加'); // [1,2,3] console.log(a); // ['添加',4,5,6,7] // 從數組下標0開始，刪除3個元素，并添加元素'添加' let b = [1, 2, 3, 4, 5, 6, 7]; let item = b.splice(-2,3,'添加1','添加2'); // [6,7] console.log(b); // [1,2,3,4,5,'添加1','添加2'] ``` // 從數組最后第二個元素開始，刪除3個元素，并添加兩個元素'添加1'、'添加2' eg3: 不刪除只添加: ``` let a = [1, 2, 3, 4, 5, 6, 7]; let item = a.splice(0,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數組 console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7] let b = [1, 2, 3, 4, 5, 6, 7]; let item = b.splice(-1,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數組 console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最后一個元素的前面添加兩個元素 ``` 從上述三個栗子可以得出: 數組如果元素不夠，會刪除到最后一個元素為止操作的元素，包括開始的那個元素可以添加很多個元素添加是在開始的元素前面添加的 sort() 數組排序定義: sort()方法對數組元素進行排序，并返回這個數組。參數可選: 規定排序順序的比較函數。默認情況下sort()方法沒有傳比較函數的話，默認按字母升序，如果不是元素不是字符串的話，會調用toString()方法將元素轉化為字符串的Unicode(萬國碼)位點，然后再比較字符。 // 字符串排列看起來很正常 ``` var a = ["Banana", "Orange", "Apple", "Mango"]; a.sort(); // ["Apple","Banana","Mango","Orange"] ``` // 數字排序的時候因為轉換成Unicode字符串之后，有些數字會比較大會排在后面這顯然不是我們想要的 ``` var a = [10, 1, 3, 20,25,8]; console.log(a.sort()) // [1,10,20,25,3,8]; ``` 比較函數的兩個參數： sort的比較函數有兩個默認參數，要在函數中接收這兩個參數，這兩個參數是數組中兩個要比較的元素，通常我們用 a 和 b 接收兩個將要比較的元素：若比較函數返回值<0，那么a將排到b的前面; 若比較函數返回值=0，那么a 和 b 相對位置不變；若比較函數返回值>0，那么b 排在a 將的前面；對于sort()方法更深層級的內部實現以及處理機制可以看一下這篇文章深入了解javascript的sort方法 sort排序常見用法： 1、數組元素為數字的升序、降序: ``` var array = [10, 1, 3, 4,20,4,25,8]; // 升序 a-b < 0 a將排到b的前面，按照a的大小來排序的 // 比如被減數a是10，減數是20 10-20 < 0 被減數a(10)在減數b(20)前面 array.sort(function(a,b){ return a-b; }); console.log(array); // [1,3,4,4,8,10,20,25]; // 降序被減數和減數調換了 20-10>0 被減數b(20)在減數a(10)的前面 array.sort(function(a,b){ return b-a; }); console.log(array); // [25,20,10,8,4,4,3,1]; ``` 2、數組多條件排序 ``` var array = [{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}]; array.sort(function(a,b){ if(a.id === b.id){// 如果id的值相等，按照age的值降序 return b.age - a.age }else{ // 如果id的值不相等，按照id的值升序 return a.id - b.id } }) // [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}] ``` 3、自定義比較函數，天空才是你的極限類似的：運用好返回值，我們可以寫出任意符合自己需求的比較函數 ``` var array = [{name:'Koro1'},{name:'Koro1'},{name:'OB'},{name:'Koro1'},{name:'OB'},{name:'OB'}]; array.sort(function(a,b){ if(a.name === 'Koro1'){// 如果name是'Koro1' 返回-1 ，-1<0 a排在b的前面 return -1 }else{ // 如果不是的話，a排在b的后面 return 1 } }) // [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}] ``` ES6: copyWithin() 指定位置的成員復制到其他位置定義: 在當前數組內部，將指定位置的成員復制到其他位置,并返回這個數組。語法: ``` array.copyWithin(target, start = 0, end = this.length) ``` 參數: 三個參數都是數值，如果不是，會自動轉為數值. target（必需）：從該位置開始替換數據。如果為負值，表示倒數。 start（可選）：從該位置開始讀取數據，默認為 0。如果為負值，表示倒數。 end（可選）：到該位置前停止讀取數據，默認等于數組長度。使用負數可從數組結尾處規定位置。瀏覽器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持 ``` // -2相當于3號位，-1相當于4號位 [1, 2, 3, 4, 5].copyWithin(0, -2, -1) // [4, 2, 3, 4, 5] var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5'] // 2位置開始被替換,3位置開始讀取要替換的 5位置前面停止替換 a.copyWithin(2,3,5) // ["OB1","Koro1","Koro2","OB3","OB3","Koro3","OB4","Koro4","OB5","Koro5"] ``` 從上述栗子: 第一個參數是開始被替換的元素位置要替換數據的位置范圍:從第二個參數是開始讀取的元素，在第三個參數前面一個元素停止讀取數組的長度不會改變讀了幾個元素就從開始被替換的地方替換幾個元素 ES6: fill() 填充數組定義: 使用給定值，填充一個數組。參數: 第一個元素(必須): 要填充數組的值第二個元素(可選): 填充的開始位置,默認值為0 第三個元素(可選)：填充的結束位置，默認是為this.length ``` ['a', 'b', 'c'].fill(7) // [7, 7, 7] ['a', 'b', 'c'].fill(7, 1, 2) // ['a', 7, 'c'] ``` # 不改變原數組的方法(8個): ES5： join、toLocateString、toStrigin、slice、cancat、indexOf、lastIndexOf、 ES7： includes join() 數組轉字符串定義: join() 方法用于把數組中的所有元素通過指定的分隔符進行分隔放入一個字符串，返回生成的字符串。語法: ``` array.join(str) ``` 參數: str(可選): 指定要使用的分隔符，默認使用逗號作為分隔符。 ``` let a= ['hello','world']; let str=a.join(); // 'hello,world' let str2=a.join('+'); // 'hello+world' ``` 使用join方法或者下文說到的toString方法時，當數組中的元素也是數組或者是對象時會出現什么情況？ ``` let a= [['OBKoro1','23'],'test']; let str1=a.join(); // OBKoro1,23,test let b= [{name:'OBKoro1',age:'23'},'test']; let str2 = b.join(); // [object Object],test // 對象轉字符串推薦JSON.stringify(obj); ``` 所以，join()/toString()方法在數組元素是數組的時候，會將里面的數組也調用join()/toString(),如果是對象的話，對象會被轉為[object Object]字符串。 toLocaleString() 數組轉字符串定義: 返回一個表示數組元素的字符串。該字符串由數組中的每個元素的 toLocaleString() 返回值經調用 join() 方法連接（由逗號隔開）組成。語法: array.toLocaleString() 參數：無。 ``` let a=[{name:'OBKoro1'},23,'abcd',new Date()]; let str=a.toLocaleString(); // [object Object],23,abcd,2018/5/28 下午1:52:20 ``` 如上述栗子：調用數組的toLocaleString方法，數組中的每個元素都會調用自身的toLocaleString方法，對象調用對象的toLocaleString,Date調用Date的toLocaleString。 toString() 數組轉字符串不推薦定義: toString() 方法可把數組轉換為由逗號鏈接起來的字符串。語法: array.toString() 參數: 無。該方法的效果和join方法一樣，都是用于數組轉字符串的，但是與join方法相比沒有優勢，也不能自定義字符串的分隔符，因此不推薦使用。值得注意的是：當數組和字符串操作的時候，js 會調用這個方法將數組自動轉換成字符串 ``` let b= [ 'toString','演示'].toString(); // toString,演示 let a= ['調用toString','連接在我后面']+'啦啦啦'; // 調用toString,連接在我后面啦啦啦 ``` slice() 淺拷貝數組的元素定義：方法返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組對象，且原數組不會被修改。注意：字符串也有一個slice() 方法是用來提取字符串的，不要弄混了。語法: ``` array.slice(begin, end); ``` 參數: begin(可選): 索引數值,接受負值，從該索引處開始提取原數組中的元素,默認值為0。 end(可選):索引數值(不包括),接受負值，在該索引處前結束提取原數組元素，默認值為數組末尾(包括最后一個元素)。 ``` let a= ['hello','world']; let b=a.slice(0,1); // ['hello'] a[0]='改變原數組'; console.log(a,b); // ['改變原數組','world'] ['hello'] b[0]='改變拷貝的數組'; console.log(a,b); // ['改變原數組','world'] ['改變拷貝的數組'] ``` 如上：新數組是淺拷貝的，元素是簡單數據類型，改變之后不會互相干擾。如果是復雜數據類型(對象,數組)的話，改變其中一個，另外一個也會改變。 ``` let a= [{name:'OBKoro1'}]; let b=a.slice(); console.log(b,a); // [{"name":"OBKoro1"}] [{"name":"OBKoro1"}] // a[0].name='改變原數組'; // console.log(b,a); // [{"name":"改變原數組"}] [{"name":"改變原數組"}] // b[0].name='改變拷貝數組',b[0].koro='改變拷貝數組'; // [{"name":"改變拷貝數組","koro":"改變拷貝數組"}] [{"name":"改變拷貝數組","koro":"改變拷貝數組"}] ``` 原因在定義上面說過了的：slice()是淺拷貝，對于復雜的數據類型淺拷貝，拷貝的只是指向原數組的指針，所以無論改變原數組，還是淺拷貝的數組，都是改變原數組的數據。 cancat 定義：方法用于合并兩個或多個數組，返回一個新數組。語法： ``` var newArr =oldArray.concat(arrayX,arrayX,......,arrayX) ``` 參數： arrayX（必須）：該參數可以是具體的值，也可以是數組對象。可以是任意多個。 ``` let a = [1, 2, 3]; let b = [4, 5, 6]; //連接兩個數組 let newVal=a.concat(b); // [1,2,3,4,5,6] // 連接三個數組 let c = [7, 8, 9] let newVal2 = a.concat(b, c); // [1,2,3,4,5,6,7,8,9] ``` // 添加元素 let newVal3 = a.concat('添加元素',b, c,'再加一個'); // [1,2,3,"添加元素",4,5,6,7,8,9,"再加一個"] // 合并嵌套數組會淺拷貝嵌套數組 ``` let d = [1,2 ]; let f = [3,[4]]; let newVal4 = d.concat(f); // [1,2,3,[4]] ``` ES6擴展運算符...合并數組：因為ES6的語法更簡潔易懂，所以現在合并數組我大部分采用...來處理，...運算符可以實現cancat的每個栗子，且更簡潔和具有高度自定義數組元素位置的效果。 ``` let a = [2, 3, 4, 5] let b = [ 4,...a, 4, 4] console.log(a,b); // [2, 3, 4, 5] [4,2,3,4,5,4,4] ``` indexOf() 查找數組是否存在某個元素，返回下標定義: 返回在數組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1。語法: ``` array.indexOf(searchElement,fromIndex) ``` 參數: searchElement(必須):被查找的元素 fromIndex(可選):開始查找的位置(不能大于等于數組的長度，返回-1)，接受負值，默認值為0。嚴格相等的搜索: 數組的indexOf搜索跟字符串的indexOf不一樣,數組的indexOf使用嚴格相等===搜索元素，即數組元素要完全匹配才能搜索成功。注意：indexOf()不能識別NaN ``` let a=['啦啦',2,4,24,NaN] console.log(a.indexOf('啦')); // -1 console.log(a.indexOf('NaN')); // -1 console.log(a.indexOf('啦啦')); // 0 ``` 使用場景：數組去重根據獲取的數組下標執行操作，改變數組中的值等。判斷是否存在，執行操作。 lastIndexOf() 查找指定元素在數組中的最后一個位置定義: 方法返回指定元素,在數組中的最后一個的索引，如果不存在則返回 -1。（從數組后面往前查找）語法: ``` arr.lastIndexOf(searchElement,fromIndex) ``` 參數: searchElement(必須): 被查找的元素 fromIndex(可選): 逆向查找開始位置，默認值數組的長度-1，即查找整個數組。關于fromIndex有三個規則: 正值。如果該值大于或等于數組的長度，則整個數組會被查找。負值。將其視為從數組末尾向前的偏移。(比如-2，從數組最后第二個元素開始往前查找) 負值。其絕對值大于數組長度，則方法返回 -1，即數組不會被查找。 ``` let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 數組長度為10 // let b=a.lastIndexOf('Koro1',4); // 從下標4開始往前找返回下標2 // let b=a.lastIndexOf('Koro1',100); // 大于或數組的長度查找整個數組返回9 // let b=a.lastIndexOf('Koro1',-11); // -1 數組不會被查找 let b=a.lastIndexOf('Koro1',-9); // 從第二個元素4往前查找，沒有找到返回-1 ``` ES7 includes() 查找數組是否包含某個元素返回布爾定義：返回一個布爾值，表示某個數組是否包含給定的值語法： ``` array.includes(searchElement,fromIndex=0) ``` 參數： searchElement(必須):被查找的元素 fromIndex(可選):默認值為0，參數表示搜索的起始位置，接受負值。正值超過數組長度，數組不會被搜索，返回false。負值絕對值超過長數組度，重置從0開始搜索。 includes方法是為了彌補indexOf方法的缺陷而出現的: indexOf方法不能識別NaN indexOf方法檢查是否包含某個值不夠語義化，需要判斷是否不等于-1，表達不夠直觀 eg: ``` let a=['OB','Koro1',1,NaN]; // let b=a.includes(NaN); // true 識別NaN // let b=a.includes('Koro1',100); // false 超過數組長度不搜索 // let b=a.includes('Koro1',-3); // true 從倒數第三個元素開始搜索 // let b=a.includes('Koro1',-100); // true 負值絕對值超過數組長度，搜索整個數組 ``` 兼容性(MDN): chrome47, Firefox 43,Edge 14,Opera 34, Safari 9,IE 未實現。 # 遍歷方法(12個): js中遍歷數組并不會改變原始數組的方法總共有12個: ES5： forEach、every 、some、 fliter、map、reduce、reduceRight、 ES6： find、findIndex、keys、values、entries 關于遍歷：盡量不要在遍歷的時候，修改后面要遍歷的值盡量不要在遍歷的時候修改數組的長度（刪除/添加） forEach 定義: 按升序為數組中含有效值的每一項執行一次回調函數。語法： ``` array.forEach(function(currentValue, index, arr), thisValue) ``` 參數: function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 hisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined 關于forEach()你要知道：無法中途退出循環，只能用return退出本次回調，進行下一次回調。它總是返回 undefined值,即使你return了一個值。下面類似語法同樣適用這些規則 1. 對于空數組是不會執行回調函數的 2. 對于已在迭代過程中刪除的元素，或者空元素會跳過回調函數 3. 遍歷次數再第一次循環前就會確定，再添加到數組中的元素不會被遍歷。 4. 如果已經存在的值被改變，則傳遞給 callback 的值是遍歷到他們那一刻的值。 ``` let a = [1, 2, ,3]; // 最后第二個元素是空的，不會遍歷(undefined、null會遍歷) let obj = { name: 'OBKoro1' }; let result = a.forEach(function (value, index, array) { a[3] = '改變元素'; a.push('添加到尾端，不會被遍歷') console.log(value, 'forEach傳遞的第一個參數'); // 分別打印 1 ,2 ,改變元素 console.log(this.name); // OBKoro1 打印三次 this綁定在obj對象上 // break; // break會報錯 return value; // return只能結束本次回調會執行下次回調 console.log('不會執行，因為return 會執行下一次循環回調') }, obj); console.log(result); // 即使return了一個值,也還是返回undefined ``` // 回調函數也接受接頭函數寫法 every 檢測數組所有元素是否都符合判斷條件定義: 方法用于檢測數組所有元素是否都符合函數定義的條件語法： ``` array.every(function(currentValue, index, arr), thisValue) ``` 參數:(這幾個方法的參數，語法都類似) function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 thisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined 方法返回值規則: 如果數組中檢測到有一個元素不滿足，則整個表達式返回 false，且剩余的元素不會再進行檢測。如果所有元素都滿足條件，則返回 true。= eg: ``` function isBigEnough(element, index, array) { return element >= 10; // 判斷數組中的所有元素是否都大于10 } let result = [12, 5, 8, 130, 44].every(isBigEnough); // false let result = [12, 54, 18, 130, 44].every(isBigEnough); // true // 接受箭頭函數寫法 [12, 5, 8, 130, 44].every(x => x >= 10); // false [12, 54, 18, 130, 44].every(x => x >= 10); // true ``` some 數組中的是否有滿足判斷條件的元素定義：數組中的是否有滿足判斷條件的元素語法： ``` array.some(function(currentValue, index, arr), thisValue) ``` 參數:(這幾個方法的參數，語法都類似) function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 thisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined 方法返回值規則：如果有一個元素滿足條件，則表達式返回true, 剩余的元素不會再執行檢測。如果沒有滿足條件的元素，則返回false。 ``` function isBigEnough(element, index, array) { return (element >= 10); //數組中是否有一個元素大于 10 } let result = [2, 5, 8, 1, 4].some(isBigEnough); // false let result = [12, 5, 8, 1, 4].some(isBigEnough); // true ``` filter 過濾原始數組，返回新數組定義: 返回一個新數組, 其包含通過所提供函數實現的測試的所有元素。語法： let new_array = arr.filter(function(currentValue, index, arr), thisArg) 參數:(這幾個方法的參數，語法都類似) function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 thisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined ``` let a = [32, 33, 16, 40]; let result = a.filter(function (value, index, array) { return value >= 18; // 返回a數組中所有大于18的元素 }); console.log(result,a);// [32,33,40] [32,33,16,40] ``` map 對數組中的每個元素進行處理，返回新的數組定義：創建一個新數組，其結果是該數組中的每個元素都調用一個提供的函數后返回的結果。語法： ``` let new_array = arr.map(function(currentValue, index, arr), thisArg) ``` 參數:(這幾個方法的參數，語法都類似) function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 thisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined ``` let a = ['1','2','3','4']; let result = a.map(function (value, index, array) { return value + '新數組的新元素' }); console.log(result, a); ``` // ["1新數組的新元素","2新數組的新元素","3新數組的新元素","4新數組的新元素"] ["1","2","3","4"] reduce 為數組提供累加器，合并為一個值定義：reduce() 方法對累加器和數組中的每個元素（從左到右）應用一個函數，最終合并為一個值。語法： ``` array.reduce(function(total, currentValue, currentIndex, arr), initialValue) ``` 參數： function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. total(必須)，初始值, 或者上一次調用回調返回的值 2. currentValue(必須),數組當前元素的值 3. index(可選), 當前元素的索引值 4. arr(可選),數組對象本身 initialValue(可選): 指定第一次回調的第一個參數。回調第一次執行時: 如果 initialValue 在調用 reduce 時被提供，那么第一個 total 將等于 initialValue，此時 currentValue 等于數組中的第一個值；如果 initialValue 未被提供，那么 total 等于數組中的第一個值，currentValue 等于數組中的第二個值。此時如果數組為空，那么將拋出 TypeError。如果數組僅有一個元素，并且沒有提供 initialValue，或提供了 initialValue 但數組為空，那么回調不會被執行，數組的唯一值將被返回。 eg: // 數組求和 ``` let sum = [0, 1, 2, 3].reduce(function (a, b) { return a + b; }, 0); // 6 // 將二維數組轉化為一維將數組元素展開 let flattened = [[0, 1], [2, 3], [4, 5]].reduce( (a, b) => a.concat(b), [] ); // [0, 1, 2, 3, 4, 5] ``` reduceRight 從右至左累加這個方法除了與reduce執行方向相反外，其他完全與其一致，請參考上述 reduce 方法介紹。 ES6：find()& findIndex() 根據條件找到數組成員 find()定義：用于找出第一個符合條件的數組成員，并返回該成員，如果沒有符合條件的成員，則返回undefined。 findIndex()定義：返回第一個符合條件的數組成員的位置，如果所有成員都不符合條件，則返回-1。這兩個方法語法： ``` let new_array = arr.find(function(currentValue, index, arr), thisArg) let new_array = arr.findIndex(function(currentValue, index, arr), thisArg) ``` 參數:(這幾個方法的參數，語法都類似) function(必須): 數組中每個元素需要調用的函數。 // 回調函數的參數 1. currentValue(必須),數組當前元素的值 2. index(可選), 當前元素的索引值 3. arr(可選),數組對象本身 thisValue(可選): 當執行回調函數時this綁定對象的值，默認值為undefined 這兩個方法都可以識別NaN,彌補了indexOf的不足. ``` // find let a = [1, 4, -5, 10].find((n) => n < 0); // 返回元素-5 let b = [1, 4, -5, 10,NaN].find((n) => Object.is(NaN, n)); // 返回元素NaN // findIndex let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回索引2 let b = [1, 4, -5, 10,NaN].findIndex((n) => Object.is(NaN, n)); // 返回索引4 ``` 瀏覽器兼容(MDN):Chrome 45,Firefox 25,Opera 32, Safari 8, Edge yes, ES6 keys()&values()&entries() 遍歷鍵名、遍歷鍵值、遍歷鍵名+鍵值定義：三個方法都返回一個新的 Array Iterator 對象，對象根據方法不同包含不同的值。語法： array.keys() array.values() array.entries() 參數：無。 ``` for (let index of ['a', 'b'].keys()) { console.log(index); } for (let elem of ['a', 'b'].values()) { console.log(elem); } // 'a' // 'b' for (let [index, elem] of ['a', 'b'].entries()) { console.log(index, elem); } // 0 "a" // 1 "b" ``` 在for..of中如果遍歷中途要退出，可以使用break退出循環。如果不使用for...of循環，可以手動調用遍歷器對象的next方法，進行遍歷: ``` let letter = ['a', 'b', 'c']; let entries = letter.entries(); console.log(entries.next().value); // [0, 'a'] console.log(entries.next().value); // [1, 'b'] console.log(entries.next().value); // [2, 'c'] ``` entries()瀏覽器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 7.1 keys()瀏覽器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 8, 注意:目前只有Safari 9支持,，其他瀏覽器未實現，babel轉碼器也還未實現