【JS】数组常用的方法（工作必用）

unshift()：是在数组开始添加元素，返回添加后的长度；

var arr = [1, 2, 3]
var val = arr.unshift(0);
console.log('返回数组长度：', val)	// 4
console.log('改变后的数组：', arr)	// [0, 1, 2, 3]

push()：是在数组末尾添加元素，返回数组最新长度；

var arr = [1, 2, 3]
var val = arr.push(4);
console.log('返回数组长度：', val)	// 4
console.log('改变后的数组：', arr)	// [1, 2, 3, 4]

pop()：删除最后一个元素，返回被删除的元素；

var arr = [1, 2, 3]
var val = arr.pop();
console.log('返回数组长度：', val)	// 3
console.log('改变后的数组：', arr)	// [1, 2]

shift()：删除元素的第一个元素并返回被删除的元素；

var arr = [1,2,3]
var val = arr.shift();
console.log('被删除的元素：', val)	// 1
console.log('改变后的元素：', arr)	// [2, 3]
// 不能在 log 这样打印被删除的元素，不然会默认执行一次
// console.log('被删除的元素：', arr.shift())

splice()：添加或者删除元素，第一个数为从第几个数删除。第二个数表示删除第几个数，第三个数开始为要添加的元素；返回新数组；

// 删除元素
let colors = ['red','green','blue'];
let removed = colors.splice(0,1);   // 删除一项
console.log(colors);    // ['green','blue']
console.log(removed);    // ['red'] 只有一个元素的数组

// 插入元素
let colors2 = ['red','green','blue'];
let removed2 = colors2.splice(1,0,'yellow','orange'); //表示从索引为 1 插入两个元素
console.log(colors2);    // ['red','yellow','orange','green','blue']
console.log(removed2);   // [] 空数组

// 修改元素
let colors3 = ['red','green','blue'];
let removed3 = colors3.splice(1,1,'yellow','orange');    // 先删除索引为1的位置删除1个元素后插入
console.log(colors3);    // ['red','yellow','orange','blue']
console.log(removed3);   // ['green'] 只有一个值的数组

----------以上方法会改变原数组 ----------

map()：创建新的数组，数组中的元素是return什么数值就将元素放入数组中；

let numArr= [1,2,3];
//将数组的每一项都+1，并返回一个包含所有结果的新数组
let result = numArr.map((item) => item+1);
console.log(result );	//[2,3,4]

let objArr= [{a:1},{a:2}];
//将数组的每个对象都添加新属性c,值为1
let result = objArr.map((item) =>{
	item.c = 1;
	return item
});
console.log(result);	//[{a:1,c:1},{a:2,c:1}];

filter()：创建新的数组，是返回为ture的成员组成的新数组；不改变原数组；

let numArr= [1,2,3];
let result = numArr.map((item) => item>1);
console.log(result );	//[2,3]

let objArr= [{a:1},{a:2}];
//将数组的每个对象都添加新属性c,值为1
let result = objArr.map((item) =>{
	return item.a===2
});
console.log(result);	//[{a:2}];

forEach()：遍历数组，每个元素都执行一次的函数；

• 数组的长度是多少，这个函数就会执行多少回；

let numArr= [1,2,3],count=0
numArr.forEach((item,index,arr) => count++);
	console.log(count);	// 3
	//item就是数组红的每一项
	//index 就是每一项对应的索引
	//arr 就是原始数组
	console.log(item);
	console.log(index);
	console.log(arr);

find()：返回满足测试函数的第一个元素的值，不满足则返回undefind;

let objArr= [{a:1},{a:2}];
// 不改变原数组
let result = objArr.find((item) =>{
	return item.a===2
});
let result1 = objArr.find((item) =>{
	return item.a===21
});
console.log(result);	//{a:2};
console.log(result1);	//undefind

findIndex()：返回满足测试函数的第一个元素的所索引，不满足则返回undefind;

indexOf():返回数组中某个元素的索引；

let objArr= [{a:1},{a:2}];
// 不改变原数组
let result = objArr.find((item) =>{
	return item.a===2
});
let result1 = objArr.find((item) =>{
	return item.a===21
});
console.log(result);	//1
console.log(result1);	//undefind

every()：所有元素都必须满足指定函数的测试，返回一个布尔值；

let numArr= [1,2,3]
let result = numArr.some((item) =>{
	return item > 1
});
console.log(result);	//false

some()：至少有一个元素满足指定函数的测试，返回一个布尔值；

let numArr= [1,2,3]
let result = numArr.some((item) =>{
	return item>1
});
console.log(result);	//true

join(separator)：将数组的元素连接成字符串，不改变原素组；

 // 参数：
- 如果 separator 不填， 数组元素默认用 逗号(,)分隔。
- 如果 separator 是空字符串 ("")，则所有元素之间都没有任何字符。
- 如果 separator 是未定义的 (undefined)，则数组元素用 逗号(,)分隔。
- 如果数据里面有元素为 undefined 或 null，它会被转换为空字符串
let numArr= [1,2,3]
let result = numArr.join()
let result1 = numArr.join("+")
console.log(result);	//1,2,3
console.log(result1);	//1+2+3
// 数组中含有 undefined 和 null
console.log([undefined,2,null].join());	// 打印结果：,2,

concat()：用于连接两个或多个数组；

let colors = ['red','green','blue'];
// colors调用concat（）方法，传入字符串‘yellow’ 和 一个包含‘bleak’和‘brown’的数组。
let colors2 = colors.concat('yellow',['bleak','brown','green']);
console.log(colors);    //['red','green','blue']
console.log(colors2);   
//发现green重复了，concat不会去重
//['red','green','blue','yellow','bleak','brown','green']

includes()：判断一个数组是否包含一个指定的值；

let numArr= [1,2,3]
let result = numArr.includes(3)
let result1 = numArr.includes(2,3)
console.log(result);	//true
console.log(result1);	//false

reverse()：对数组进行倒序；

let numArr= [1,2,3]
let result = numArr.reverse()
console.log(result);	//[3,2,1]

flat()：扁平化（降维）数组，会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回

var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]

//使用 Infinity，可展开任意深度的嵌套数组
var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]