数组的创建方式
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…