这里一共有27个数组的方法
//Array.prototype.of() 弥补new Array 的不足,代替new Array使用
var arr = new Array(3);//[empty * 3]
var arr = Array.of(3);//[3]
var arr = Array.of();//[]
//Array.prototype.copyWithin(target[,start[,end]]) 复制到target,复制从start开始，到end结束的元素(不包含end这个位置的元素),改变后的数组。
var arr = [1,2,3,4,5,6,7];
var a = arr.copyWithin(3,0,2);//[1，2，3，1，2，6，7]
//把索引为从0到2的元素复制到索引为3的元素上，数组长度不变，复制的元素会顶掉原有的元素，这是一个会对数组造成改变的方法
var a = arr.copyWithin(3);//[1, 2, 3, 1, 2, 3, 1]
//target必填，start和end不写的话默认从数组第一个元素开始到arr.length结束，重复复制
var a = arr.copyWithin(3,1);//[1, 2, 3, 2, 3, 1, 2]
//Array.prototype.flat(),将数组中所有元素及其子元素整理到一个新数组中，参数决定整理子元素的“深度”,默认是1，仅一级子元素
var arr = [1,2,[3,4,[5,[6]]]];//1, 2, Array(3)
var flat = arr.flat(3);//[1，2，3，4，5，6]
//flat会移除数组中的空项:
var arr2 = [1,2, ,3,[4, ,5]];//1, 2, empty, 3, Array(3)
var flat2 = arr2.flat(2);//[1, 2, 3, 4, 5]
//Array.prototype.concat(arr[,arr2...[,valueN]] 将两个数组拼接成一个新数组，不会改变原数组,第一个参数是要拼接的数组，可以拼接多个，但是只是浅拷贝,对于数组中的引用类型只保存其对应的引用，无法实现深拷贝
var arr = [1,2,3];
var arr1 = [4,5,6];
var arr2 = [7,8,9];
var arr3 = arr.concat(arr1);//[1,2,3,4,5,6]
var arr4 = arr.concat(arr1,arr2);//[1,2,3,4,5,6,7,8,9]
arr = [0];
var arr5 = arr.concat(arr1,arr2);//[0,4,5,6,7,8,9]
//引用类型的拼接
var arr = [{"type":'Object'}];
var arr1 = [{"type":'Array'}];
var arr3 = arr.concat(arr1);//[{type:'Object'},{type:'Array'}]
arr1[0].type = 'String';//[{type:'Object'},{type:'String'}]
//concat对于引用类型只是保存了它们的引用，相当于它们的副本，当引用的数据发生变化后，concat返回的数据也会跟着变化（浅拷贝）
//Array.prototype.every(callback[,thisArg])对数组里的每一项进行检测，都通过返回true，否则返回false
var arr = [1,2,3,4];
arr.every(element => element > 0);//true =>数组中每一项都大于0
//第一个参数callback有三个参数，第一个element表示当前进行检测的值，第二项第三项可选分别为index当前值的索引，array当前调用every的数组
//第二个参数可选指定callback执行的环境（this指向），默认全局
//Array.prototype.fill(value[,start[,end]]) 以一个固定的值填充数组中对应开始和结束参数的索引的值
var arr = [1,2,3,4,5,6];
var arrFill = arr.fill('F',1,3);//[1,F,F,4,5,6]
//Array.prototype.filter(callback[,thisArg]);通过对调用数组的callback函数过滤通过的保留返回一个新数组，参数及含义与every一致
var arr = [1,2,3,4,5,6,7,8,9];
var FilterArr = arr.filter((element,index,array) => {
return element % 2 == 0;
})//[2,4,6,8]
// find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。参数和every，filter一样用法含义
var arr = [1,2,3,4,5,6,7];
var FindOdd = arr.find(element => element % 1 == 0);//1 odd奇数，even偶数
//findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。参数及用法和find，evety，filter一致，只不过返回的是复合要求的值的索引
var arr = [1,2,3,4,5,6,7];
var FindOdd = arr.findIndex(element => element % 1 == 0);//0
//forEach 对数组每一项进行callback操作 永远返回undefined forEach不会直接改变调用它的对象，但是那个对象可能会被 callback 函数改变。参数和find，findIndex，every，filter一致
var arr = [1,2,3,4,5];
var ForEach = arr.forEach((element,index,array) => {
arr[index] = element * 2;
})//[2，4，6，8，10]
//arr.includes(valueToFind[, fromIndex]) includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
var arr = [1,2,3,4,5,6];
var includes = arr.includes(2);//true
var includes = arr.includes(20);//false
//第二个参数：从第几个开始找：MDN：fromIndex 可选从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。
var includes = arr.includes(2,2);//false
//indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
var arr = [1,2,3,4,5];
var IndexOf = arr.indexOf(2);//1
/*
第二个参数 fromIndex 可选
开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.*/
//lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。也有第二个参数从哪开始，跟indexOf一样
//join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。
var arr = ['Hello','Hongbin'];
var Join = arr.join();//Hello,Hongbin
var Join = arr.join('');//HelloHongbin
var Join = arr.join('-');//Hello-Hongbin
//split 分割，以特定字符串将字符转分割成数组，默认分隔符为,
var str = 'Hello,Hongbin';
var arr = str.split();//["Hello","Hongbin"]
var arr = str.split('');//["H", "e", "l", "l", "o", ",", "H", "o", "n", "g", "b", "i", "n"]
//slice 切片 截取 两个参数是从哪开始切和切到哪为止
var arr = [1,2,3,4,5,6,7];
var str = 'HelloWorld';
var Slice = arr.slice(1,3);//[2,3]
var Slice = str.slice(1,3);//el
//splice 在数组中插入、删除、替换数组元素 三个参数从哪开始，删除的个数，要添加的数据,返回的是被删除的数据
var arr = [1,2,3,4];
var str = 'HelloWorld';
arr.splice(0,0,'splice');//["splice",1,2,3,4] =>从索引为0开始，删除0个，添加'splice'
arr.splice(arr.length,0,'huohua');["splice", 1, 2, 3, 4, "huohua"]
arr.splice(4,2);//["splice", 1, 2, 3]
//keys() 方法返回一个包含数组中每个索引键的Array Iterator对象。键值对中的键名，下面values对应值
var arr = ["A","B","C"];
var Keys = arr.keys();//[]
// Keys.next()//{value: 0, done: false} => 当前键值：0，是否执行完毕：flase
// Keys.next()//{value: 1, done: false}
// Keys.next()//{value: 2, done: false}
// Keys.next()//{value: undefined, done: true}
for (let s of Keys) {
console.log(s);//0,1,2
}
//values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
var Vals = arr.values();//[]
for (let s of Vals) {
console.log(s);//A,B,C
}
//map给原数组中的每个元素都按顺序调用一次 callback 函数。callback 每次执行后的返回值（包括 undefined）组合起来形成一个新数组。 callback 函数只会在有值的索引上被调用；那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。
//参数和every，filter，find，findIndex，forEach一样
var arr = [1,2,3,4]
var Map = arr.map(element => element * 2);//[2,4,6,8]
//arr.pop()删除数组的后一位，根据length算的，如果不包含length属性，或length属性不能转为一个数值的会将length置为0，并返回undefined'返回被删掉的项
var arr = [1,2,3,4];
arr.pop();//[4]
var arr = [];
arr.pop()//undefined
//push() 向数组的末尾添加新元素 新的 length 属性值将被返回。
//reduce 累计-一堆进去一个出来，求和，平均值。。。有多种巧妙的用法
//第一个callback函数4个参数，第一个是上次执行回调函数返回的累计值，第二个参数->第一次执行方法的初始值
//如果不指定初始值,也就是prev的值则算作数组中的第一项
var arr = [1,2,3,4,5,6];
var add = arr.reduce((temp,curr,index,arr) => {
return temp + curr;//21
})
//reduce实现flat功能-指定模板的初始值为[]
var arr = [1,2,3,[4,5,6]]
let red = arr.reduce((prev,curr,index) => {
return prev.concat(curr);
},[])
//[1,2,3,4,5,6]
//reverse() 将数组中的值颠倒,返回新数组的引用
var arr = [1,2,3,4];
var Reverse = arr.reverse();//[4,3,2,1]
//shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
var arr = [1,2,3,4];
arr.shift();//1
//作用于类数组上 - 通过call和apple方法可以在类数组身上使用数组的方法
var arr = {0:'Z',1:'O',2:'T',length:3}
Array.prototype.shift.call(arr);//{0: "O", 1: "T", length: 2}
Array.prototype.shift.call(arr);//{0: "O", length: 1}
//slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
var arr = [1,2,3,4,5,6];
var slice = arr.slice(1,4);//[2,3,4]
//some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。
var arr = [1,2,3,4,5,6,7,8,9];
var S = arr.some((element,index,arr) => {
return element % 2 == 0 //true
})
//可以用来判断数组中是否有符合条件的，找到他并对其进行操作,找到就会返回true，循环就会终止
var S = arr.some((element,index,arr) => {
if(element % 3 == 0){
console.log(arr[index])//3
return index+1 == arr.length ? true : false
}else{
return false
}
})
//sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的
//由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。
var arr = [2,1,3,5,7,32,62,7];
var Sort = arr.sort();//[1, 2, 3, 32, 5, 62, 7, 7]
//对sort进项传参才能按照我们想要的进行排列
//如果不指定参数，元素会按照转换为的字符串的诸个字符的Unicode位点进行排序
//compareFunction 可选
//用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
//firstEl
//第一个用于比较的元素。
//secondEl
//第二个用于比较的元素。
/*
如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；
如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。*/
var Sort = arr.sort((x,y) => {
return x-y//[1,2,3,5,7,7,32,62]
})
var Sort = arr.sort((x,y) => {
return y-x//[62, 32, 7, 7, 5, 3, 2, 1]
})
//toString() 转换成字符串 返回一个字符串，表示指定的数组及其元素。
var arr = [1,2,3];
//console.log(arr.toString());//1,2,3
//unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。
//shift()是删除元素删除，unshift与其相反
//set
var arr = new Set().add('a').add('b').add('c');//{"a","b","c"}
