数组的一些方法

数组转字符串

toString()方法

返回值：拼接的字符串不改变原数组

toLocaleString()方法

返回值：拼接的字符串不改变原数组

join()方法

返回值：拼接的字符串不改变原数组
join()方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。将数组转化成字符串。

不传参时默认使用逗号分隔，类似于toString()方法

数组遍历

for

for in

for in循环遍历数组时，会遍历数组的所有可枚举属性，包括原型链上的属性，所以不建议使用for in遍历数组,效率较低

for of

for of循环遍历数组时，只会遍历数组可枚举的元素，不会遍历数组的原型链上的属性，所以建议使用for of遍历数组,不能遍历对象

forEach

返回值：undefined 不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

除了抛出异常以外，没有办法中止或跳出forEach()循环,因为源码是回调函数执行，写break只是在回调函数内调出，不能调出循环。返回值为undefined
也不能return

map

返回值：新数组不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

map()方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。需要return

filter

返回值：新数组不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

filter()方法创建一个新数组, 每次给元素调用回调函数，将那些使回调函数返回true的元素放入新数组中。

some

返回值：布尔值不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

some()方法测试数组中是不是至少有1个元素通过了被提供的函数测试。如果有一个元素通过了测试，那么表达式返回true，否则返回false。true之后，后面的元素不再执行
若数组为空，则返回false

every

返回值：布尔值不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

every()方法测试数组中的所有元素是否都通过了指定函数的测试。如果有一个元素没有通过测试，那么表达式返回false，否则返回true。false之后，后面的元素不再执行
若数组为空，则返回true

find

返回值：找到的元素不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

find()方法返回数组中满足提供的测试函数的第一个元素的值。如果没有值满足测试函数，则返回undefined,如果找到就不再寻找。

findIndex

返回值：找到的元素的索引不改变原数组
参数：回调函数，回调函数有三个参数，分别是当前遍历的元素，当前遍历的元素的索引，遍历的数组本身

findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。如果没有值满足测试函数，则返回-1,如果找到就不再寻找。

数组的增删改查

增

push

返回值：数组的长度改变原数组
参数：要添加的元素可以是多个用逗号隔开也可以是一个数组也可以是一个对象会以一个元素的形式添加到数组中

push()方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

unshift

返回值：数组的长度改变原数组
参数：要添加的元素可以是多个用逗号隔开也可以是一个数组也可以是一个对象会以一个元素的形式添加到数组中

unshift()方法将一个或多个元素添加到数组的开头，并返回该数组的新长度。
如果是一次添加多个元素，那么这些元素会按照它们被添加的顺序排列，而不是按照它们被传递的顺序排列。如果分批次添加元素，越后添加的越前

删

shift

返回值：被删除的元素改变原数组
参数：无

shift()方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
如果数组为空，则shift()不改变数组，并返回undefined值。
如果数组中只有一个元素，则shift()方法将删除该元素，并返回该元素的值。
如果数组中有多个元素，则shift()方法将删除第一个元素，并返回该元素的值。

pop

返回值：被删除的元素改变原数组
参数：无

pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
如果数组为空，则pop()不改变数组，并返回undefined值。
如果数组中只有一个元素，则pop()方法将删除该元素，并返回该元素的值。
如果数组中有多个元素，则pop()方法将删除最后一个元素，并返回该元素的值。

slice

返回值：截取的新数组 不改变原数组 （浅拷贝）
参数：开始截取的索引，结束截取的索引（不包含）

只拷贝第一级目录，拷贝一个数组（或者一部分），不拷贝更深层次的目录。
slice()方法返回一个新的数组对象，这一对象是一个由 begin和 end（不包括end）决定的原数组的浅拷贝。原始数组不会被改变。
Array.prototype.slice.call(arguments)可以将类数组转换为数组
slice(-1)提取数组最后一个元素如果有end，一定是从begin从左到右取，不存在从右到左取，begin为负数时，表示从数组倒数第几个元素开始取
若超出数组索引范围，返回空数组

改

splice 可以增删改

返回值：由被删除的元素组成的一个数组 改变原数组
参数：开始删除的索引，删除的个数，要添加的元素（可选）

数组清空 splice(0) 从索引0开始删除到数组末尾
切片删除 splice(2) 从索引2开始删除到数组末尾
删除一个元素 splice(2,1) 从索引2开始删除一个元素
修改元素 splice(2,1,3) 从索引2开始删除一个元素，然后在索引2处添加3
增加元素 splice(2,0,3) 从索引2开始删除0个元素，然后在索引2处添加3(将3变成索引2处的元素，添加到原来索引2处的元素前面)
如果start为正超过数组长度，则从数组末尾开始添加元素，如果为负超过数组长度，则从数组开头开始添加元素

查

indexOf

返回值：元素在数组中的索引，如果没有则返回-1 不改变原数组
参数：要查找的元素，开始查找的索引（可选） indexOf(searchElement, fromIndex?)

从左到右查找，找到第一个就返回索引，找不到返回-1
如果fromIndex为负数，则表示从数组末尾开始查找，如果为负数超过数组长度，则从数组开头开始查找
如果fromIndex为正数，则表示从数组开头开始查找，如果为正数超过数组长度，则返回-1

lastIndexOf

