js 数组详细操作方法及解析合集

2023-09-12 01:06:05 207

前言

在开发中，数组的使用场景非常多，平日中也涉及到很多数组的api/相关操作，一直也没有对这块内容进行一块整理总结，很多时候就算用过几次这个api，在开发中也很容易忘记，还是要谷歌一下。所以就希望对这块内容有一个比较系统性的总结，在这背景下，就有了本篇文章，如果喜欢的话可以点波赞/关注，支持一下，希望大家看完本文可以有所收获。

创建一个数组:

//字面量方式:
//这个方法也是我们最常用的，在初始化数组的时候相当方便
vara=[3,11,8];//[3,11,8];
//构造器:
//实际上newArray===Array,加不加new一点影响都没有。
vara=Array();//[]
vara=Array(3);//[undefined,undefined,undefined]
vara=Array(3,11,8);//[3,11,8]

ES6Array.of()返回由所有参数值组成的数组

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。

目的：Array.of()出现的目的是为了解决上述构造器因参数个数不同，导致的行为有差异的问题。

leta=Array.of(3,11,8);//[3,11,8]
leta=Array.of(3);//[3]

ES6Arrar.from()将两类对象转为真正的数组

定义：用于将两类对象转为真正的数组（不改变原对象，返回新的数组）。

参数：

第一个参数(必需):要转化为真正数组的对象。

第二个参数(可选):类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。

第三个参数(可选):用来绑定this。

//1.对象拥有length属性
letobj={0:'a',1:'b',2:'c',length:3};
letarr=Array.from(obj);//['a','b','c'];
//2.部署了Iterator接口的数据结构比如:字符串、Set、NodeList对象
letarr=Array.from('hello');//['h','e','l','l']
letarr=Array.from(newSet(['a','b']));//['a','b']

方法:

数组原型提供了非常多的方法，这里分为三类来讲，一类会改变原数组的值，一类是不会改变原数组，以及数组的遍历方法。

改变原数组的方法(9个):

