<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]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]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]
4,arr.sort()
(1)作用：将数组中的元素排序;
(2)语法：arr.sort()；
(3)语法表明：小括号内可以带参数，假如不带参数，默认依照字母表次序分列，假如数组中有unefined值，将会被排到数组尾部；小括号内也可以带一个函数作为参数:
function(a,b){ // value是a和b比较的效果 return value;}
函数表明：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;}(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"]
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);// 46,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);// 307,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
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
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
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
二，不动原数组，只产生新数据的方法
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);// ["中国", "俄罗斯", "英国"]
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]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-9console.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-94，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,9console.log(arr)// [1, 2, 3, 4, 5, 6, 7, 8, 9]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] 6,arr.filter()
(1)作用：依据指定的函数逻辑判断，并返回原数组的一个元素的子集构成的新数组；
(2)语法：arr.filter(function(item){return item<n});
(3)语法表明：item指代数组元素，符合条件(判断为true)的item会被返回；
(4)返回值：返回符合判断条件的元素构成的新数组；
(5)示例代码：
// 示例1const 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]// 示例2const 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过滤不掉nullconst arr4=[0,null,1,2,3];const res4=arr4.filter((item)=>{return true})console.log(res4);// [0, null, 1, 2, 3]//示例5--true过滤不掉undefinedconst arr5=[0,undefined,1,2,3];const res5=arr5.filter((item)=>{return true})console.log(res5);//示例6--过滤null和undefinedconst arr6=[0,undefined,1,2,null,3];const res6=arr6.filter((item)=>{return item!==undefined && item!==null})console.log(res6);// [0, 1, 2, 3]
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 求最大值
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);// 1const 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 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]]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"}]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"]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);// tomconsole.log(res.next().value);// jeryconsole.log(res.next().value);// jackconsole.log(res.next().value);// wilsonconsole.log(res.next().value);// undefined
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);// 0console.log(res.next().value);// 1console.log(res.next().value);// 2console.log(res.next().value);// 3console.log(res.next().value);// undefined
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三，不动原数组，只依据原数组进行判断/处置惩罚的方法
1，arr.forEach()
(1)作用：遍历数组，为每个元素调用指定的函数；
(2)语法：arr.forEach(function(item,index,arr){arr[index]=item+1;});
(3)语法表明：item指代元素，index指代下标，arr指代数组自己；
(4)返回值：undefined；
(5)示例代码：
// 示例1.1const arr=[1,2,3,4,5,6,7,8,9];let sum=0;const res=arr.forEach((item)=>{sum+=item});console.log(res)；// undefinedconsole.log(sum);// 45// 示例1.2const res1=arr.forEach((item,index,arr)=>{arr[index]=item+1})console.log(res1)；// undefinedconsole.log(arr);// [2, 3, 4, 5, 6, 7, 8, 9, 10]// 示例1.3const res2=arr.forEach((item)=>{return item+1});console.log(res2);// undefined// 示例2let arr2=[];arr.forEach((item,index)=>{arr2[index]=item+1});console.log(arr2);// [2, 3, 4, 5, 6, 7, 8, 9, 10]
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]);}// 1// 2// 3// 4// 5// 6// 7// 8// 9
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)}// 1// 2// 3// 4// 5// 6// 7// 8// 94,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)}// 1// 2// 3// 4// 5// 6// 7// 8// 95,...(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);// 16,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);// 0const res2=arr.lastIndexOf('tom')console.log(res2);// 2const res3=arr.indexOf('kity')console.log(res3);// -17,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);// trueconst res1=arr.every((item)=>{return item<8});console.log(res1);// falseconst res2=arr.some((item)=>{return item <8});console.log(res2);// trueconst res3=arr.some((item)=>{return item >10});console.log(res3);// false
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);// trueconst res2=Array.isArray(data2);console.log(res2);// falseconst res3=Array.isArray(data3);console.log(res3);// false
9,arr.includes()
(1)作用：判断一个数组中是否包罗一个指定的值；
(2)语法：arr.includes(n);
(3)语法表明：n某个指定的值；
(4)返回值：布尔值；
(5)示例代码：
const arr=['中国','日本','韩国'];const res1=arr.includes('中国');console.log(res1);// trueconst res2=arr.includes('china');console.log(res2);// false10,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);// 0const arr1=[{name:'tom',age:30},{name:'jery',age:35}];const res1=arr1.findIndex((item)=>{return item.name==='tom'});console.log(res1);// 0const res2=arr1.findIndex((item)=>{return item.name==='tomBro'});console.log(res2);// -1// indexOf方法不能判断NaNconst res3=[NaN].indexOf(NaN);console.log(res3);// -1// finIndex借助Object.is方法可以判断NaNconst res4=[NaN].findIndex(y => Object.is(NaN, y));console.log(res4);// 0 |