返回值：元素在数组中的索引，如果没有则返回-1 不改变原数组
参数：要查找的元素，开始查找的索引（可选） lastIndexOf(searchElement, fromIndex?)

从右到左查找，找到第一个就返回索引，找不到返回-1

includes

返回值：布尔值，表示是否找到参数字符串(引用类型是查内存地址是否相同) 不改变原数组
参数：要查找的元素，开始查找的索引（可选） includes(searchElement, fromIndex?)

从左到右查找，找到第一个就返回true，找不到返回false
一般是来查询基本类型的值，引用类型是查内存地址是否相同，所以直接查找引用类型返回false

其他方法

concat

返回值：返回一个新数组，不改变原数组
参数：要连接的数组或元素

如果参数是数组，则将数组中的元素连接到新数组中
如果参数不是数组，则将参数添加到新数组中

fill

返回值：返回修改后的原数组
参数：要填充的元素，开始填充的索引，结束填充的索引（可选）

如果开始索引为负数，则表示从数组末尾开始填充，如果为负数超过数组长度，则从数组开头开始填充
Array(3).fill(4) // [4,4,4] Array.from({length:3}).fill(4) // [4,4,4]

sort

返回值：返回修改后的原数组
参数：排序规则（可选）

如果不传参数，则按照Unicode编码进行排序，默认升序

如果传参，参数是比较函数，则按照函数返回值进行排序 return a - b 升序 return b - a 降序

var arr= [ 
    { 'sortNo': 2},
    { 'sortNo': 1},
    { 'sortNo': 5},
    { 'sortNo': 6},
    { 'sortNo': 7},
    { 'sortNo': 3},
    { 'sortNo': 9},
    { 'sortNo': 4},
    { 'sortNo': 0}
];
arr.sort(function(a, b){
        return a.sortNo - b.sortNo;
});

reverse

返回值：返回修改后的原数组
参数：无

将数组中的元素倒序排列

reduce

返回值：返回累计的值不改变原数组
参数：累计函数，初始值（可选）

累计函数的参数：上一次累计的值，当前值，当前索引，原数组
如果没有初始值，则第一次累计的值为数组的第一个元素，从第二个元素开始累计

如果有初始值，则第一次累计的值为初始值，从第一个元素开始累计

var arr = [1,2,3,4,5];
var sum = arr.reduce((prev, cur, index, arr)=>{
    return prev + cur;
}, 0);

reduceRight

返回值：返回累计的值不改变原数组
参数：累计函数，初始值（可选）

与reduce的区别是从右向左累计
如果没有初始值，则第一次累计的值为数组的最后一个元素，从倒数第二个元素开始累计
如果有初始值，则第一次累计的值为初始值，从最后一个元素开始累计

copyWithin

复制数组的一部分数据覆盖到数组的另一个位置。并返回数组，不改变数组长度
参数：要复制的开始索引，要复制的结束索引，要粘贴的索引

如果开始索引为负数，则表示从数组末尾开始复制，如果为负数超过数组长度，则从数组开头开始复制

var arr = [1,2,3,4,5];
arr.copyWithin(0, 3); 
// [4,5,3,4,5] 没有第三个参数，表示从3开始复制到数组末尾，复制了'4','5'，然后从数组[0]开始粘贴'4','5'
arr.copyWithin(0, 3, 4); 
// [4,2,3,4,5] 从3开始复制到4，复制了'4'，然后从数组[0]开始粘贴'4'

flat

返回值：返回一个新数组，不改变原数组
参数：要展开的深度（可选）

如果不传参数，则默认展开一层
如果传参数，则展开指定层

flatMap

返回值：返回一个新数组，不改变原数组
参数：回调函数，回调函数的this指向（可选）

与map的区别是，回调函数返回的值会被flat展开

Array.from

返回值：返回一个新数组
参数：类数组对象，回调函数，回调函数的this指向（可选）
将一个类数组对象转换为一个真正的数组，必须具备以下条件：
1、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数组是一个空数组。
2、该类数组对象的属性名必须为数值型或字符串型的数字,如果不是，会返回undefined。

如果传回调函数，则会对数组的每个元素进行回调函数的操作

1 2	var arr = Array.from({length: 3}, (item, index) => index); let arr = Array.from({length:3}).fill(1)

Array.of

返回值：返回一个新数组
参数：任意个数的参数
是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异,只有当参数大于等于2时，Array()才会返回由参数组成的新数组，否则只是返回一个长度为参数的空数组。

将参数转换为数组

Array.isArray

返回值：布尔值
参数：任意类型的参数

判断参数是否为数组
如果参数是一个类数组对象，则返回false

Array.prototype.entries

返回值：返回一个新的迭代器对象,该对象包含数组中每个索引的键值对,与Object.entries()不同，Object.entries()直接返回二维数组
它返回带有键/值对的Array Iterator对象。每个键值对的键名是数字索引，键值是该索引处的值。

Array.prototype.keys

返回值：返回一个新的迭代器对象,该对象包含数组中每个索引的键值对,与Object.keys()不同，Object.keys()直接返回一维数组
它返回一个包含数组中每个索引键的Array Iterator对象。

Array.prototype.values

返回值：返回一个新的迭代器对象,该对象包含数组中每个索引的键值对,与Object.values()不同，Object.values()直接返回一维数组
它返回一个包含数组中每个索引值的Array Iterator对象。