增删数组
Array.push 末尾添加
// 1. push() 在我们数组的末尾 添加一个或者多个数组元素
var arr = [1, 2, 3];
arr.push(4, 5);
console.log(arr); //1,2,3,4,5
console.log(arr.push(6, 7));//7
// (1) push 是可以给数组追加新的元素
// (2) push() 参数直接写数组元素就可以了
// (3) push完毕之后，返回的结果是 新数组的长度
// (4) 原数组也会发生变化
Array.unshift 开头添加
// 2. unshift 在我们数组的开头 添加一个或者多个数组元素
var arr = [1, 2, 3];
arr.unshift(1,2);
console.log(arr);//1,2,1,2,3
// (1) unshift是可以给数组前面追加新的元素
// (2) unshift() 参数直接写数组元素就可以了
// (3) unshift完毕之后，返回的结果是 新数组的长度
// (4) 原数组也会发生变化
Array.pop 末尾删除
// 3. pop() 它可以删除数组的最后一个元素
var arr = [1, 2, 3];
arr.pop();
console.log(arr);//1,2
console.log(arr.pop());//3
// (1) pop是可以删除数组的最后一个元素 记住一次只能删除一个元素
// (2) pop() 没有参数
// (3) pop完毕之后，返回的结果是 删除的那个元素
// (4) 原数组也会发生变化
Array.shift 开头删除
// 4. shift() 它可以删除数组的第一个元素
var arr = [1, 2, 3];
arr.shift();
console.log(arr);//2,3
console.log(arr.shift());//1
// (1) shift是可以删除数组的第一个元素 记住一次只能删除一个元素
// (2) shift() 没有参数
// (3) shift完毕之后，返回的结果是 删除的那个元素
// (4) 原数组也会发生变化
// 总结删除返回的是删除的元素，添加返回的是数组的长度
排序数组
Array.reverse
var arr = [1, 64, 9, 6];
console.log(arr.reverse())//[6, 9, 64, 1]
Array.sort
var arr = [1, 64, 9, 6];
arr.sort(function(a, b) {
return b - a; // 降a序
// return a - b; // 升序
});
console.log(arr);//[64, 9, 6, 1]
数组索引
Array.indexOf
var arr = [1, 64, 9, 6];
arr.indexOf(64) //1
arr.indexOf(100) //-1
Array.lastIndexOf
var arr = [1, 64, 9, 6,6];
arr.lastIndexOf(6)//4
arr.lastIndexOf(100)//-1
数组转字符串
Array.join
let arr = ['green','yellow','red']
console.log(arr.join('-'))//'green-yellow-red'
数组合并
Array.concat
let a = [1, 2, 3]
let b = [2, 4, 5]
let c = a.concat(b，100)
console.log(c);//[1,2,3,2,4,5,100]
数组截取
Array.slice(start，end)
切片
- 从start开始截取到end但是不包括end
- 返回值为截取出来的元素的集合
- 原始的数组不会发生变化
//例子
var arr1 = [1,23,44,55,66,77,888,"fff"];
var arr2 = arr1.slice(2,4) //从index为2截取到index为4之前不包括4
console.log(arr2); //[44,55]
console.log(arr1); // [1,23,44,55,66,77,888,"fff"]原始数组没有被改变
Array. splice(start,deleteCount,item1,item2…..)
粘接
start参数 开始的位置
deleteCount 要截取的个数
后面的items为要添加的元素
如果deleteCount为0，则表示不删除元素，从start位置开始添加后面的几个元素到原始的数组里面
返回值为由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组
这个方法会改变原始数组，数组的长度会发生变化
//例子
var arr3 = [1,2,3,4,5,6,7,"f1","f2"];
var arr4 = arr3.splice(2,3) //删除第三个元素以后的三个数组元素(包含第三个元素)
console.log(arr4); //[3,4,5];
console.log(arr3); //[1,2,6,7,"f1","f2"]; 原始数组被改变
var arr5 = arr3.splice(2,0,"wu","leon");
//从第2位开始删除0个元素，插入"wu","leon"
console.log(arr5); //[] 返回空数组
console.log(arr3); // [1, 2, "wu", "leon", 6, 7, "f1", "f2"]; 原始数组被改变
var arr6 = arr3.splice(2,3,"xiao","long");
//从第2位开始删除3个元素，插入"xiao","long"
console.log(arr6); //["wu", "leon", 6]
console.log(arr3); //[1, 2, "xiao", "long", 7, "f1", "f2"]
var arr7 = arr3.splice(2);//从第三个元素开始删除所有的元素
console.log(arr7);//["xiao", "long", 7, "f1", "f2"]
console.log(arr3); //[1, 2]
Array.flat
有一个二维数组，我想让他变成一维数组
const arr = [1, 2, 3, [4, 5, 6]]
console.log(arr.flat()) // [ 1, 2, 3, 4, 5, 6 ]
还可以传参数，参数为降维的次数
const arr = [1, 2, 3, [4, 5, 6, [7, 8, 9]]]
console.log(arr.flat(2))
[
1, 2, 3, 4, 5,
6, 7, 8, 9
]
如果传的是一个无限大的数字，那么就实现了多维数组(无论几维)降为一维数组
const arr = [1, 2, 3, [4, 5, 6, [7, 8, 9, [10, 11, 12]]]]
console.log(arr.flat(Infinity))
[
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12
]
Array.flatMap
现在给你一个需求
let arr = ["科比 詹姆斯 安东尼", "利拉德 罗斯 麦科勒姆"];
将上面数组转为
[ '科比', '詹姆斯', '安东尼', '利拉德', '罗斯', '麦科勒姆' ]
第一时间想到map + flat
console.log(arr.map(x => x.split(" ")).flat());
// [ '科比', '詹姆斯', '安东尼', '利拉德', '罗斯', '麦科勒姆' ]
flatMap就是flat + map，一个方法顶两个
console.log(arr.flatMap(x => x.split(" ")));
// [ '科比', '詹姆斯', '安东尼', '利拉德', '罗斯', '麦科勒姆' ]
Array.isArray
判断是否为数组
Array.isArray(arr)
如果是数组，则返回true，否则为false
array.at(负数)
返回指定字符串索引值(位置对应的值)，当传递负数时，支持从字符串末端开始的相对索引；也就是说，如果使用负数，返回的字符将从字符串的末端开始倒数。
不传索引默认索引为0.
' '也是有意义的字符串，也占位。
let a = "a bcd"
let c = a.at(1);
let d = a.at(-1);
let e = a.at(4);
let f = a.at(5);
console.log(c);//
console.log(d);// d
console.log(e);// d
console.log(f);// undefinde
console.log(a.at())//a
Array.from(伪数组)
function doSomething () {
let args = Array.from(arguments);
console.log(args);
}
doSomething('一', '二', '三');
// 输出: ['一', '二', '三']
Array.from 的主要作用就是把伪数组和可遍历对象转换成数组的。
说“主要作用”的原因是因为 Array.from 还提供了2个参数可传。这样可以延伸很多种小玩法。 Array.from 的第二个参数是一个函数，类似 map遍历 方法。用来遍历的。 Array.from 的第三个参数接受一个 this 对象，用来改变 this 指向。
let helper = {
diff: 1,
add (value) {
return value + this.diff; // 注意这里有个 this
}
};
function translate () {
return Array.from(arguments, helper.add, helper);
}
let numbers = translate(1, 2, 3);
console.log(numbers); // 2, 3, 4
Array.from 其他玩法
创建长度为5的数组，且初始化数组每个元素都是1
let array = Array.from({length: 5}, () => 1)
console.log(array)
// 输出: [1, 1, 1, 1, 1]
第二个参数的作用和 map遍历 差不多的，所以 map遍历 有什么玩法，这里也可以做相同的功能。就不多赘述了。
把字符串转换成数组
let msg = 'hello';
let msgArr = Array.from(msg);
console.log(msgArr);
// 输出: ["h", "e", "l", "l", "o"]
如果传一个真正的数组给 Array.from 会返回一个一模一样的数组。
