一、增删改查

1.增删

1.栈方法（后进后出）
push()   后增   let newArrLength=arr.push(element1, ..., elementN) ;//返回新数组长度
Array.prototype.push.apply(array1,array2);//简化要先转换成单个形参，这个时候就可以直接传递数组
//以下类似，利用Array.prototype.XX.apply可以把形参为单个的，可以转化为传数组

pop()    后删   let deleteEle=arr.pop() ;//删除最后一项，并返回删除项

2.队列方法（先进后出）
unshift()   前增     let newArrLength=arr.unshift(element1, ..., elementN);//返回新数组长度
Array.prototype.unshift.apply(array1,array2);//简化要先转换成单个形参，这个时候就可以直接传递数组

shift()     前删     let deleteEle=arr.shift();//删除第一项，并返回删除项

3.指定位置增删 
splice()   let deleteEle=arr.splice(start[,deleteCount[,item1[,item2[,...]]]]);//返回删除项
//从start位置，删除deleteCount个，然后在start处插入item1...itemN

总结：会修改自身。删除则返回删除项，增加则返回修改后的length 。
     push/pop、unshift/shift是通用方法，因为依赖length来操作，对象必须要有length属性

2.改

1.自身复制黏贴：
copyWithin()   Withi  let newArr=arr.copyn(target[,start[,end]]);
//复制[start,end)左闭右开区间内容到target为开始，覆盖原来的值。返回新数组
//如果没有end，则复制为[start到尾部] 。start和end都可以为负数
//复制黏贴是浅拷贝
                                                                
2.fill对象填充：
fill()     let newArr=arr.fill(value[, start[, end]]); 
//用value填充索引为[start,end)左闭右开的区间，value可以是对象。返回新数组

总结：会修改自身，但不改变数组length。都是返回新数组，都是浅拷贝 

3.查

1.项查找  
includes    let bool=arr.includes(searchElement[,fromIndex]);//返回布尔值

2.查找指定元素的索引：
indexof     let index=arr.indexOf(searchElement[,fromIndex]);//返回索引值，如果不存在，则返回-1
lastIndex    let index=arr.lastIndexOf(searchElement[,fromIndex = arr.length - 1]);//返回索引，逆序查找

3.查找满足测试函数  ：
findIndex   let index=arr.findIndex(callback(element[,index[,array]])[,thisArg]);//返回索引
find        let ArrEle=arr.find(callback(element[,index[,array]])[,thisArg]);//返回项

总结：都是查找到1个就结束 
includes查找项是专业的，可以找到NaN和稀疏数组的undefined，indexof不可以 
但indexof/lastIndex可以获得该项的索引
复杂查找用find/findIndex

二、迭代

1.every

测试数组中是否所有元素都通过了由提供的函数实现的测试都通过,返回true;如果有一个不通过,结束执行,返回false

let bool=arr.every(callback(element[,index [,array]])[,objThis]);
//objThis作为参数1函数的this使用，相当于引入外部对象,返回布尔值

2.some

测试数组中是否至少有一个元素通过了由提供的函数实现的测试

let bool=arr.some(callback(element[,index [,array]])[,thisArg]);
//返回布尔值

3.filter

通过所提供函数实现的测试的所有元素，返回子数组

let newArr=arr.filter(callback(element[,index[,array]])[,thisArg]);
//如果没有符合条件的元素则返回空数组

4.map

旧数组每个元素执行提供的函数得到新的元素，返回新的数组，自身不改变

let newArr=arr.map(callback(element[,index[,array]])[,thisArg]);

5.forEach

旧数组每个元素执行提供的函数得到新的元素，更新自身元素，自身改变，无返回值

arr.forEach(callback(element[,index[,array]])[,thisArg]);

总结：
every/some用于测试
filter用于返回旧数组满足条件的新数组(旧数组子项)
map用于返回旧数组映射后的新数组 //filter、map都不会修改原数组
forEach用于修改自身数组

三、排序

