数组基础方法
Array.push 方法
该方法向原数组末尾添加元素，返回undefined
Array.pop 方法
该方法向原数组首部添加元素，返回undefined
Array.shift 方法
该方法删除原数组第一个元素，返回undefined
Array.unshiff 方法
该方法删除原数组最后一个元素，返回undefined
Array.concat 方法
Array.concat(ary1,ary2)该方法可以拼接两个或多个数组，并返回一个新数组
let ary = [1,2,3,4]
let newAry = ary.concat([6,7,8]);
console.log(newAry) // [1,2,3,4,5,6,7,8]
Array.join 方法
该方法将数组以指定字符拼接成字符串，并返回一个新字符串，如果数组为空，则返回一个空字符串
let ary = [1,2,3,4]
let newStr = ary.join(",");
console.log(newStr) // 1,2,3,4
Array.splice 方法
该方法可以实现对原数组的增删改查，并以数组形式返回删除的元素
Array.splice(开始位置,删除的个数,添加的元素)
当开始位置大于数组长度时，默认不会删除原数组中任何元素，但是如果存在添加的元素，会在原数组末尾添加元素，并且返回值是空数组。
let ary = [1,2,3,4,5,6]
let newAry = ary.splice(0,2,"add")
console.log(ary) // ["add", 3, 4, 5, 6]
console.log(newAry) // [1, 2]
Array.isArray 方法
该方法判断是否是数组，返回布尔值
let ary = [1,2,3]
let bol = Array.isArray(ary); // bol 返回true
数组遍历方法
Array.forEach()
该方法遍历数组，不会改变原数组，无返回值（返回undefined）
let ary = [1,2,3,4,5,6]
let newAry = ary.forEach((item,index)=>{
console.log(`第${index + 1}位元素：${item}`)
})
console.log(ary) // 原数组
console.log(newAry) // undefined
Array.map()
该方法遍历原数组，返回新数组
- 如果
map回调函数中没有return，返回的数组中将自动填充undefined - 如果
map回调函数中有return值，那么返回的数组中将是对应的return值
let ary = [1,2,3,4]
let newAry = ary.map((item,index)=>{
if(item === 3){
return "a";
}
return item;
})
console.log(ary) // 原数组不改变
console.log(newAry) // [1,2,"a",4]
Array.filter()
该方法遍历元素组，返回新数组
- 如果
filter回调函数中没有return，将跳过该循环，不对返回的数组做处理` - 如果
filter回调函数中有return，则返回的新数组中将填充return值
let ary = [1,2,3,4,5,6]
let newAry = ary.filter((item,index)=>{
if(item > 4){
return item;
}
})
console.log(ary) // 原数组
console.log(newAry) // [5,6]
Array.every()
该方法将所有元素进行判断，如果所有都符合某个条件，返回true,否则返回false
- 不改变元素组
- 返回值为布尔值
let ary = [4,5,6]
let bol = ary.every((item,index)=>{
return item > 1;
})
console.log(ary) // 原数组
console.log(bol) // true
Array.some()
该方法将所有元素进行判断，如果其中有一个符合某个条件，返回true,否则返回false
let ary = [4,5,6]
let newAry = ary.some((item,index)=>{
return item > 5;
})
console.log(ary)// 原数组
console.log(newAry) // true
Array.reduce()
该方法将数组元素进行累计操作，返回累计操作的最终结果
let ary = [1,2,3,4]
let result = ary.reduce((a,b)=>{
return a + b; // 累加操作
})
console.log(result) // 结果为 10
Array.reduceRight()
该方法和Array.reduce 方法类似，只不过是从右往左遍历
let ary = [1,2,3,4]
let result = ary.reduceRight((a,b)=>{
return a - b ; // 从右累减操作
})
console.log(result) // -2
数组检索方法
Array.indexOf()
该方法，检索数组中的元素，如果存在返回该元素(第一个元素)的下标，否则返回-1
let ary = [1,2,3,4]
let result = ary.indexOf(2)
let resultTwo = ary.indexOf(10)
console.log(result) // 1
console.log(resultTwo) // -1
Array.find() -ES6
该方法返回数组中符合测试函数条件的第一个元素。否则返回undefined
let ary = [
{name:"小王",age:20},
{name:"小牛",age:21},
{name:"小李",age:23},
{name:"小张",age:20}
]
let newAry = ary.find((item)=>{
return item.age === 20;
})
console.log(newAry) // {name:"小王",age:20}
Array.findIndex() -ES6
该方法和find方法类似，只不过返回值为索引值，如果没有符合条件的数据，返回-1
let ary = [
{name:"小王",age:20},
{name:"小李",age:23},
{name:"小张",age:20}
]
let newAry = ary.find((item)=>{
return item.age === 20;
})
console.log(newAry) // 0
Array.includes() -ES6
该方法检索是否包含一个指定的值，是返回true, 否则返回false
let ary = [1,2,3,4]
ary.includes(2); // true
ary.includes(11); // false
其它 ES6 新增方法
Array.form()
Array.from(ary,callback)方法用于将类对象转为真正的数组
- 第一个参数可以是类数组也可是数组
- 第二个参数是个函数，类似
map可以处理每个元素，并返回处理后的数组
let NodeList = {
0:"a",
1:"b",
3:"d",
length:4,
}
let ary = Array.from(NodeList);
console.log(ary) // ["a", "b", undefined, "d"]
// es5
[].slice.call(NodeList); // ["a", "b", empty, "d"]
let NodeList = {
0:"a",
1:"b",
3:"d",
length:4,
}
let ary = Array.from(NodeList,(item,index)=>{
return index + item;
});
console.log(ary) // ["0a", "1b", NaN, "3d"]
Array.of()
该方法用于将一组值，转换为数组。
let ary = Array.of(1,2,3,4) // [1,2,3,4]
Array.fill()
该方法使用给定值，填充一个数组
let ary = [1,2,3].of("a") // ["a","a","a"]
Array.copyWithin()
该方法可以将指定位置的元素替换当前数组（原数组） 内其它位置的元素 该方法有三个参数，都是Number值
- 参数1：必需，该参数表示开始替换的位置，从0开始包含该位置。如果为负数则从数组后边开始
- 参数2：选填，开始读取的位置，默认为0，负数表示从末尾开始
- 参数3：选填，结束读取的位置，默认数组长度，负数表示从末尾开始
let ary = [1,2,3,4,5,6];
ary.copyWithin(2,3,5); // [1, 2, 4, 5, 5, 6]
let ary2 = [1,2,3,4,5,6];
ary2.copyWithin(-1,0,2); // [1, 2, 3, 4, 5, 1]
Array.flat()
该方法用于将多维数组拉平为一维数组,默认只展开二维数组，可以传入数字参数，来规定展开维度，如果想全部展开可以传入Infinity
let ary = [1,2,[3,4,[5,6]]];
let ary1 = ary.flat(); // [1, 2, 3, 4, [5,6]]
let ary2 = ary.flat(2); // [1, 2, 3, 4, 5, 6]
let ary3 = ary.flat(Infinity); // [1, 2, 3, 4, 5, 6]
