添加/删除元素：
push(...items) 从结尾添加元素
pop() 从结尾删除元素
shift() 从开头删除元素
unshift(...items) 从开头添加元素
splice(pos,deeteCount,...items) 从index开始，删除deleteCount元素并在当前位置插入元素
slice(start,end) 从所有元素的开始所有 start复制到end，返回一个新的数组
concat(...items) 返回一个新数组，复制当前数组的所有成员并向其中添加items。如果有任何items是一个数组，那
就取其元素。
查询元素：
indexOf/lastIndexOf(item,pos) 从pos找到item，则返回索引否则返回 -1
includes(value) 如果数组有value，则返回true，否则返回false
find/filter(func) 通过函数过滤元素，返回true添加的符合find函数的第一个值或符合filter函数的全部值。
findIndex 和find 类似，但返回索引而不是值
转换数组：
map(func) 从每个元素调用func 的结果创建一个新数组
sort(func) 将数组倒序排列，然后返回
reverse() 在原地颠倒数组，然后返回它
split/join 将字符串转换为数组并返回
reduce(func,inital) 通过每个元素调用func 计算数组上的单个值并在调用之间传递中间结果
迭代元素：
forEach(func) 为每个元素调用func,不返回任何东西
其他：
Array.isArray(arr) 检查arr是否是一个数组
arr.some(fn)/arr.every(fn) 检查数组：类似于map的数组每个元素上调用函数fn,如果任何/所有结果为true，
则返回true，否则返回false。
arr.copyWithin(target,start,end) 将元素从start 到end 在 target 位置复制到本身。
生成类似[1-100]这样的数组：
let arr = new Array(100).fill(0).map((item,index)=>index+1)
数组解构赋值应用：
//交换变量
[a,b] = [b,a]
[o.a,o.b] = [o.b,o.a]
//生成剩余数组
const [a,...rest] = [...'asdf']//a:'a',rest:['s','d','f']
数组浅拷贝
const arr = [1,2,3]
const arrClone = [...arr]
//对象也可以这样浅拷贝
const obj = {a:1}
const objClone = {...obj}
数组合并
const arr1=[1,2,3]
const arr2=[4,5,6]
const arr3=[7,8,9]
const arrs = [...arr1,...arr2,...arr3]
//或者使用 concat 也可以， arr1.concat(arr2,arr3)。
数组去重
const arr = [1,2,1,2,1,2,3,5,6,7]
const uniqueArr = [...new Set(arr)]
//new Set(arr) 接受一个数组参数并生成一个set结构的数据类型。set数据类型的元素不会重复且是 array iterator,
所以可以利用这个特性来去重。
数组取交集
let arr1 = [1,2,3,4,2];
let arr2 = [1,2,6,5,2,2];
let arr3;
arr3 = arr1.filter(function(val){
return arr2.indexOf(val) > -1
})
或者
let arr1set = new Set(arr1);
let arr2set = new Set(arr2);
arr3 = arr1.filter(item => arr2set.has(item))
console.log(arr3);//[1,2,2]
数组常用方法：
map: 遍历数组，返回回调返回值组成的新数组
forEach: 无法break，可以用try/catch 中 throw new Error 来停止
filter：过滤
some: 有一项返回true，整体为true
every： 有一项返回false,则整体为false
join: 通过指定连接符生成字符串
push/pop: 末尾添加或删除，改变原数组，push返回数组长度，pop返回原数组最后一项
unshift / shift：头部添加和删除，改变原数组，unshift返回数组长度，shift返回原数组第一项
sort(fn) / reverse: 排序与反转，改变原数组
concat：连接数组，不影响原数组，浅拷贝
slice(start,end):返回截断后的新数组，不改变原数组
splice(start,number,value...):返回删除元素组成的数组，value为插入项，改变原数组
indexOf / lastIndexOf(value,fromIndex): 查找数组项，返回对应的下标
reduce / reduceRight(fn(prev,cur),defaultPrev):两两执行，prev为上次化简函数的return值，cur为当前值
当传入 defaultPrev时，从第一项开始
当未传入时，则为第二项
数组乱序：
var arr = [1,2,3,4,5,6,7,8,9,10];
arr.sort(function(){
return Math.random() - 0.5;
})
数组拆解： flat:[1,[2,3]] -->[1,2,3]
Array.prototype.flat = function(){
return this.toString().split(',').map(item=>+item)
}
数组降维处理方式
1、递归
function reduceDimension(arr){
let res = [];
let toArr = function(arr){
arr.forEach(function(item){
item instanceof Array ? toArr(item) : res.push(item);
})
}
toArra(arr);
return res
}
//调用此方法
let arr = [1,2,[3,4,[5,6]]]
let result = reduceDimension(arr);
console.log(result);//[1,2,3,4,5,6];
2、Array.prototype.flat()
let arr1 = [1,2,[3,4,[5,6]]];
let arr3 = arr1.flat(Infinity);//[1,2,3,4,5,6] Infinity 作为深度，展开任意深度的嵌套数组。
3、利用扩展运算符
let arr1 = [1,2,[3,4,[5,6]]];
function arrayDimensionReducion(arr,result = []){
while(arr.some(Array.isArray)){
arr = [].concat(...arr)
}
return arr
}
或者其他方法
let meta = [1,2,[3,4,[5]],6,[7,[8,9,[10,11,[12,13,[14,15]]]]]]
function dimensionReduc(arr,result=[]){
return arr.toString().split(',').map(x=>parseInt(x,10)) //这种方法可以哦，但是需要思考一个问题，如何确定parseInt(x,10)这个10值？
或者
for(let value of arr){
Array.isArray(value)? dimensionReduc(value,result):result.push(value)
}
return result;
或者
let res = arr.reduce((a,b)=>a.concat(b),[])
if(!res.filter(x=>Array.isArray(x)).length){
return res
}
return dimensionReduc(res)
或者
return [].concat(...arr.map(item=>Array.isArray(item)?demensionReduc(item):item))
或者
return arr.join().split(',').map(Number)
return arr.toString().split(',').map(Number)
}
函数柯里化（乱入一个,嘻嘻~~）
在一个函数中，首先填充几个参数，然后再返回一个新的函数的技术，称为函数的柯里化。通常可用于在不侵入函数的前提下，为函数 预置通常参数，供多次重复调用。
const add = function add(x){
return function(y){
return x+y
}
}
const add1 = add(1)
add1(2) === 3;
add1(20) === 21