数组的方法
entries()
遍历数组的键名和键值
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.entries();
//[0, "Banana"]
//[1, "Orange"]
//[2, "Apple"]
//[3, "Mango"]
values()
遍历数组键值
let a = [1,1,1,1]
let b = arr.values() // [1,1,1,1]
keys()
遍历数组的键名
let a = [1,2,3,4]
let b = arr.keys() // [0,1,2,3]
includes()
判断数组中是否包含给定的值
includes(n,[,i])，从起始位置 i 开始查找，负值为绝对值。
indexOf() 不能判断NaN，返回为-1
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
[1, 2, 3].includes(3, 3) // false
[1, 2, 3].includes(3, -1) // true
[1, 2, NaN].includes(NaN) // true
fill(target, start, end)
方法用于将一个固定值替换数组的元素,会改变原数组
target -- 待填充的元素
start -- 开始填充的位置-索引
end -- 终止填充的位置-索引（不包括该位置)
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob"); //[Runoob,Runoob,Runoob,Runoob]
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4); //[Banana,Orange,Runoob,Runoob]
findIndex(callback)
找到第一个符合条件的数组成员的索引值
let arr = [1,0,1,2,3,4,7,2,3]
let arr1 = arr.findIndex((n, i, a) =>n > 2)
console.log(arr1) // 4
find(callback)
找到第一个符合条件的数组成员
let arr = [1,0,1,2,3,4,7,2,3]
let arr1 = arr.find((n, i, a) =>n > 2)
console.log(arr1) // 3
copyWithin()
在当前数组内部，将指定位置的数组复制到其他位置，会覆盖原数组项，返回当前数组参数:
target --必选 索引从该位置开始替换数组项
start --可选 索引从该位置开始读取数组项，默认为0。如果为负值，则从右往左读。
end --可选 索引到该位置停止读取的数组项，默认是Array.length,如果是负值，表示倒数
let arr = [1,2,3,4,5,6,7]
let arr1 = arr.copyWithin(1)
console.log(arr1) // [1, 1, 2, 3, 4, 5, 6]
let arr2 = arr.copyWithin(1,2)
console.log(arr2) // [1, 3, 4, 5, 6, 7, 7]
let arr3 = arr.copyWithin(1,2,4)
console.log(arr3) // [1, 3, 4, 4, 5, 6, 7]
of()
将一组值转换成数组，类似于声明数组 ---es6
let str = '11'
console.log(Array.of(str)) // ['11']
console.log(new Array(2)) //[empty × 2] 是个空数组
from()
将伪数组变成数组，就是只要有length的就可以转成数组。 ---es6
let str = '12345'
console.log(Array.from(str)) // ["1", "2", "3", "4", "5"]
let obj = {0:'a',1:'b',length:2}
console.log(Array.from(obj)) // ["a", "b"]
Arry.prototype.slice.call(伪数组)
indexOf()
查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1
let arr = [1,2,3,4,5,2]
let arr1 = arr.indexOf(2)
console.log(arr1) // 1
let arr2 = arr.indexOf(9)
console.log(arr2) // -1
lastIndexOf()
和arr.indexOf()的功能一样，不同的是从后往前查找
reduce(callback, initialValue)
迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值 参数： callback: previousValue 必选 --上一次调用回调返回的值，或者是提供的初始值（initialValue）
currentValue 必选 --数组中当前被处理的数组项
index 可选 --当前数组项在数组中的索引值
array 可选 --原数组
initialValue: 可选 --初始值
let arr = [0,1,2,3,4]
let arr1 = arr.reduce((preValue, curValue) =>
preValue + curValue
)
console.log(arr1) // 10
let arr2 = arr.reduce((preValue,curValue)=>preValue + curValue,5)
console.log(arr2) // 15
reduceRight(callback, initialValue)
与arr.reduce()功能一样，不同的是，reduceRight()从数组的末尾向前将数组中的数组项做累加。
some(callback)
依据判断条件，数组的元素是否有至少一个满足，若有则返回ture
let arr = [1,2,3,4,5]
let arr1 = arr.some( (n, i) => n < 3) //n-值 i-索引
console.log(arr1) // true
let arr2 = arr.some( (n, i) => n > 10) //n-值 i-索引
console.log(arr2) // false
every(callback)
依据判断条件，数组的元素是否全满足，若满足则返回ture
let arr = [1,2,3,4,5]
let arr1 = arr.every( (n, i) => n < 3) //n-值 i-索引
console.log(arr1) // false
let arr2 = arr.every( (n, i) => n < 10) //n-值 i-索引
console.log(arr2) // true
filter(callback)
过滤数组，返回一个满足要求的数组
let arr = [1,2,3,4,5]
let arr1 = arr.filter( (n,i) => n < 3) //n-值 i-索引
console.log(arr1) // [1, 2]
map(callback)
映射数组(遍历数组),有return 返回一个新数组
callback(value,index,array)的参数： value --当前索引的值 index --索引 array --原数组
let arr = [1,2,3,4,5]
let n=arr.map( (value,index,array)=>{
value= value * 2
console.log(`value:${value} index:${index} array:${array}`)
return value
})
console.log(n)
// value:2 index:0 array:1,2,3,4,5
// value:4 index:1 array:1,2,3,4,5
// value:6 index:2 array:1,2,3,4,5
// value:8 index:3 array:1,2,3,4,5
// value:10 index:4 array:1,2,3,4,5
[2, 4, 6, 8, 10]
forEach(callback) 遍历数组,无return
使用return可退出当次循环(循环会继续)
callback(value,index,array)的参数： value --当前索引的值 index --索引 array --原数组
let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
console.log(`value:${value} index:${index} array:${array}`)
})
// value:1 index:0 array:1,2,3,4,5
// value:2 index:1 array:1,2,3,4,5
// value:3 index:2 array:1,2,3,4,5
// value:4 index:3 array:1,2,3,4,5
// value:5 index:4 array:1,2,3,4,5
reverse()
将数组反转,返回值是反转后的数组
let arr = [1,2,3,4,5]
console.log(arr.reverse()) // [5,4,3,2,1]
console.log(arr) // [5,4,3,2,1]
sort()
将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的。
let arr = [2,10,6,1,4,22,3]
console.log(arr.sort()) // [1, 10, 2, 22, 3, 4, 6]
let arr1 = arr.sort((a, b) =>a - b)
console.log(arr1) // [1, 2, 3, 4, 6, 10, 22]
let arr2 = arr.sort((a, b) =>b-a)
console.log(arr2) // [22, 10, 6, 4, 3, 2, 1]
toString()
JavaScript 方法 toString() 把数组转换为数组值（逗号分隔）的字符串。
var dc = ["a", "b", "c", "d"];
dc.toString();
结果 a,b,c,d
[] => ""
join()
JavaScript 方法join()也可将所有数组元素结合为一个字符串。
var dc = ["a", "b","c", "d"];
dc.join(" * ");
结果 a * b * c * d
pop()
方法从数组中删除最后一个元素，pop() 方法返回“被弹出”的值
var dc = ["a", "b", "c", "d"];
dc.pop(); // 从 dc 删除最后一个元素（"d"）
var dc = ["a", "b", "c", "d"];
var x = dc.pop(); // x 的值是 "d"
push()
方法（在数组结尾处）向数组添加一个新的元素,push() 方法返回新数组的长度
var dc = ["a", "b", "c", "d"];
var x=dc.push("e"); // 向 dc 添加一个新元素
// x 的值是 5
dc[dc.length] = "e"; //
shift()
方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引,shift() 方法返回被“位移出”的数据
var dc = ["a", "b", "c", "d"];
dc.shift(); // 从 dc 删除第一个元素 "a"
// 返回 "a"
unshift()
方法（在开头）向数组添加新元素，并“反向位移”旧元素,unshift() 方法返回新数组的长度。
var dc = ["a", "b", "c", "d"];
dc.unshift("e"); // 向 dc 添加新元素 "e"
// 返回 5
splice()
方法可用于向数组添加新项，第一个参数（2）定义了应添加新元素的位置（拼接），第二个参数（0）定义应删除多少元素，其余参数（“e”，“f”）定义要添加的新元素
var dc = ["a", "b", "c", "d"];
dc.splice(2, 0, "e", "f");
// splice() 方法返回一个包含已删除项的数组
使用 splice() 来删除元素，
var dc = ["a", "b", "c", "d"];
dc.splice(0, 1); // 删除 dc 中的第一个元素
concat()
方法通过合并（连接）现有数组来创建一个新数组，concat() 方法不会更改现有数组。它总是返回一个新数组。concat() 方法可以使用任意数量的数组参数。
var a = ["1", "2"];
var b = ["3", "4", "5"];
var c=["6","7"]
var newlist = a.concat(b,c); // 连接 a 和 b,c
slice() 不改变原数组
方法用数组的某个片段切出新数组，slice() 方法创建新数组。它不会从源数组中删除任何元素。slice() 可接受两个参数，比如 (1, 3)。该方法会从开始参数选取元素，直到结束参数（不包括）为止。
var dc = ["a", "b", "c", "d", "e"];
var ndc = dc.slice(1); //["b", "c", "d", "e"]
var nl=dc.slice(1,3); //["b", "c"]
var nnl=dc.slice(-1); //["e"]
