数组的创建方式
1.使用Array构造函数
let arr_1 = new Array(); //创建一个空数组
let arr_2 = new Array(10); // 创建一个包含10项的数组
let arr_3 = new Array("zhangsan","lisi"); // 创建一个包含2个字符串的数组
console.log("arr_1",arr_1);
console.log("arr_2",arr_2);
console.log("arr_3",arr_3);
2.使用数组字面量
let arr_6 = []; //创建一个空数组
let arr_7 = [1,2,3,7,8,9]; // 创建一个包含6项的数组
let arr_8 = ["zhangsan","lisi"]; // 创建一个包含2个字符串的数组
console.log("arr_6",arr_6);
console.log("arr_7",arr_7);
console.log("arr_8",arr_8);
数组方法
数组原型上的主要方法有：
join()
push()
pop()
shift()
unshift()
sort()
reverse()
concat()
slice()
splice()
ES5新增
indexOf()
lastIndexOf()
forEach()
map()
filter()
every()
some()
reduce()
reduceRight()
ES6新增
find
findIndex
forEach
for in
for
for of
具体介绍
join()
join():方法将只接收一个参数即分隔符数，将数组元素组成一个以该分割符连接起来的字符串，省略的话则用默认用逗号为分隔符，原数组不变
let arr = [1,2,3];
console.log(arr.join());
console.log(arr.join("-"));
console.log(arr);
push()和pop()
push():在数组末尾添加，可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
pop()：删除数组末尾移除最后一项，数组的 length 值减少，然后返回移除的项。
let arr1 = ["zs","ls","ww"];
let arr1Length = arr1.push("zl","sq");
console.log(arr1Length);
console.log(arr1);
let item = arr1.pop();
console.log(item);
console.log(arr1);
shift() 和 unshift()
shift()：删除数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。
unshift()：将参数添加到原数组开头，并返回数组的长度 。
let arr3 = ["zs","ls","ww"];
let arr3Length = arr3.unshift("zl","sq");
console.log("arr3Length",arr3Length);
console.log(arr3);
let item2 = arr3.shift();
console.log("item2",item2);
console.log(arr3);
sort()
sort()：1.将数组中的元素按升序排列即默认排序，最小的值位于最前面，最大的值排在最后面。该方法会改变原数组。它会将数组中的元素按照字母顺序进行排序，即根据字符编码的顺序进行排序
let arr4 = ["a", "d", "c", "b"];
console.log(arr4.sort());
console.log("arr4",arr4)
arr5 = [12, 29, 61, 3,8];
console.log(arr5.sort());
console.log(arr5);
2.传递比较函数。可以通过传递一个比较函数来指定排序顺序。这个函数接收两个参数，并返回一个用于说明这两个值相对顺序的数字。如果比较函数返回一个小于0的值，则第一个参数会在排序后的数组中位于第二个参数之前；如果返回0，则它们相等；如果返回一个大于0的值，则第一个参数会在排序后的数组中位于第二个参数之后。
备注：sort()方法会改变原数组
let arr6 = [12, 29, 61, 3,8];
arr6.sort((a,b)=>{return a-b});
console.log("arr6",arr6);
reverse()
reverse()：反转数组元素的顺序，该方法会改变原数组。
let arr7 = [11, 26, 69, 38, 89 ];
console.log("arr7前",arr7);
arr7.reverse();
console.log("arr7后",arr7);
concat()
concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。如果 concat()方法没有参数，它只是复制当前数组并返回副本。
let arr8 = [11, 26, 69, 38, 89 ];
let a = 11;
let arr9 = arr8.concat(a);
console.log("arr8",arr8);
console.log("arr9",arr9);
let arr10 = ["zs","ls","ww"];
let arr11 = ["sq","sc"];
let arr12 = arr10.concat(arr11);
console.log("arr10",arr10);
console.log("arr11",arr11);
console.log("arr12",arr12);
slice()
slice()：返回从原数组中指定下标开始到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项，但不包括结束位置的项。该方法不会改变现有的数组。
当终止下标出现负数时，将负数加上数组长度的值来替换该位置的数，因此就是从1开始到5（不包括）的子数组
当开始下标出现负数时，将负数加上数组长度的值来替换该位置的数，因此就是从2开始到7（不包括）的子数组
let arr13 = ["a","b","c","d","e","f","g","h"];
let arr13S1 = arr13.slice(1);
let arr13S2 = arr13.slice(1,4);
let arr13S3 = arr13.slice(1,-3);
let arr13S4 = arr13.slice(-4,-1);
console.log("arr13",arr13);
console.log("arr13S1",arr13S1);
console.log("arr13S2",arr13S2);
console.log("arr13S3",arr13S3);
console.log("arr13S4",arr13S4);
splice()
splice() 方法向/从数组中添加/删除项目，返回被删除的项目。它有很多种用法，可以实现删除、插入和替换。该方法会改变原始数组。
a.只有一个参数：
splice(index) ， 从index的位置开始，删除之后的所有元素(包括第index位置的元素)
若 index < 0 , 则从数组后面删除index个元素
splice()函数返回删除元素数组
let arr14 = ["a","b","c","d","e","f","g","h"];
let arr14SP1 = arr14.splice(2);
console.log("arr14SP1",arr14SP1);
console.log("arr14",arr14);
let arr14SP2 = arr14.splice(-1);
console.log("arr14SP2",arr14SP2);
console.log("arr14",arr14);
b.两个参数
splice(index,num) ——> 删除从index位置开始的数，num为删除的个数
若 num小于等于 0，则不删除
let arr15 = ["a","b","c","d","e","f","g","h"];
let arr15SP1 = arr15.splice(2,3);
console.log("arr15SP1",arr15SP1);
console.log("arr15",arr15);
let arr15SP2 = arr15.splice(2,-1);
console.log("arr15SP2",arr15SP2);
console.log("arr15",arr15);
c.三个或三个以上参数
splice(index ,num, item1, …, itemX )
index >0 时
①. num为 0 时 不删除只添加，在index位置前添加item1, …, itemX的数
②. num> 0 删除且添加，在index位置前添加item1, …, itemX的数，并且删除从index位置开始的num为删除的个数。
let arr16 = ["a","b","c","d","e","f","g","h"];
let arr16SP1 = arr16.splice(2,0,1,2,3);
console.log("arr16SP1",arr16SP1);
console.log("arr16",arr16);
let arr16SP2 = arr16.splice(2,2,7,8,9);
console.log("arr16SP2",arr16SP2);
console.log("arr16",arr16);
index <0 时 数组最后一个为 -1 依次倒数第二个元素为-2
①. num为 0 时 不删除只添加 —— 在index位置前添加item1, …, itemX的数
②. num> 0 删除且添加 —— 在index位置前添加item1, …, itemX的数，并且删除从index位置开始的数，num为删除的个数
let arr17 = ["a","b","c","d","e","f","g","h"];
let arr17SP1 = arr17.splice(-2,0,1,2,3);
console.log("arr17SP1",arr17SP1);
console.log("arr17",arr17);
let arr17SP2 = arr17.splice(-2,1,8,9,10);
console.log("arr17SP2",arr17SP2);
console.log("arr17",arr17);
indexOf()和 lastIndexOf()
indexOf()：从数组的开头（位置 0）开始向后查找。返回某个指定的字符串值在字符串中首次出现的位置。接收两个参数：要查找的项和表示查找起点位置的索引（可选的） ，它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
lastIndexOf： 从数组的末尾开始向前查找。返回一个指定的字符串值最后出现的位置，接收两个参数：要查找的项和表示查找起点位置的索引（可选的）。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。
这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。
let arr18 = ["a","b","c","d","e","f","g","h"];
console.log(arr18.indexOf("c"));
console.log(arr18.indexOf("c",3));
console.log(arr18.lastIndexOf("g"));
console.log(arr18.lastIndexOf("g",3));
console.log("arr18",arr18);
forEach()
forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。该方法的第一个参数为回调函数，是必传的，它有三个参数：
item：必需。当前元素
index：可选。当前元素的索引值。
arr：可选。当前元素所属的数组对象
forEach 方法不会改变原数组，也没有返回值；
forEach无法使用 break，continue 跳出循环，使用 return 时，效果和在 for 循环中使用 continue 一致；
forEach 方法无法遍历对象，仅适用于数组的遍历。
let arr19 = ["a","b","c","d","e","f","g","h"];
arr19.forEach((item,index,arr)=>{
console.log(`${item}:${index}:${arr}`)
})
该方法还可以有第二个参数，用来绑定回调函数内部this变量（前提是回调函数不能是箭头函数，因为箭头函数没有this）
let arr20 = ["a","b","c","d","e","f","g","h"];
arr20.forEach(function(item,index,arr){
console.log(`${this[index]}`)
},arr20)
map()
map() 方法会返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。该方法按照原始数组元素顺序依次处理元素。
该方法的第一个参数为回调函数，是必传的，它有三个参数：
item：必须。当前元素的值；
index：可选。当前元素的索引值；
arr：可选。当前元素属于的数组对象。
let arr21 = [1,2,3,4,5,6];
let arr22 = arr21.map((item)=>{
return item*9
})
console.log("arr22",arr22);
console.log("arr21",arr21);
该方法的第二个参数（可选）用来绑定参数函数内部的this变量，不能使用箭头函数：
let arr23 = ["a","b","c","d"];
arr23.map(function(item,index){
console.log(`${this[index]}`)
},arr23)
备注：
map 方法不会对空数组进行检测；
map 方法遍历数组时会返回一个新数组，不会改变原始数组；
map 方法有返回值，可以return出来，map的回调函数中支持return返回值；
map 方法无法遍历对象，仅适用于数组的遍历。
for of
for…of 语句创建一个循环来迭代可迭代的对象。在 ES6 中引入的 for…of 循环，以替代 for…in 和 forEach() ：
该方法有两个参数：
item：每个迭代的属性值被分配给该变量。
arrObj：一个具有可枚举属性并且可以迭代的对象。
let arr24 = [
{id:1, name:'zs',age:18},
{id:2, name:'ls',age:19},
{id:3, name:'ww',age:20}
]
for (let item of arr24) {
console.log(`name is ${item.name},age is ${item.age}`);
}
console.log("arr24",arr24)
备注：
for of 不会改变原始数组；
for of 方法只会遍历当前对象的属性，不会遍历其原型链上的属性；
for of 方法适用遍历 数组/ 类数组/字符串/map/set 等拥有迭代器对象的集合；
for of 方法不支持遍历普通对象，因为其没有迭代器对象。如果想要遍历一个对象的属性，可以用 for in 方法；
可以使用break、continue、return来中断循环遍历；
filter()
filter()方法用于过滤数组，满足条件的元素会被返回。它的参数是一个回调函数，所有数组元素依次执行该函数，返回结果为true的元素会被返回，如果没有符合条件的元素，则返回空数组。
该方法的第一个参数为回调函数，是必传的，它有三个参数：
item：必须。当前元素的值；
index：可选。当前元素的索引值；
arr：可选。当前元素属于的数组对象。
它也有第二个参数，用来绑定参数函数内部的this变量。
let arr25 = [
{id:1, name:'zs',age:18},
{id:2, name:'ls',age:19},
{id:3, name:'ww',age:20},
{id:4, name:'zl',age:21},
{id:5, name:'sc',age:22},
]
let arr26 = arr25.filter((item)=>{
return item.age < 20
})
console.log("arr26",arr26);
console.log("arr25",arr25);
备注：
filter 方法会返回一个新的数组，不会改变原数组；
filter 方法不会对空数组进行检测；
filter 方法仅适用于检测数组。
some()、every()
some() 方法会对数组中的每一项进行遍历，只要有一个元素符合条件，就返回true，且剩余的元素不会再进行检测，否则就返回false。
every() 方法会对数组中的每一项进行遍历，只有所有元素都符合条件时，才返回true，如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
两个方法的第一个参数为回调函数，是必传的，它有三个参数：
item：必须。当前元素的值；
index：可选。当前元素的索引值；
arr：可选。当前元素属于的数组对象。
let arr27 = [
{id:1, name:'zs',age:18},
{id:2, name:'ls',age:19},
{id:3, name:'ww',age:20},
{id:4, name:'zl',age:21},
{id:5, name:'sc',age:22},
]
let someTest1 = arr27.some((item)=>{
return item.age > 30
})
let someTest2 = arr27.some((item)=>{
return item.age > 20
})
console.log("someTest1",someTest1);
console.log("someTest2",someTest2);
console.log("arr27",arr27);
let everyTest1 = arr27.every((item)=>{
return item.age > 20
})
let everyTest2 = arr27.every((item)=>{
return item.age > 17
})
console.log("everyTest1",everyTest1);
console.log("everyTest2",everyTest2);
console.log("arr27",arr27);
备注：
两个方法都不会改变原数组，会返回一个布尔值；
两个方法都不会对空数组进行检测；
两个方法都仅适用于检测数组。
reduce()、reduceRight()
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。
reduce 方法会为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，回调函数接受四个参数：
prev：上一次调用回调返回的值，或者是提供的初始值（initialValue）；
cur：当前被处理的元素；
index：当前元素的索引；
arr：当前元素所属的数组对象。
let arr28 = [2,4,6,8];
let sum = arr28.reduce((prev, cur, index, array)=>{
console.log("prev",prev);
console.log("cur",cur);
console.log("index",index);
console.log("array",array);
return prev + cur
})
console.log("sum",sum);
console.log("arr28",arr28);
该方法的第二个参数是 initialValue，表示传递给函数的初始值 （作为第一次调用 callback 的第一个参数）：
let arr29 = [2,4,6,8];
let sum2 = arr29.reduce((prev, cur, index, array)=>{
console.log("prev",prev);
console.log("cur",cur);
console.log("index",index);
console.log("array",array);
return prev + cur
},10)
console.log("sum2",sum2);
console.log("arr29",arr29);
如果没有提供初始值initialValue，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供了初始值initialValue，从索引0开始执行
备注：
两个方法都不会改变原数组；
两个方法对于空数组是不会执行回调函数的
find()、findIndex()
find() 方法返回通过函数内判断的数组的第一个元素的值。当数组中的元素在测试条件时返回 true 时， find() 返回符合条件的元素，之后的值不会再调用执行函数。如果没有符合条件的元素返回 undefined。
findIndex() 方法返回传入一个测试函数符合条件的数组第一个元素位置（索引）。当数组中的元素在函数条件时返回 true 时， findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。如果没有符合条件的元素返回 -1。
两个方法的第一个参数为回调函数，是必传的，它有三个参数：
item：必需。当前元素；
index：可选。当前元素的索引；
arr：可选。当前元素所属的数组对象。
let arr30 = [2,4,6,8,10,12,20];
let findTest = arr30.find((item)=>{
return item>10;
})
let findTest2 = arr30.find((item)=>{
return item>21;
})
console.log("findTest",findTest);
console.log("findTest2",findTest2);
console.log("arr30",arr30);
let findIndexTest = arr30.findIndex((item)=>{
return item>10;
})
let findIndexTest2 = arr30.findIndex((item)=>{
return item>21;
})
console.log("findIndexTest",findIndexTest);
console.log("findIndexTest2",findIndexTest2);
console.log("arr30",arr30);
find()和findIndex()两个方法几乎一样，只是返回结果不同：
find()：返回的是第一个符合条件的值；
findIndex：返回的是第一个返回条件的值的索引值。
备注：
两个方法对于空数组，函数是不会执行的；
两个方法都不会改变原数组。
扩展运算符（…）
扩展运算符是三个点（…），它可以将一个数组或对象展开成多个元素，或将多个元素合并成一个数组或对象。
扩展运算符的作用
数组的展、合并、复制和解构赋值
对象的展开、合并、复制和解构赋值
函数参数的传递和返回值的处理
这里探讨在数组中的应用
①数组的展开
使用扩展运算符可以将一个数组展开成多个元素；
let arr31 = ["a","b","c"];
console.log(...arr31);
②数组的合并
使用扩展运算符可以将多个数组合并成一个数组
let arr32 = ["x","y","z"];
let arr33 = [1,2,3];
let arr34 = [...arr32,...arr33];
console.log("arr34",arr34);
console.log("arr32",arr32);
console.log("arr33",arr33);
③数组的复制
let arr35 = ["a",1,"b",2];
let arr36 = [...arr35];
console.log("arr36",arr36);
console.log("arr35",arr35);
④数组的解构赋值
数组解构赋值是一种语法，它允许我们从数组中提取值并将它们赋给变量。数组解构赋值的语法使用方括号（[]），里面填写变量对应要结构的数组，然后通过等号（=）将解构的值赋给变量。
let arr37 = [8,9,10];
let [x,y,z] = arr37;
console.log("x",x);
console.log("y",y);
console.log("z",z);
舍弃某些元素
let arr38 = [100,200,300];
let [,,t] = arr38;
console.log("t",t);
console.log("arr38",arr38);
不定元素
let arr39 = ["a","b","c","d","e","f","g","h"];
let [m,n,...p] = arr39;
console.log("m",m);
console.log("n",n);
console.log("p",p);
console.log("arr39",arr39);
默认值
let arr40 = ["a","b"];
let [j,h=10,k=20] = arr40;
console.log("j",j);
console.log("h",h);
console.log("k",k);
console.log("arr40",arr40);
end…
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
