大家好，我是蓝胖子的小叮当，今天分享的是JavaScript的第十一章数组方法总结，大家在阅读期间有任何的意见或建议都可以留言给我哈！
11.1创建数组
let a = Array(); // []
let a = Array(3); // [,,]
let a = Array(3,11,8); // [ 3,11,8 ]
let a = Array.of(3, 11, 8); // [3,11,8]
let a = Array.of(3); // [3]
let obj = {0: 'a', 1: 'b', 2:'c', length: 3};
let arr = Array.from(obj); // ['a','b','c'];
let arr = Array.from('hello'); // ['h','e','l','l','o']
let arr = Array.from(new Set(['a','b','b'])); // ['a','b']
11.2改变原数组
11.2.1 splice添加/删除数组元素
定义： splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目
语法： array.splice(index,howmany,item1,.....,itemX)
参数:
- index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
- howmany：可选。要删除的项目数量。如果设置为 0，则不会删除项目。
- item1, ..., itemX： 可选。向数组添加的新项目。
//删除
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0, 3); // [1,2,3]
console.log(a); // [4,5,6,7]
//删除并添加
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0,3,'添加'); // [1,2,3]
console.log(a); // ['添加',4,5,6,7]
// 从数组下标0开始，删除3个元素，并添加元素'添加'
let b = [1, 2, 3, 4, 5, 6, 7];
let item = b.splice(-2,3,'添加1','添加2'); // [6,7]
console.log(b); // [1,2,3,4,5,'添加1','添加2']
// 从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2'
// 不删除添加
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0,0,'添加1','添加2'); // [] 没有删除元素，返回空数组
console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]
let b = [1, 2, 3, 4, 5, 6, 7];
let item = b.splice(-1,0,'添加1','添加2'); // [] 没有删除元素，返回空数组
console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最后一个元素的前面添加两个元素
11.2.2 sort 数组排序
定义: sort()方法对数组元素进行排序，并返回这个数组。
参数可选: 规定排序顺序的比较函数。
默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。
// 1.不传函数
// 字符串排列 看起来很正常
let a = ["Banana", "Orange", "Apple", "Mango"];
a.sort(); // ["Apple","Banana","Mango","Orange"]
// 数字排序的时候 因为转换成Unicode字符串之后，有些数字会比较大会排在后面 这显然不是我们想要的
let a = [10, 1, 3, 20,25,8];
console.log(a.sort()) // [1,10,20,25,3,8];
// 2.传入函数
// 数组元素为数字的升序、降序
let array = [10, 1, 3, 4,20,4,25,8];
// 升序 a-b < 0 a将排到b的前面，按照a的大小来排序的
// 比如被减数a是10，减数是20 10-20 < 0 被减数a(10)在减数b(20)前面
array.sort(function(a,b){
return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];
// 降序 被减数和减数调换了 20-10>0 被减数b(20)在减数a(10)的前面
array.sort(function(a,b){
return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];
// 数组多条件排序
let array = [{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的值降序
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}]
// 运用好返回值自定义比较函数
let array = [{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<0 a排在b的前面
return -1
}else{ // 如果不是的话，a排在b的后面
return 1
}
})
// [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}]
11.2.3 pop 删除一个数组中最后一个元素
定义: pop() 方法删除一个数组中的最后的一个元素，并且返回这个元素。
let a = [1,2,3];
let item = a.pop(); // 3
console.log(a); // [1,2]
11.2.4 shift 删除数组的第一个元素
定义: shift()方法删除数组的第一个元素，并返回这个元素。
let a = [1,2,3];
let item = a.shift(); // 1
console.log(a); // [2,3]
11.2.5 push 向数组的末尾添加元素
定义：push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
参数: item1, item2, ..., itemX ,要添加到数组末尾的元素
let a = [1,2,3];
let item = a.push('末尾'); // 4
console.log(a); // [1,2,3,'末尾']
11.2.6 unshift 向数组的开头添加元素
定义：unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
参数: item1, item2, ..., itemX ,要添加到数组开头的元素
let a = [1,2,3];
let item = a.unshift('开头'); // 4
console.log(a); // ['开头',1,2,3]
11.2.7 reverse 颠倒元素中的顺序
定义: reverse() 方法用于颠倒数组中元素的顺序。
let a = [1,2,3];
a.reverse();
console.log(a); // [3,2,1]
11.2.8 copyWithin 指定位置的成员复制到其他位置
定义: 在当前数组内部，将指定位置的成员复制到其他位置,并返回这个数组。
语法： array.copyWithin(target, start = 0, end = this.length)
参数:
三个参数都是数值，如果不是，会自动转为数值.
- target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
- start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
- end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]
let 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"]
11.2.9 fill 填充数组
定义: 使用给定值，填充一个数组。
参数:
第一个元素(必须): 要填充数组的值
第二个元素(可选): 填充的开始位置,默认值为0
第三个元素(可选)：填充的结束位置，默认是为this.length
['a', 'b', 'c'].fill(7)
// [7, 7, 7]
['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']
11.3不改变原数组
11.3.1 slice 浅拷贝取出数组元素
定义： 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象，且原数组不会被修改。
注意：字符串也有一个slice() 方法是用来提取字符串的，不要弄混了。
语法：array.slice(begin, end);
参数:
begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。
end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。
let a= ['hello','world'];
let b=a.slice(0,1); // ['hello']
a[0]='改变原数组';
console.log(a,b); // ['改变原数组','world'] ['hello']
b[0]='改变拷贝的数组';
console.log(a,b); // ['改变原数组','world'] ['改变拷贝的数组']
11.3.2 join 数组转字符串
定义: join() 方法用于把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串，返回生成的字符串
let a= ['hello','world'];
let str=a.join(); // 'hello,world'
let str2=a.join('+'); // 'hello+world'
let a= [['OBKoro1','23'],'test'];
let str1=a.join(); // OBKoro1,23,test
11.3.3 toLocaleString 数组转字符串
定义: 返回一个表示数组元素的字符串。该字符串由数组中的每个元素的 toLocaleString() 返回值经调用 join() 方法连接（由逗号隔开）组成。
let a=[{name:'OBKoro1'},23,'abcd',new Date()];
let str=a.toLocaleString(); // [object Object],23,abcd,2024/5/28 下午3:21:10
11.3.4 toString 数组转字符串
定义: toString() 方法可把数组转换为由逗号链接起来的字符串。
let b= [ 'toString','演示'].toString(); // toString,演示
let a= ['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦
11.3.5 concat 合并数组
定义： 方法用于合并两个或多个数组，返回一个新数组。
语法： var newArr =oldArray.concat(arrayX,arrayX,......,arrayX)
let a = [1, 2, 3];
let b = [4, 5, 6];
//连接两个数组
let newVal=a.concat(b); // [1,2,3,4,5,6]
// 连接三个数组
let c = [7, 8, 9]
let newVal2 = a.concat(b, c); // [1,2,3,4,5,6,7,8,9]
// 添加元素
let newVal3 = a.concat('添加元素',b, c,'再加一个');
// [1,2,3,"添加元素",4,5,6,7,8,9,"再加一个"]
// 合并嵌套数组 会浅拷贝嵌套数组
let d = [1,2 ];
let f = [3,[4]];
let newVal4 = d.concat(f); // [1,2,3,[4]]
let a = [2, 3, 4, 5]
let b = [ 4,...a, 4, 4]
console.log(a,b); // [2, 3, 4, 5] [4,2,3,4,5,4,4]
11.3.6 indexOf查找数组是否存在某个元素 返回下标
定义: 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
语法: array.indexOf(searchElement,fromIndex)
参数:
searchElement(必须):被查找的元素
fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。
let a=['啦啦',2,4,24,NaN]
console.log(a.indexOf('啦')); // -1
console.log(a.indexOf('NaN')); // -1
console.log(a.indexOf('啦啦')); // 0
11.3.7 lastIndexOf查找数组中指定元素的最后一个位置
定义: 方法返回指定元素,在数组中的最后一个的索引，如果不存在则返回 -1。（从数组后面往前查找）
语法: arr.lastIndexOf(searchElement,fromIndex)
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 数组长度为10
// let b=a.lastIndexOf('Koro1',4); // 从下标4开始往前找 返回下标2
// let b=a.lastIndexOf('Koro1',100); // 大于或数组的长度 查找整个数组 返回9
// let b=a.lastIndexOf('Koro1',-11); // -1 数组不会被查找
let b=a.lastIndexOf('Koro1',-9); // 从第二个元素4往前查找，没有找到 返回-1
11.3.8 includes 查找数组会否包含某个值返回布尔
定义： 返回一个布尔值，表示某个数组是否包含给定的值
语法： array.includes(searchElement,fromIndex=0)
参数：
searchElement(必须):被查找的元素
fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。
let a=['OB','Koro1',1,NaN];
// let b=a.includes(NaN); // true 识别NaN
// let b=a.includes('Koro1',100); // false 超过数组长度 不搜索
// let b=a.includes('Koro1',-3); // true 从倒数第三个元素开始搜索
// let b=a.includes('Koro1',-100); // true 负值绝对值超过数组长度，搜索整个数组
11.3.9 flat 数组扁平化
定义：扁平化数组
语法：animals.flat(index);
参数： index不传时默认返回1层，传入整数即拉平的层数，传入Infinity关键字时转为以为数组，传入<=0将返回原数组
const animals = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]];
// 不传参数时，默认“拉平”一层
animals.flat();
// ["a", "b", "c", "d", ["e", ["f"]], "g"]
// 传入一个整数参数，整数即“拉平”的层数
animals.flat(2);
// ["a", "b", "c", "d", "e", ["f"], "g"]
// Infinity 关键字作为参数时，无论多少层嵌套，都会转为一维数组
animals.flat(Infinity);
// ["a", "b", "c", "d", "e", "f", "g"]
// 传入 <=0 的整数将返回原数组，不“拉平”
animals.flat(0);
animals.flat(-10);
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]];
// 如果原数组有空位，flat()方法会跳过空位。
["a", "b", "c", "d",,].flat();
// ["a", "b", "c", "d"]
11.4遍历数组
11.4.1 forEach
定义: 按升序为数组中含有效值的每一项执行一次回调函数。
语法：array.forEach(function(currentValue, index, arr), thisValue)
参数：
currentValue(必须),数组当前元素的值
index(可选), 当前元素的索引值
arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
let a = [1, 2, ,3]; // 最后第二个元素是空的，不会遍历(undefined、null会遍历)
let obj = { name: 'OBKoro1' };
let result = 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会报错
return value; // return只能结束本次回调 会执行下次回调
console.log('不会执行，因为return 会执行下一次循环回调')
}, obj);
console.log(result); // 即使return了一个值,也还是返回undefined
// 回调函数也接受接头函数写法
11.4.2 every 检测数组内所有元素是否都符合判断条件
定义: 方法用于检测数组所有元素是否都符合函数定义的条件
语法：array.every(function(currentValue, index, arr), thisValue)
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
11.4.3 some 数组中是否有满足判断条件元素
定义：数组中的是否有满足判断条件的元素
语法：array.some(function(currentValue, index, arr), thisValue)
function isBigEnough(element, index, array) {
return element >= 10; // 判断数组中是否有满足判断条件的元素
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true
11.4.4 filter 过滤原数组 返回新数组
定义: 返回一个新数组, 其包含通过所提供函数实现的测试的所有元素。
语法：let new_array = arr.filter(function(currentValue, index, arr), thisArg)
let a = [32, 33, 16, 40];
let result = a.filter(function (value, index, array) {
return value >= 18; // 返回a数组中所有大于18的元素
});
console.log(result,a);// [32,33,40] [32,33,16,40]
11.4.5 map 对数组每个值进行处理 返回新数组
定义：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
语法：let new_array = arr.map(function(currentValue, index, arr), thisArg)
let a = ['1','2','3','4'];
let result = a.map(function (value, index, array) {
return value + '新数组的新元素'
});
console.log(result, a);
// ["1新数组的新元素","2新数组的新元素","3新数组的新元素","4新数组的新元素"] ["1","2","3","4"]
11.4.6 reduce 为数组提供累加器 合并为一个值
定义：reduce() 方法对累加器和数组中的每个元素（从左到右）应用一个函数，最终合并为一个值。
语法：array.reduce(function(total, currentValue, currentIndex, arr), 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]
11.4.7 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, 4, -5, 10].find((n) => n < 0); // 返回元素-5
let b = [1, 4, -5, 10,NaN].find((n) => Object.is(NaN, n)); // 返回元素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
11.4.8 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"
好啦，关于数组方法的知识点就总结到这里，如果有什么疑问、意见或建议，都可畅所欲言，谢谢大家，我也将持续更新。
预告：不理解高阶函数和高阶组件的含义？欢迎收看JavaScript基础的下一章：高阶函数、高阶组件
