<meta charset="utf-8">
需求：
js數組(Array)方法彙總
索引：
對數組方法的學習和彙總，分為三大類：
一，改變原數組的方法(10種)：
1，arr[key]='tom';
2，arr.splice();
3，arr.reverse();
4，arr.sort();
5，arr.push();
6，arr.pop();
7，arr.unshift();
8，arr.shift();
9，arr.fill();
10，arr.copyWithin();
二，不動原數組，隻産生新資料的方法(14種)：
1，arr.concat();
2，arr.slice();
3，arr.join();
4，arr.toString();
5，arr.map();
6，arr.filter();
7，arr.reduce()和arr.reduceRight();
8，arr.find();
9，Array.from();
10，Array.of();
11，Object.keys(arr);
12，arr.values();
13，arr.keys();
14，arr.entries();
三，不動原數組，隻依據原數組進行判斷/處理的方法(10種)：
1，arr.forEach()---周遊方法1;
2，for()---周遊方法2;
3，for...of....---周遊方法3;
4，for...in...---周遊方法4;
5，...(spread);
6，arr.indexOf()||arr.lastIndexOf();
7，arr.every()||arr.some();
8，Array.isArray();
9，arr.includes();
10，arr.findIndex();
正文：
一，改變原數組的方法
1，arr[key]='tom';依據下标直接指派
代碼如下，說明一點：索引和關聯數組不是互斥的，這裡為了友善說明定義了兩個空數組，實際上，可以同時用數字和字元串作為下标為同一個數組指派；
//定義一個空數組
let indexArr=[];
//以索引數組指派方式
indexArr[0]='tom';
console.log(indexArr);//['tom']
//定義一個空數組
let associativeArr=[];
//以關聯數組方式指派
associativeArr['age']=30;
console.log(associativeArr);//[age:30]
image
2，arr.splice()
(1)作用：允許從指定的數組中，删除一部分元素，同時還可以添加另外一部分元素;
(2)文法：var res=數組名.splice(start,count,e1,e2,e3)；
(3)文法解釋：start:開始删除和(或)添加元素的位置；count：删除的數量，0表示不删除任何元素，省略表示從開始位置全部删除；e1,e2,e3:新添加的元素；
(4)傳回值：傳回的是删除的元素組成的數組，原數組會被删除對應的元素；
(5)示例代碼：
// 定義一個數組
let arr=[1,2,3,4,5,6];
// 用splice方法處理
let res=arr.splice(1,2,'new1','new2','new3');
// 檢視傳回值
console.log('res',res);// [2,3]
// 檢視修改後的數組
console.log('arr',arr);// [1, "new1", "new2", "new3", 4, 5, 6]
// 驗證為count為0的情況
let newRes=arr.splice(1,0);
console.log(newRes);// []
console.log(arr);// [1, "new1", "new2", "new3", 4, 5, 6]
// 驗證count空着的情況
let myNewRes=arr.splice(1);
console.log(myNewRes);// ["new1", "new2", "new3", 4, 5, 6]
console.log(arr);// [1]
image
3,arr.reverse()
(1)作用：将一個數組反轉(次序反轉);
(2)文法：var res=數組名.reverse()；
(3)文法解釋：#；
(4)傳回值：該函數會改變原有數組，傳回的時反轉後的新數組；
(5)示例代碼：
let arr=[1,2,3,4,5,6];
let res=arr.reverse();
console.log(res);// [6, 5, 4, 3, 2, 1]
console.log(arr);// [6, 5, 4, 3, 2, 1]
image
4,arr.sort()
(1)作用：将數組中的元素排序;
(2)文法：arr.sort()；
(3)文法解釋：小括号内可以帶參數，如果不帶參數，預設依照字母表順序排列，如果數組中有unefined值，将會被排到數組尾部；小括号内也可以帶一個函數作為參數:
function(a,b){
// value是a和b比較的結果
return value;
}
image
函數解釋：a，b分别代表數組的兩個元素，數組元素采用冒泡方法比較，每個元素至少會比較一次；value值如果小于0,從小到大排序，value如果大于0,從大到小排序，value如果等于0，不動順序(如果是a===b的情況value需要等于0,其實可以忽略這個判斷)；
函數個人了解如下,僅供參考，完整用例見(5)示例代碼:
// 從小到大排序
function(a,b){
// 個人來了解：如果a小于b,a-b強制等于-1=>a小于b,a排前面(升序)
// 基于a-b的判斷，結果可以強制定義，依據定義的結果，小值永遠在前
if(a<b)return -1;
return 1;
}
// 從大到小排序
function(a,b){
// 個人來了解：如果a小于b,a-b強制等于1=>a大于b,b排前面(降序)
// 基于a-b的判斷，結果可以強制定義，依據定義的結果，小值永遠在前
if(a<b)return 1;
return -1;
}
image
(4)傳回值：傳回排序後的數組，注意undefined值總會被預設排在最後，無論升序還是降序；
(5)示例代碼：
let arr=['b','c','a',undefined,'e','d'];
// 不帶參數排序
let res=arr.sort();
// 驗證傳回值
console.log(res);// ["a", "b", "c", "d", "e",undefined]
// 驗證原數組
console.log(arr);// ["a", "b", "c", "d", "e",undefined]
// 驗證傳回值是否指向原數組
console.log(res===arr); // true
// 驗證排序規則-從小到大
let arr1=['b','c','a',undefined,'e','d'];
arr1.sort((a,b)=>{
if(a<b)return -1;
return 1;
})
console.log(arr1);// ["a", "b", "c", "d", "e", undefined]
// 驗證排序規則-從大到小
let arr1=['b','c','a',undefined,'e','d'];
arr1.sort((a,b)=>{
if(a<b)return 1;
return -1;
})
console.log(arr1);// ["e", "d", "c", "b", "a", undefined]
// 讓某個值排在第一位比如'd'
// 注意一個現象:如果要求'd'在第一位，而其他元素排序不變，在元素偏多時(比如10個以上)
// 'd'在第一位不會出問題，但是其他元素的排序可能不穩定
let arr=['c','b','a','d','e'];
arr.sort((a,b)=>{
// 個人來了解：如果a是‘d’,a-b強制等于-1=>a小于b,a排前面
if(a==='d')return -1;
// 個人了解：如果b是‘d’，a-b強制等于1=>b小于a,b排前面
if(b==='d')return 1;
return 0;
})
console.log(arr); // ["d", "c", "b", "a", "e"]
image
5,arr.push()
(1)作用：在數組尾部(棧頂)添加新元素;
(2)文法：var res=數組名.push(n)；
(3)文法解釋：n是需要插入數組的元素；
(4)傳回值：更新後的原數組的長度；
(5)示例代碼：
let arr=[10,20,30];
let res=arr.push(40);
console.log(arr);// [10, 20, 30, 40]
console.log(res);// 4
image
6,arr.pop()
(1)作用：删除數組尾部(棧頂)的元素;
(2)文法：var res=數組名.push()；
(3)文法解釋：#；
(4)傳回值：被删除的元素；
(5)示例代碼：
let arr=[10,20,30];
let res=arr.pop();
console.log(arr);// [10, 20]
console.log(res);// 30
image
7,arr.unshift()
(1)作用：在數組頭部(棧底)添加新元素;
(2)文法：var res=數組名.unshift(n)；
(3)文法解釋：n是需要插入數組的元素；
(4)傳回值：更新後的原數組的長度；
(5)示例代碼：
let arr=[10,20,30];
let res=arr.unshift(40);
console.log(arr);// [40, 10, 20, 30]
console.log(res);// 4
image
8,arr.shift()
(1)作用：删除數組頭部(棧底)的元素;
(2)文法：var res=數組名.shift()；
(3)文法解釋：#；
(4)傳回值：被删除的元素；
(5)示例代碼：
let arr=[10,20,30];
let res=arr.shift();
console.log(arr);// [20, 30]
console.log(res);// 10
image
9,arr.fill()
(1)作用：用一個固定值填充一個數組中從起始索引到終止索引内的全部元素；
(2)文法：arr.fill(value,start,end);
(3)文法解釋：value某個值，start起始下标，end結束下标；
(4)傳回值：修改後的原數組；
(5)示例代碼：
let arr=[1,2,3,4,5,6,7,8,9];
const res=arr.fill('tom',2,14);
console.log(res);// [1, 2, "tom", "tom", "tom", "tom", "tom", "tom", "tom"]
console.log(arr);// [1, 2, "tom", "tom", "tom", "tom", "tom", "tom", "tom"]
console.log(res===arr);// true
image
10,arr.copyWithin()
(1)作用：淺拷貝數組的部分元素到同一數組的不同位置，且不改變數組的長度；
(2)文法：arr.copyWithin(target,start,end);
(3)文法解釋：target---複制序列即将覆寫元素的目标位置，如果是負數，target 将從末尾開始計算，如果 target 大于等于 arr.length，将會不發生拷貝，如果 target 在 start 之後，複制的序列将被修改以符合 arr.length；start 被複制元素的起始位置，如果是負數，start 将從末尾開始計算，如果 start 被忽略，copyWithin 将會從0開始複制；end 被複制元素的結束位置，如果是負數，end 将從末尾開始計算，如果 end 被忽略，copyWithin 将會複制到 arr.length；以上位置遵循數組索引規則(即位于元素的左下角)；
(4)傳回值：修改後的原數組；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.copyWithin(0,1,3)
console.log(res);// [2, 3, 3, 4, 5, 6, 7, 8, 9]
console.log(res===arr);// true
image
二，不動原數組，隻産生新資料的方法
1,arr.concat()
(1)作用：拼接兩個或多個數組；
(2)文法：let res=數組名.concat(arr1,arr2,arr3.......);
(3文法解釋：arr指代數組；
(4)傳回值：拼接後的新數組；
(5)示例代碼：
const arr=["中國","俄羅斯","英國"];
const arr1=["日本","南韓","北韓"];
const arr2=["美國","巴西","西班牙"];
const res=arr.concat(arr1,arr2);
console.log(res);// ["中國", "俄羅斯", "英國", "日本", "南韓", "北韓", "美國", "巴西", "西班牙"]
console.log(arr);// ["中國", "俄羅斯", "英國"]
image
2,arr.slice()
(1)作用：用來截取子數組，從指定的數組中，截取幾個連續的元素，組成一個新數組；
(2)文法：let res=數組名.slice(start,[end]);
(3)文法解釋：start截取的開始下标，end截取的結束下标(可省略，如果省略，一直截取到數組末尾)，[]表示可以省略；
(4)傳回值：截取的元素組成的新數組；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.slice(2,5);
console.log(res);// [3, 4, 5]
console.log(arr);// [1, 2, 3, 4, 5, 6, 7, 8, 9]
image
3，arr.join()
(1)作用：将數組的元素值通過指定的字元連接配接到一起，并組成一個新的字元串；
(2)文法：let res=arr.join(str);
(3)文法解釋：str指代一個字元串；
(4)傳回值：傳回數組元素加分割字元串組成的一個新數組；和字元串方法arr.split(str)有互反的作用；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.join('-');
console.log(res);// 1-2-3-4-5-6-7-8-9
console.log(arr);// [1, 2, 3, 4, 5, 6, 7, 8, 9]
const test=res.split('-');
console.log(test);// ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
console.log(res);// 1-2-3-4-5-6-7-8-9
image
4，arr.toString()
(1)作用：将數組的元素值通過逗号連接配接到一起，并組成一個新的字元串；
(2)文法：let res=arr.toString();
(3)文法解釋：#；
(4)傳回值：傳回用數組元素加逗号分隔組成的新字元串；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.toString();
console.log(res);// 1,2,3,4,5,6,7,8,9
console.log(arr)// [1, 2, 3, 4, 5, 6, 7, 8, 9]
image
5，arr.map()
(1)作用：将數組的每個元素傳遞給指定函數， 并傳回一個數組；
(2)文法：arr.map(function(item){return item*item});
(3)文法解釋：item指代數組的元素，每個元素都會調用後面的函數處理一次；
(4)傳回值：函數處理後的新數組；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.map((item)=>{return item*item});
console.log(res);// [1, 4, 9, 16, 25, 36, 49, 64, 81]
console.log(arr);// [1, 2, 3, 4, 5, 6, 7, 8, 9]
image
6,arr.filter()
(1)作用：依據指定的函數邏輯判斷，并傳回原數組的一個元素的子集組成的新數組；
(2)文法：arr.filter(function(item){return item<n});
(3)文法解釋：item指代數組元素，符合條件(判定為true)的item會被傳回；
(4)傳回值：傳回符合判斷條件的元素組成的新數組；
(5)示例代碼：
// 示例1
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.filter((item)=>{return item<5});
console.log(res);// [1, 2, 3, 4]
// 示例2
const arr2=[0,1,2,3];
const res2=arr2.filter((item)=>{return true})；
console.log(res2);// [0, 1, 2, 3]
// 示例3--true過濾空元素
const arr3=[0,,1,2,3];
const res3=arr3.filter((item)=>{return true})
console.log(res3);// [0, 1, 2, 3]
// 示例4--true過濾不掉null
const arr4=[0,null,1,2,3];
const res4=arr4.filter((item)=>{return true})
console.log(res4);// [0, null, 1, 2, 3]
//示例5--true過濾不掉undefined
const arr5=[0,undefined,1,2,3];
const res5=arr5.filter((item)=>{return true})
console.log(res5);
//示例6--過濾null和undefined
const arr6=[0,undefined,1,2,null,3];
const res6=arr6.filter((item)=>{return item!==undefined && item!==null})
console.log(res6);// [0, 1, 2, 3]
image
7,arr.reduce()和arr.reduceRight()
(1)作用：依據指定函數對數組進行收斂/縮減，最終傳回單一值作為計算結果；
(2)文法：arr.reduce(function(res,value,index,arr){return res+value},n);
(3)文法解釋：res為每次計算的結果，初始值是n，如果n沒給，則延取數組第一個元素作為其初始值，value則延取數組第二個元素；value是數組的元素值，index是數組的下标，arr是數組本身；res和value必須給，index/arr/n可選；注意arr為空數組且未給參數n時報錯；arr為單元素數組，未給n時，簡單傳回單元素；arr為空數組，n給了時，簡單傳回n；reduce從左到右處理，reduceRight從右到左處理；
(4)傳回值：傳回最終計算後的res值；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res1=arr.reduce((res,value)=>{return res+value},0);
console.log(res1);// 45 求和
const res2=arr.reduce((res,value)=>{return res*value},1);
console.log(res2);// 362880 求積
const res3=arr.reduce((res,value)=>{return res>value?res:value});
console.log(res3);// 9 求最大值
image
8,arr.find()
(1)作用：判斷數組内是否有符合條件的元素，并傳回這個元素；
(2)文法：arr.find(function(item,index,arr){return item<9});
(3)文法解釋：item數組元素，index數組下标，arr數組本身；
(4)傳回值：傳回數組内通過判斷的第一個元素的值,若找不到傳回undefined；空數組不執行函數；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.find((item)=>{return item<4})
console.log(res);// 1
const arr1=[{name:'tom',age:30},{name:'jery',age:35}];
const res1=arr1.find((item)=>{return item.name==='tom'});
console.log(res1);// {name: "tom", age: 30}
const res2=arr1.find((item)=>{return item.name==='tomBro'});
console.log(res2);// undefined
image
9,Array.from()
(1)作用：從一個類似數組或可疊代對象中建立一個新的數組；
(2)文法：Array.from(arrayLike, mapFn, thisArg)；
(3)文法解釋：arrayLike(必須)想要轉換成數組的僞數組對象或可疊代對象；mapFn(可選)如果指定了該參數，新數組中的每個元素會執行該回調函數；thisArg(可選)執行回調函數 mapFn 時的 this 對象；
(4)傳回值：一個新的數組；
(5)示例代碼：
function fun() {
return Array.from(arguments);
}
const res=fun('tom', 'jery');
console.log(res);// ["tom", "jery"]
const res1=Array.from('test');
console.log(res1);// ["t", "e", "s", "t"]
const res4=Array.from('test',item=>item+2);
console.log(res4);// ["t2", "e2", "s2", "t2"]
const set = new Set(['test', window]);
const res2=Array.from(set);
console.log(res2);// ["test", Window]
const map = new Map([[1, 2], [2, 4], [4, 8]]);
const res3=Array.from(map);
console.log(res3);// [[1, 2], [2, 4], [4, 8]]
image
10,Array.of()
(1)作用：将任意數量的參數，按順序組成新數組；
(2)文法：Array.of(n);
(3)文法解釋：n任意格式的資料；
(4)傳回值：參數按照順序組成的新數組；和Array()的差別，當參數是Number且是>=0的整數時，Array()預設傳回對應長度的數組(元素為空)，否則報錯；而Array.of()一律将參數當作元素看待。
(5)示例代碼：
const res=Array.of('tom');
console.log(res);// ["tom"]
const res1=Array.of('tom',1,[1,2],{name:'tom'});
console.log(res1);// ["tom", 1, [1, 2], {name: "tom"}]
image
11，Object.keys(arr)
(1)作用：周遊數組的鍵(下标)；
(2)文法：Object.keys(arr);
(3)文法解釋：arr指代某個數組；
(4)傳回值：傳回原數組的鍵(下标)組成的新數組；
(5)示例代碼：
const arr1=[1,2,3,4,5,6,7,8,9];
const res1=Object.keys(arr1);
console.log(res1);// ["0", "1", "2", "3", "4", "5", "6", "7", "8"]
let arr2=[];
arr2['name']='tom';
arr2['age']=30;
arr2['female']='man';
const res2=Object.keys(arr2);
console.log(res2);// ["name", "age", "female"]
image
12，arr.values()
(1)作用：該方法擷取一個數組疊代器對象，該對象包含數組中每一個索引的值;
(2)文法：arr.values();
(3)文法解釋：疊代器對象Iterator具有next()方法，可以用來依次調用它的值；
(4)傳回值：傳回原數組的疊代器對象，通過next()方法的value屬性擷取疊代器對象的值；
(5)示例代碼：
const arr=['tom','jery','jack','wilson'];
const res=arr.values();
console.log(res.next().value);// tom
console.log(res.next().value);// jery
console.log(res.next().value);// jack
console.log(res.next().value);// wilson
console.log(res.next().value);// undefined
image
13，arr.keys()
(1)作用：該方法擷取一個數組疊代器對象，該對象包含數組中每一個索引的鍵;
(2)文法：arr.keys();
(3)文法解釋：疊代器對象Iterator具有next()方法，可以用來依次調用它的值；
(4)傳回值：傳回原數組的疊代器對象，通過next()方法的value屬性擷取疊代器對象的值；
(5)示例代碼：
const arr=['tom','jery','jack','wilson'];
const res=arr.keys();
console.log(res.next().value);// 0
console.log(res.next().value);// 1
console.log(res.next().value);// 2
console.log(res.next().value);// 3
console.log(res.next().value);// undefined
image
14，arr.entries()
(1)作用：該方法擷取一個數組疊代器對象，該對象包含數組中每一個索引的鍵值對;
(2)文法：arr.entries();
(3)文法解釋：疊代器對象Iterator具有next()方法，可以用來依次調用它的值；
(4)傳回值：傳回原數組的疊代器對象，通過next()方法的value屬性擷取疊代器對象的值；
(5)示例代碼：
const arr=['tom','jery','jack','wilson'];
const res=arr.entries();
console.log(res.next().value);// [0, "tom"]
console.log(res.next().value);// [1, "jery"]
console.log(res.next().value);// [2, "jack"]
console.log(res.next().value);// [3, "wilson"]
console.log(res.next().value);// undefined
image
三，不動原數組，隻依據原數組進行判斷/處理的方法
1，arr.forEach()
(1)作用：周遊數組，為每個元素調用指定的函數；
(2)文法：arr.forEach(function(item,index,arr){arr[index]=item+1;});
(3)文法解釋：item指代元素，index指代下标，arr指代數組本身；
(4)傳回值：undefined；
(5)示例代碼：
// 示例1.1
const arr=[1,2,3,4,5,6,7,8,9];
let sum=0;
const res=arr.forEach((item)=>{sum+=item});
console.log(res)；// undefined
console.log(sum);// 45
// 示例1.2
const res1=arr.forEach((item,index,arr)=>{arr[index]=item+1})
console.log(res1)；// undefined
console.log(arr);// [2, 3, 4, 5, 6, 7, 8, 9, 10]
// 示例1.3
const res2=arr.forEach((item)=>{return item+1});
console.log(res2);// undefined
// 示例2
let arr2=[];
arr.forEach((item,index)=>{arr2[index]=item+1});
console.log(arr2);// [2, 3, 4, 5, 6, 7, 8, 9, 10]
image
2,for
(1)作用：周遊數組；
(2)文法：for(let key=0;key<arr.lenth;key++){};
(3)文法解釋：arr指代某個數組；
(4)傳回值：無；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
for(let key=0;key<arr.length;key++){
console.log(arr[key]);
}
image
3,for...of...
(1)作用：周遊數組；
(2)文法：for(let item of arr){};
(3)文法解釋：arr指代數組，item指代數組的元素；
(4)傳回值：無；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
for(let item of arr){
console.log(item)
}
image
4,for...in...
(1)作用：周遊數組；
(2)文法：for(let key in arr){};
(3)文法解釋：arr指代數組，key指代數組的下标；
(4)傳回值：無；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
for(let item of arr){
console.log(item)
} image
5,...(spread)
(1)作用：如果函數需要傳入多個參數值，但是給定的參數卻是數組，函數無法處理時，可以用...實作數組的打散和逐個配置設定；
(2)文法：function computed(arr){};let arr=[1,2,3];computed(...arr);
(3)文法解釋：arr指代某個數組；
(4)傳回值：無；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
console.log(...arr);// 1 2 3 4 5 6 7 8 9
const res=Math.min(...arr);
console.log(res);// 1
// 分解步驟
function getMin(){
const arrLike=arguments;
let min;
for(let key in arrLike){
if(key===0){
min=arrLike[key]
}else{
min=min<=arrLike[key]?min:arrLike[key];
}
}
return min;
}
const res1 = getMin(...arr);
console.log(res1);// 1
image
6,arr.indexOf()
(1)作用：搜尋整個數組中是否有給定的值；
(2)文法：arr.indexOf(n) || arr.lastIndexOf(n);
(3)文法解釋：n代表某個元素值；
(4)傳回值：傳回找到的第一個元素的索引，如果沒找到，傳回-1；indexOf從前往後找，lastIndexOf從後往前找；
(5)示例代碼：
const arr=['tom','jery','tom','jack'];
const res1=arr.indexOf('tom');
console.log(res1);// 0
const res2=arr.lastIndexOf('tom')
console.log(res2);// 2
const res3=arr.indexOf('kity')
console.log(res3);// -1
image
7,arr.every()和arr.some()
(1)作用：對數組元素應用指定的函數進行判定，判定是否符合條件；
(2)文法：arr.every(function(item){return item<n}),arr.some(function(item){return item<n});
(3)文法解釋：<n是某判斷條件；every要求所有元素符合條件，some隻要求最少有一個元素符合要求
(4)傳回值：傳回true或者false；
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.every((item)=>{return item<10});
console.log(res);// true
const res1=arr.every((item)=>{return item<8});
console.log(res1);// false
const res2=arr.some((item)=>{return item <8});
console.log(res2);// true
const res3=arr.some((item)=>{return item >10});
console.log(res3);// false
image
8，Array.isArray()
(1)判斷一個資料是否是數組格式；
(2)文法：Array.isArray();
(3)文法解釋：n是一個待判斷的資料；
(4)傳回值：布爾值；
(5)示例代碼：
const data1=[1,2,3,,4,5,6];
const data2={name:'tom',age:30};
const data3='tom';
const res1=Array.isArray(data1);
console.log(res1);// true
const res2=Array.isArray(data2);
console.log(res2);// false
const res3=Array.isArray(data3);
console.log(res3);// false
image
9,arr.includes()
(1)作用：判斷一個數組中是否包含一個指定的值；
(2)文法：arr.includes(n);
(3)文法解釋：n某個指定的值；
(4)傳回值：布爾值；
(5)示例代碼：
const arr=['中國','日本','南韓'];
const res1=arr.includes('中國');
console.log(res1);// true
const res2=arr.includes('china');
console.log(res2);// false
image
10,arr.findIndex();
(1)作用：判斷數組内是否有符合條件的元素，并傳回這個元素的下标；
(2)文法：arr.findIndex(function(item,index,arr){return item<9});
(3)文法解釋：item數組元素，index數組下标，arr數組本身；
(4)傳回：傳回數組内通過判斷的第一個元素的下标,若找不到傳回-1；空數組不執行函數；
和arr.indexOf(n)的差別：indexOf直接檢查某個數組是否包含某個元素，findIndex是判斷數組内是否有符合條件的元素，後者功能更豐富，但是前者更簡潔；另外，借助Object.is後者可以判斷NaN，前者不可以。
(5)示例代碼：
const arr=[1,2,3,4,5,6,7,8,9];
const res=arr.findIndex((item)=>{return item<4})
console.log(res);// 0
const arr1=[{name:'tom',age:30},{name:'jery',age:35}];
const res1=arr1.findIndex((item)=>{return item.name==='tom'});
console.log(res1);// 0
const res2=arr1.findIndex((item)=>{return item.name==='tomBro'});
console.log(res2);// -1
// indexOf方法不能判定NaN
const res3=[NaN].indexOf(NaN);
console.log(res3);// -1
// finIndex借助Object.is方法可以判斷NaN
const res4=[NaN].findIndex(y => Object.is(NaN, y));
console.log(res4);// 0