JavaScript 数组相关操作方法
前言
在开发中，数组的使用场景非常多，平日中也涉及到很多数组的api/相关操作。记得经常用的几个push,splice，其它在开发中很容易忘记，故整理一波数组api。
创建一个数组
字面量方式：
let a = [1,2,3]
构造器：
let a =new Array(); // []
let b = Array(3); // [empty × 3]
let c = Array(1,2,3); // [1, 2, 3]
ES6 Array.of() 返回由所有参数值组成的数组
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
ES6 Arrary.from() 将类数组对象转换成真正的数组
定义：将类数组对象转为真正的数组（不改变原对象，返回新得数组）
// 1. 对象拥有length属性
let obj = {0: 'a', 1: 'b', 2:'c', length: 3};
let arr = Array.from(obj); // ['a','b','c'];
// 2. 部署了 Iterator接口的数据结构 比如:字符串、Set、NodeList对象
let arr = Array.from('hello'); // ['h','e','l','l','o']
let arr = Array.from(new Set(['a','b'])); // ['a','b']
方法
1. 改变原数组的方法:
let a = [1,2,3];
ES5:
a.splice()/ a.sort() / a.pop()/ a.shift()/ a.push()/ a.unshift()/a.reverse()
ES6:
a.copyWithin() / a.fill
注意避免在循环遍历中改变原数组的选项，比如: 改变数组的长度，导致遍历的长度出现问题。
splice() 添加/删除数组元素
定义： splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目
语法： array.splice(index,howmany,item1,.....,itemX)
参数：
- index：必填。规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
- howmany：可选。要删除的项目数量。如果设置为 0，则不会删除项目。
- item1, ..., itemX： 可选。向数组添加的新项目。
返回值: 如果有元素被删除,返回包含被删除项目的新数组。
删除：
let a = [1, 2, 3, 4, 5, 6, 7];
// 从数组下标0开始，删除2个元素
let item = a.splice(0, 2); // [1,2]
console.log(a); // [3,4,5,6,7]
// 从最后一个元素开始删除2个元素，因为最后一个元素，所以只删除了7
let item = a.splice(-1, 2); // [7]
添加：
let a = [1, 2, 3];
let item = a.splice(0, 0, 'add1', 'add2'); // [] 没有删除元素，返回空数组
console.log(a); // ['add1','add2',1,2,3]
let b = [1, 2, 3];
let item = b.splice(-1, 0, 'add1', 'add2'); // [] 没有删除元素，返回空数组
console.log(b); // [1,2,3,'add1','add2',3] 在最后一个元素的前面添加两个元素
添加并删除：
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0,3,'add'); // [1,2,3]
console.log(a); // ['add',4,5,6,7]
// 从数组下标0开始，删除3个元素，并添加元素'add'
let b = [1, 2, 3, 4, 5, 6, 7];
let item = b.splice(-2,3,'add1','add2'); // [6,7]
console.log(b); // [1,2,3,4,5,'add1','add2']
// 从数组最后第二个元素开始，删除3个元素，并添加两个元素'add1'、'add2'
sort() 数组排序
定义: sort()方法对数组元素进行排序，并返回这个数组。
默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。
很正常：
let a = ['Y-ray', 'A-ray', 'O-ray', 'X-ray', 'p', 'a'];
a.sort(); //['A-ray', 'O-ray', 'X-ray', 'Y-ray', 'a', 'p']
很不正常：
let a = [5,6,1,4,10,2424,343,0];
a.sort(); //[0, 1, 10, 2424, 343, 4, 5, 6] 数字排序的时候 因为转换成Unicode字符串之后，有些数字会比较大会排在后面
一般使用 两个参数比较大小
a.sort((a, b) => {
return a - b;
}) // [0, 1, 4, 5, 6, 10, 343, 2424]
多条件
let a = [{ id: 10, age: 2 },{ id: 5, age: 4 },{ id: 6, age: 10 },{ id: 9, age: 6 },{ id: 2, age: 8 },{ id: 10, age: 9 }];
a.sort((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}]
pop() 删除数组中的最后的一个元素
定义: pop() 方法删除数组中的最后的一个元素，并且返回这个元素。
let a = [1,2,3];
let i = a.pop(); // 3
console.log(a); // [1,2]
shift() 删除数组的第一个元素
定义: shift()方法删除数组的第一个元素，并返回这个元素。
let a = [1,2,3];
let i = a.shift(); // 1
console.log(a); // [2,3]
push() 向数组的末尾添加元素
定义：push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
let a = [1,2,3];
let i = a.push('end'); // 4
console.log(a); // [1,2,3,'end']
unshift()
定义：unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
let a = [1,2,3];
let i = a.unshift('start'); // 4
console.log(a); // ['start',1,2,3]
reverse() 反转数组中元素的顺序
定义: reverse() 方法用于反转数组中元素的顺序。
let a = [1,2,3];
a.reverse();
console.log(a); // [3,2,1]
ES6: copyWithin() 指定位置的成员复制到其他位置
定义: 浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
语法：
array.copyWithin(target, start = 0, end = this.length)
参数:
三个参数都是数值，如果不是，会自动转为数值.
- target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
- start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
- end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
// -4相当2，-1相当5，之间元素有2，3，4
let arr = [1, 2, 3, 4, 5].copyWithin(0, -4, -1);
// [2, 3, 4, 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']
2. 不改变原数组的方法:
ES5：
slice、join、toLocaleString、toString、concat、indexOf、lastIndexOf、firstIndexOf
ES7：
includes
slice() 浅拷贝数组的元素
定义： 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象，且原数组不会被修改。
注意：字符串也有一个slice() 方法是用来提取字符串的，不要弄混了。
语法:
array.slice(begin, end);
用法：
let a = [1, 2, 3];
let i = a.slice(1);
a[2] = 'change'
// 第二个参数不填 默认最后一个元素
console.log(i); // [2, 3]
console.log(a); // [1, 2, 'change']
如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。
如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变。
let a = [{name:'king',age:99},{name:'ray',age:101}]
let b= a.slice(1)
a[1].age = 1;
console.log(a,b); // {name: 'ray', age: 1} {name: 'ray', age: 1}
slice()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。
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= [['king','23'],'test'];
let str1=a.join(); // 'king',23,test
let b= [{name:'king',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:'king'},23,'abcd',new Date()];
let str=a.toLocaleString(); // [object Object],23,abcd,2022/8/25 17:22:27
如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。
concat([])
定义： 方法用于合并两个或多个数组，返回一个新数组。
let a = [1, 2, 3];
let b = [1, 4, 5, 6];
console.log(a.concat(b)); // [1, 2, 3, 1, 4, 5, 6]
// 扩展运算符更方便
console.log([...a,...b]);// [1, 2, 3, 1, 4, 5, 6]
indexOf() 查找数组是否存在某个元素，返回下标
定义: 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
语法:
array.indexOf(searchElement,fromIndex)
参数:
searchElement(必须):被查找的元素
fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。
严格相等的搜索:
数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。
注意：indexOf()不能识别NaN
let a = [1, 2, 3, NaN];
console.log(a.indexOf('1')); // -1
console.log(a.indexOf(1)); // 0
console.log(a.indexOf(NaN)); // -1
使用场景：
- 数组去重
- 根据获取的数组下标执行操作，改变数组中的值等。
- 判断是否存在，执行操作。
let b = [1, 2, 3, NaN];
if (~b.indexOf('1')) {
// 不存在
} else {
//存在
}
lastIndexOf() 查找指定元素在数组中的最后一个位置
定义: 方法返回指定元素,在数组中的最后一个的索引，如果不存在则返回 -1。（从数组后面往前查找）
语法:
arr.lastIndexOf(searchElement,fromIndex)
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
关于fromIndex有三个规则:
- 正值。如果该值大于或等于数组的长度，则整个数组会被查找。
- 负值。将其视为从数组末尾向前的偏移。(比如-2，从数组最后第二个元素开始往前查找)
- 负值。其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
let a = ['King', 4, 'King1', 1, 2, 'King1', 3, 4, 5, 'King1']; // 数组长度为10
// let b=a.lastIndexOf('King1',4); // 从下标4开始往前找 返回下标2
// let b=a.lastIndexOf('King1',100); // 大于或数组的长度 查找整个数组 返回9
// let b=a.lastIndexOf('King1',-11); // -1 数组不会被查找
let b = a.lastIndexOf('King1', -9); // 从第二个元素4往前查找，没有找到 返回-1
ES7 includes() 查找数组是否包含某个元素 返回布尔
定义： 返回一个布尔值，表示某个数组是否包含给定的值
includes方法是为了弥补indexOf方法的缺陷而出现的:
- indexOf方法不能识别
NaN - indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于
-1，表达不够直观
let a = ['1', '2', '3', NaN];
let ar = a.includes(NaN); // true
// let b = a.includes('2',11); // false 超过数组长度 不搜索
// let b=a.includes('2',-3); // true 从倒数第三个元素开始搜索
// let b=a.includes('2',-100); // true 负值绝对值超过数组长度，搜索整个数组
3. 遍历方法
ES5：
forEach、every 、some、 filter、map、reduce、reduceRight、
ES6：
find、findIndex、keys、values、entries
forEach
定义: 按升序为数组中含有效值的每一项执行一次回调函数。
语法：
array.forEach(function(currentValue, index, arr), thisValue)
参数:
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
注意： 无法中断循环，break，continue无效；只能return退出。try..catch..可强制中断
try{
obj.forEach(item => {
console.log(`当前id：${item.id}`)
if(item.id === '002'){
throw new Error('id等于002，跳出循环');
}
});
}
catch(error){
console.error(error)
};
console.log("0.0.0");
1. 对于空数组是不会执行回调函数的
2. 对于已在迭代过程中删除的元素，或者空元素会跳过回调函数
3. 遍历次数再第一次循环前就会确定，再添加到数组中的元素不会被遍历。
4. 如果已经存在的值被改变，则传递给 callback 的值是遍历到他们那一刻的值。
let a = [1, 2, ,3]; // 最后第二个元素是空的，不会遍历(undefined、null会遍历)
let obj = { name: 'King1' };
let result = a.forEach(function (value, index, array) {
a[3] = '改变元素';
a.push('添加到尾端，不会被遍历')
console.log(value, 'forEach传递的第一个参数'); // 分别打印 1 ,2 ,改变元素
console.log(this.name); // King1 打印三次 this绑定在obj对象上
// break; // break会报错
return value; // return只能结束本次回调 会执行下次回调
console.log('不会执行，因为return 会执行下一次循环回调')
}, obj);
console.log(result); // 即使return了一个值,也还是返回undefined
// 回调函数也接受接头函数写法
every 检测数组所有元素是否都符合判断条件
定义: 方法用于检测数组所有元素是否都符合函数定义的条件
语法：
array.every(function(currentValue, index, arr), thisValue)
方法返回值规则:
- 如果数组中检测到有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测。
- 如果所有元素都满足条件，则返回 true。
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 数组中的是否有满足判断条件的元素
定义：数组中的是否有满足判断条件的元素
- 一真就真，全假才假
filter 过滤原始数组，返回新数组
定义: 返回一个新数组, 其包含通过所提供函数实现的测试的所有元素。
let a = [
{ name: 'x', age: 1 },
{ name: 'y', age: 2 },
{ name: 'z', age: 3 },
];
let filterArr = a.filter(item => item.age >= 2);
console.log(filterArr);//[{name: 'y', age: 2},{name: 'z', age: 3}]
map 对数组中的每个元素进行处理，返回新的数组
定义：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
let a = ['1', '2', '3'];
let b = [];
a.map((i, index) => {
let obj = {};
obj.name = i;
obj.id = index;
b.push(obj);
});
console.log(b); //[{name: '1', id: 0},{name: '2', id: 1},{name: '3', id: 2}]
reduce 为数组提供累加器，合并为一个值
定义：reduce() 方法对累加器和数组中的每个元素（从左到右）应用一个函数，最终合并为一个值。
语法：
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
参数：
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. total(必须)，初始值, 或者上一次调用回调返回的值
2. currentValue(必须),数组当前元素的值
3. index(可选), 当前元素的索引值
4. arr(可选),数组对象本身
回调第一次执行时:
- 如果 initialValue 在调用 reduce 时被提供，那么第一个 total 将等于 initialValue，此时 currentValue 等于数组中的第一个值；
- 如果 initialValue 未被提供，那么 total 等于数组中的第一个值，currentValue 等于数组中的第二个值。此时如果数组为空，那么将抛出 TypeError。
- 如果数组仅有一个元素，并且没有提供 initialValue，或提供了 initialValue 但数组为空，那么回调不会被执行，数组的唯一值将被返回。
// 数组求和
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]
更高级用法参考：25个你不得不知道的数组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)
// find
let a = [1, 2, 3, 4, 5, 6, 7].find(i => i > 1); //2
let b = [1, 2, 3, NaN].find(i => Object.is(NaN, i)); // 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
ES6 keys()&values()&entries() 遍历键名、遍历键值、遍历键名+键值
定义：三个方法都返回一个新的 Array Iterator 对象，对象根据方法不同包含不同的值。
语法：
array.keys()
array.values()
array.entries()
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
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']
搬运于：js 数组详细操作方法及解析合集
自己跟着敲一遍 加深印象