leta=[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()方法删除一个数组中的最后的一个元素，并且返回这个元素。

参数:无。

leta=[1,2,3];
letitem=a.pop();//3
console.log(a);//[1,2]

shift()删除数组的第一个元素

定义:shift()方法删除数组的第一个元素，并返回这个元素。

参数:无。

leta=[1,2,3];
letitem=a.shift();//1
console.log(a);//[2,3]

push()向数组的末尾添加元素

定义：push()方法可向数组的末尾添加一个或多个元素，并返回新的长度。

参数:item1,item2,…,itemX,要添加到数组末尾的元素

leta=[1,2,3];
letitem=a.push('末尾');//4
console.log(a);//[1,2,3,'末尾']

unshift()

定义：unshift()方法可向数组的开头添加一个或更多元素，并返回新的长度。

参数:item1,item2,…,itemX,要添加到数组开头的元素

leta=[1,2,3];
letitem=a.unshift('开头');//4
console.log(a);//['开头',1,2,3]

reverse()颠倒数组中元素的顺序

定义:reverse()方法用于颠倒数组中元素的顺序。

参数:无

leta=[1,2,3];
a.reverse();
console.log(a);//[3,2,1]

splice()添加/删除数组元素

定义：splice()方法向/从数组中添加/删除项目，然后返回被删除的项目

语法：array.splice(index,howmany,item1,.....,itemX)

参数:

index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany：必需。要删除的项目数量。如果设置为0，则不会删除项目。
item1,…,itemX：可选。向数组添加的新项目。

返回值:如果有元素被删除,返回包含被删除项目的新数组。

eg1:删除元素

leta=[1,2,3,4,5,6,7];
letitem=a.splice(0,3);//[1,2,3]
console.log(a);//[4,5,6,7]
//从数组下标0开始，删除3个元素
letitem=a.splice(-1,3);//[7]
//从最后一个元素开始删除3个元素，因为最后一个元素，所以只删除了7

eg2:删除并添加

leta=[1,2,3,4,5,6,7];
letitem=a.splice(0,3,'添加');//[1,2,3]
console.log(a);//['添加',4,5,6,7]
//从数组下标0开始，删除3个元素，并添加元素'添加'
letb=[1,2,3,4,5,6,7];
letitem=b.splice(-2,3,'添加1','添加2');//[6,7]
console.log(b);//[1,2,3,4,5,'添加1','添加2']
//从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2'

eg3:不删除只添加:

leta=[1,2,3,4,5,6,7];
letitem=a.splice(0,0,'添加1','添加2');//[]没有删除元素，返回空数组
console.log(a);//['添加1','添加2',1,2,3,4,5,6,7]
letb=[1,2,3,4,5,6,7];
letitem=b.splice(-1,0,'添加1','添加2');//[]没有删除元素，返回空数组
console.log(b);//[1,2,3,4,5,6,'添加1','添加2',7]在最后一个元素的前面添加两个元素

从上述三个栗子可以得出:

数组如果元素不够，会删除到最后一个元素为止
操作的元素，包括开始的那个元素
可以添加很多个元素
添加是在开始的元素前面添加的

sort()数组排序

定义:sort()方法对数组元素进行排序，并返回这个数组。

参数可选:规定排序顺序的比较函数。

默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。

//字符串排列看起来很正常
vara=["Banana","Orange","Apple","Mango"];
a.sort();//["Apple","Banana","Mango","Orange"]
//数字排序的时候因为转换成Unicode字符串之后，有些数字会比较大会排在后面这显然不是我们想要的
vara=[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、数组元素为数字的升序、降序:

vararray=[10,1,3,4,20,4,25,8];
//升序a-b<0a将排到b的前面，按照a的大小来排序的
//比如被减数a是10，减数是2010-20<0被减数a(10)在减数b(20)前面
array.sort(function(a,b){
returna-b;
});
console.log(array);//[1,3,4,4,8,10,20,25];
//降序被减数和减数调换了20-10>0被减数b(20)在减数a(10)的前面
array.sort(function(a,b){
returnb-a;
});
console.log(array);//[25,20,10,8,4,4,3,1];

2、数组多条件排序

vararray=[{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的值降序
returnb.age-a.age
}else{//如果id的值不相等，按照id的值升序
returna.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、自定义比较函数，天空才是你的极限

类似的：运用好返回值，我们可以写出任意符合自己需求的比较函数

vararray=[{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<0a排在b的前面
return-1
}else{//如果不是的话，a排在b的后面
return1
}
})
//[{"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):chrome45,Edge12,Firefox32,Opera32,Safari9,IE不支持

eg:

//-2相当于3号位，-1相当于4号位
[1,2,3,4,5].copyWithin(0,-2,-1)
//[4,2,3,4,5]
vara=['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

MDN浏览器兼容

['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(可选):指定要使用的分隔符，默认使用逗号作为分隔符。

leta=['hello','world'];
letstr=a.join();//'hello,world'
letstr2=a.join('+');//'hello+world'

使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

leta=[['OBKoro1','23'],'test'];
letstr1=a.join();//OBKoro1,23,test
letb=[{name:'OBKoro1',age:'23'},'test'];
letstr2=b.join();//[objectObject],test
//对象转字符串推荐JSON.stringify(obj);

所以，join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[objectObject]字符串。

toLocaleString()数组转字符串

定义:返回一个表示数组元素的字符串。该字符串由数组中的每个元素的toLocaleString()返回值经调用join()方法连接（由逗号隔开）组成。

语法:

array.toLocaleString()
参数：无。

leta=[{name:'OBKoro1'},23,'abcd',newDate()];
letstr=a.toLocaleString();//[objectObject],23,abcd,2018/5/28下午1:52:20

如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。

toString()数组转字符串不推荐

定义:toString()方法可把数组转换为由逗号链接起来的字符串。

语法:

array.toString()
参数:无。

该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不推荐使用。

值得注意的是：当数组和字符串操作的时候，js会调用这个方法将数组自动转换成字符串

letb=['toString','演示'].toString();//toString,演示
leta=['调用toString','连接在我后面']+'啦啦啦';//调用toString,连接在我后面啦啦啦

slice()浅拷贝数组的元素

定义：方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象，且原数组不会被修改。

注意：字符串也有一个slice()方法是用来提取字符串的，不要弄混了。

语法:

array.slice(begin,end);
参数:

begin(可选):索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。

end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。

leta=['hello','world'];
letb=a.slice(0,1);//['hello']
a[0]='改变原数组';
console.log(a,b);//['改变原数组','world']['hello']
b[0]='改变拷贝的数组';
console.log(a,b);//['改变原数组','world']['改变拷贝的数组']

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变。

leta=[{name:'OBKoro1'}];
letb=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

定义：方法用于合并两个或多个数组，返回一个新数组。

语法：

varnewArr=oldArray.concat(arrayX,arrayX,......,arrayX)
参数：

arrayX（必须）：该参数可以是具体的值，也可以是数组对象。可以是任意多个。

eg1:

leta=[1,2,3];
letb=[4,5,6];
//连接两个数组
letnewVal=a.concat(b);//[1,2,3,4,5,6]
//连接三个数组
letc=[7,8,9]
letnewVal2=a.concat(b,c);//[1,2,3,4,5,6,7,8,9]
//添加元素
letnewVal3=a.concat('添加元素',b,c,'再加一个');
//[1,2,3,"添加元素",4,5,6,7,8,9,"再加一个"]
//合并嵌套数组会浅拷贝嵌套数组
letd=[1,2];
letf=[3,[4]];
letnewVal4=d.concat(f);//[1,2,3,[4]]

ES6扩展运算符...合并数组：

因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。

leta=[2,3,4,5]
letb=[4,...a,4,4]
console.log(a,b);//[2,3,4,5][4,2,3,4,5,4,4]

更多关于扩展符的详细内容移步阮一峰大神的ECMAScript6入门

indexOf()查找数组是否存在某个元素，返回下标

定义:返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

语法:

array.indexOf(searchElement,fromIndex)
参数:

searchElement(必须):被查找的元素

fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。

严格相等的搜索:

数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。

注意：indexOf()不能识别NaN

eg:

leta=['啦啦',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，即数组不会被查找。

leta=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1'];//数组长度为10
//letb=a.lastIndexOf('Koro1',4);//从下标4开始往前找返回下标2
//letb=a.lastIndexOf('Koro1',100);//大于或数组的长度查找整个数组返回9
//letb=a.lastIndexOf('Koro1',-11);//-1数组不会被查找
letb=a.lastIndexOf('Koro1',-9);//从第二个元素4往前查找，没有找到返回-1

ES7includes()查找数组是否包含某个元素返回布尔

定义：返回一个布尔值，表示某个数组是否包含给定的值

语法：

array.includes(searchElement,fromIndex=0)
参数：

searchElement(必须):被查找的元素

fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。

includes方法是为了弥补indexOf方法的缺陷而出现的:

indexOf方法不能识别NaN
indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观

eg:

leta=['OB','Koro1',1,NaN];
//letb=a.includes(NaN);//true识别NaN
//letb=a.includes('Koro1',100);//false超过数组长度不搜索
//letb=a.includes('Koro1',-3);//true从倒数第三个元素开始搜索
//letb=a.includes('Koro1',-100);//true负值绝对值超过数组长度，搜索整个数组

兼容性(MDN):chrome47,Firefox43,Edge14,Opera34,Safari9,IE未实现。

遍历方法(12个):

js中遍历数组并不会改变原始数组的方法总共有12个:

ES5：
forEach、every、some、fliter、map、reduce、reduceRight、
ES6：
find、findIndex、keys、values、entries

关于遍历：

关于遍历的效率，可以看一下这篇详解JS遍历
尽量不要在遍历的时候，修改后面要遍历的值
尽量不要在遍历的时候修改数组的长度（删除/添加）

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的值是遍历到他们那一刻的值。

eg:

leta=[1,2,,3];//最后第二个元素是空的，不会遍历(undefined、null会遍历)
letobj={name:'OBKoro1'};
letresult=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会报错
returnvalue;//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:

functionisBigEnough(element,index,array){
returnelement>=10;//判断数组中的所有元素是否都大于10
}
letresult=[12,5,8,130,44].every(isBigEnough);//false
letresult=[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。

functionisBigEnough(element,index,array){
return(element>=10);//数组中是否有一个元素大于10
}
letresult=[2,5,8,1,4].some(isBigEnough);//false
letresult=[12,5,8,1,4].some(isBigEnough);//true

filter过滤原始数组，返回新数组

定义:返回一个新数组,其包含通过所提供函数实现的测试的所有元素。

语法：

letnew_array=arr.filter(function(currentValue,index,arr),thisArg)
参数:(这几个方法的参数，语法都类似)

function(必须):数组中每个元素需要调用的函数。

//回调函数的参数
1.currentValue(必须),数组当前元素的值
2.index(可选),当前元素的索引值
3.arr(可选),数组对象本身

thisValue(可选):当执行回调函数时this绑定对象的值，默认值为undefined

eg:

leta=[32,33,16,40];
letresult=a.filter(function(value,index,array){
returnvalue>=18;//返回a数组中所有大于18的元素
});
console.log(result,a);//[32,33,40][32,33,16,40]

map对数组中的每个元素进行处理，返回新的数组

定义：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

语法：

letnew_array=arr.map(function(currentValue,index,arr),thisArg)
参数:(这几个方法的参数，语法都类似)

function(必须):数组中每个元素需要调用的函数。

//回调函数的参数
1.currentValue(必须),数组当前元素的值
2.index(可选),当前元素的索引值
3.arr(可选),数组对象本身

thisValue(可选):当执行回调函数时this绑定对象的值，默认值为undefined

eg:

leta=['1','2','3','4'];
letresult=a.map(function(value,index,array){
returnvalue+'新数组的新元素'
});
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:

//数组求和
letsum=[0,1,2,3].reduce(function(a,b){
returna+b;
},0);
//6
//将二维数组转化为一维将数组元素展开
letflattened=[[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。

这两个方法

语法：

letnew_array=arr.find(function(currentValue,index,arr),thisArg)
letnew_array=arr.findIndex(function(currentValue,index,arr),thisArg)

参数:(这几个方法的参数，语法都类似)

function(必须):数组中每个元素需要调用的函数。

//回调函数的参数
1.currentValue(必须),数组当前元素的值
2.index(可选),当前元素的索引值
3.arr(可选),数组对象本身

thisValue(可选):当执行回调函数时this绑定对象的值，默认值为undefined

这两个方法都可以识别NaN,弥补了indexOf的不足.

eg:

//find
leta=[1,4,-5,10].find((n)=>n<0);//返回元素-5
letb=[1,4,-5,10,NaN].find((n)=>Object.is(NaN,n));//返回元素NaN
//findIndex
leta=[1,4,-5,10].findIndex((n)=>n<0);//返回索引2
letb=[1,4,-5,10,NaN].findIndex((n)=>Object.is(NaN,n));//返回索引4

浏览器兼容(MDN):Chrome45,Firefox25,Opera32,Safari8,Edgeyes,

ES6keys()&values()&entries()遍历键名、遍历键值、遍历键名+键值

定义：三个方法都返回一个新的ArrayIterator对象，对象根据方法不同包含不同的值。

语法：

array.keys()
array.values()
array.entries()

参数：无。

遍历栗子(摘自ECMAScript6入门)：

for(letindexof['a','b'].keys()){
console.log(index);
}
//0
//1

for(letelemof['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方法，进行遍历:

letletter=['a','b','c'];
letentries=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):Chrome38,Firefox28,Opera25,Safari7.1

keys()浏览器兼容性(MDN):Chrome38,Firefox28,Opera25,Safari8,

注意:目前只有Safari9支持,，其他浏览器未实现，babel转码器也还未实现

结语

呼~终于写好了，断断续续，上班也偷偷划水的写了几天，虽说很辛苦，但是现在对数组操作方法，整体清晰了很多，各个API也理解的更好一点了，收获颇多，文章如有不正确的地方欢迎各位大佬鞭策！希望大家看完可以有所收获，喜欢的话，赶紧点波订阅关注/喜欢。

希望看完的朋友可以点个喜欢/关注，您的支持是对我最大的鼓励。

个人blog and 掘金个人主页，如需转载，请放上原文链接并署名。码字不易，感谢支持！本人写文章本着交流记录的心态，写的不好之处，不撕逼，但是欢迎指点。

js 数组详细操作方法及解析合集

热门推荐

随机推荐