1.reverse 反转排序

arr.reverse();//修改自身，没有返回值

2.sort 算法排序

arr.sort([sortby(L,R)]);
//没有返回值。如果没有参数：arr.sort();默认情况为升序排序,按照字符编码的顺序进行排序 
sortby(L,R);//是数组元素两两比较   排序规则为：return true或正数，则L，R进行调换排序 

四、归并

数组元素两两比较，返回的值作为新的比较值，返回最终结果

1.reduce

let arrEle=arr.reduce(callback(accumulator,currentValue[,currentIndex][,array])[,initialValue]);
//initialValue为初始值

2.reduceRight

和reduce区别在于：reduce是从左到右，reduceRight是从右到左

五、生成新数组

√ 都可以用于数组拷贝(通常用concat或slice(0))

1.concat

用于源数组连接其它元素/数组，返回新数组
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本
可以用于数组拷贝

let newArr=arr.concat(arrayX,arrayX,......,arrayX);//arrayX可以是具体的值，也可以是数组(参数数组会拉平)
eg:
var arr=[1,2,3,4,5,6,7];
var addArr=[8,[9,10]];
var newArrCopy = arr.concat(addArr,11);
console.log(newArrCopy);// [1, 2, 3, 4, 5, 6, 7, 8, Array(2), 11]

//返回新数组，浅拷贝测试
var a={
    name:"张三"
}
var arr=[1,2,3,4,5,a,7];
var newArrCopy = arr.concat();
arr.pop();
arr[5].name="李四";
console.log(newArrCopy)//[1, 2, 3, 4, 5, {…}, 7]
//即arr和newArrCopy本身是浅拷贝，原数组pop不会影响新数组
//但原数组的项引用修改，会影响新数组(浅拷贝)

2.slice

从已有的数组中返回选定的元素。返回子数组
该方法并不会修改数组，而是返回一个子数组
可以用于数组拷贝

let newArr=arr.slice(start,end);//[start,end)左闭右开区间
//返回新数组，浅拷贝测试
var a={
    name:"张三"
}
var arr=[1,2,3,4,5,a,7];
var newArrCopy = arr.slice(0);//start是必选的
arr.pop();
arr[5].name="李四";
console.log(newArrCopy)//[1, 2, 3, 4, 5, {…}, 7]
//即arr和newArrCopy本身是浅拷贝，原数组pop不会影响新数组
//但原数组的项引用修改，会影响新数组(浅拷贝)

3.filter

通过所提供函数实现的测试的所有元素，返回子数组

let newArr=arr.filter(callback(element[,index[,array]])[,thisArg]);//如果没有符合条件的元素则返回空数组

4.map

旧数组每个元素执行提供的函数得到新的元素，返回新的数组

let newArr=arr.map(callback(element[,index[,array]])[,thisArg]);

总结：生成新数组有这几种方法：
1.借助已有数组 concat
2.自身数组子区域 slice
3.自身数组过滤 filter
4.自身数组加工 map

六、转成字符串

1.join

将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符

let str=arr.join(separator);
//separator为分隔符，默认为“，”
//如果元素是对象，则会调用对象的toString()方法 

2.利用数组隐式转换为String

转String
显示语法：String(s);    //转换函数
隐式方式："+"运算符
1.Null        // "null" 
2.Undefined   // "undefined" 
3.Boolean     // false为"false"，true为"true" 
4.Number      // "对应数字" //0,+0,-0为0
5.String      //
6.Object      // Object为："[object Object]"； function为："function(){}"；数组为："数组内容1，数组内容2" 

所以：数组转字符串可以写成
1.String(Arr)
2.Arr+""

七、伪数组

概念：有些对象是自动生成的，键是数字，可以类似数组的方式读写。即obj[i]
例子：arguments,DOM对象
特点：具有length属性，不具有Array数组的方法 

转换为数组
1.Array.prototype.slice.call();//或[].slice.call()
//

2.Array.from()
//Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例

3. 利用...

4.