数组

扩展操作符

ES6中可使用扩展操作符在一个数组字面量中包含另一个数组

let a = [1, 2, 3]
let b = [0, ...a, 4]    // [0, 1, 2, 3, 4]
// 扩展操作符可用于任何可迭代对象
let digits = [..."adsadassfasfasfsff"] // ["a", "b", "s", ..., "f", "f"]
// 若想去重，可借助集合
let letters = [ ...new Set(digits)]      

稀疏数组

稀疏数组就是数组中有空位，其length值大于实际元素的个数

let c = ["0"]
c[10] = "10"
c[3] = undefined
console.log(c) // [ '0', <2 empty items>, undefined, <6 empty items>, '9' ]      

迭代稀疏数组，会发现空位为undefined，但并非表示空位的值是undefined

for(let i of c){
    console.log(i)  // 空位为undefined
}
console.log(c.length)   // 11
console.log(1 in c) // c[1]为真正的空值，没有元素，返回为false
console.log(3 in c) // c[3]为undefined元素，并非真的没有元素，返回为true      

forEach可以感知到稀疏数组，并跳过空位

c.forEach(element=>{
    console.log(element)  // foreach能感知到稀疏数组，并跳过空位
})      

filter过滤

filter传入一个回调函数，去除返回值为false的元素，返回一个新的数组

let arr = [5, 4, 3, 2, 1]
let arrFilter = arr.filter(x => x<3)  // 过滤掉大于等于三的元素，返回新数据      

filter会自动过滤掉稀疏数组中的空位，返回稠密数组

arr.filter(() => true)  // 所以可以使用filter过滤空值      

find与findIndex

let f = arr.find( x => x===3)   // 返回第一个匹配项，找不到返回undefined
let fIdx = arr.findIndex( x => x > 3)   // 返回第一个匹配项的索引，找不到返回-1      

every与some

every只有所有项都匹配时，才会返回true；some只要有一个匹配项，就返回true

arr.every( x => x <10)
arr.some( x => x === 3)      

reduce 与 reduceRight

归并，根据条件返回一个最终结果，reduceRight()是从右向左归并

arr.reduce((x, y) => x + y) // 条件是求和，那么就逐一相加，每次的结果将取代x，并进行下一次归并
arr.reduce((x, y) => (x > y) ? x : y, 100) // 条件为找出最大值，第二个参数为初始的x值，结果为100      

map

map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

let strArr = ["hello world", "the definitive guide"]
strArr.map(x => x.split(" "))  // [ [ 'hello', 'world' ], [ 'the', 'definitive', 'guide' ] ]      

flat()与flatMap()打平数组

let matrix = [1, [2, [3, [4]]]]
matrix.flat()  // [ 1, 2, [ 3, [ 4 ] ] ]
matrix.flat(1) // [ 1, 2, [ 3, [ 4 ] ] ]
matrix.flat(2) // [ 1, 2, 3, [ 4 ] ]
matrix.flat(3) // [ 1, 2, 3, 4 ]
matrix.flat(4) // [ 1, 2, 3, 4 ]      

flatMap() 等同于(但效率远高于) map().flat()，可以把flatMap理解为通用版的map

let strArr = ["hello world", "the definitive guide"]
strArr.flatMap(x => x.split(" ")) // [ 'hello', 'world', 'the', 'definitive', 'guide' ]      

concat()

添加数组,原始数组不变, 可以打平数组，但不会递归的打平嵌套的数组

let addArr = [1, 2, 3]
a.concat(4, 5)  // [1, 2, 3, 4, 5]
a.concat([4, 5], [6, 7]) // [1, 2, 3, 4, 5, 6, 7]
a.concat(4, [5, [6, 7]]) // [1, 2, 3, 4, 5, [6, 7]]      

slice()切片

let arr = [5, 4, 3, 2, 1]
arr.slice(0, 2) // [5, 4] [0, 2) 前闭后开
arr.slice(3)    // [2, 1] 从索引3开始到结尾
arr.slice(1, -1) // [4, 3, 2] 支持负索引      

fill()填充

可只填充切片部分

let farr = new Array(5)
farr.fill(0)    // [0, 0, 0, 0, 0]
farr.fill(9, 1) // [0, 9, 9, 9, 9]
farr.fill(8, 2, -1) // [0, 9, 8, 8, 9]      

copyWithin()

copyWithin(index, startIndex, endIndex)，把指定切片复制到指定索引处，会修改原数组, 支持负索引

let arr = [5, 4, 3, 2, 1]
arr.copyWithin(1)   // [5, 5, 4, 3, 2]
arr.copyWithin(2, 3, 5)   // [5, 5, 3, 2, 2]
arr.copyWithin(0, -2)   // [2, 2, 4, 2, 2]      

其他

indexOf lastIndexOf 查找匹配项中第一个和最后一个的索引，没有返回-1

includes() ES6新方法测试数组中是否包含某个值，返回true或false

sort( a, b =>{ return a - b })   若 < 0，则a在前，若 > 0，则b在前

arr.join("+")  可以理解为split的反向操作，若不传参数，则默认为使用","相连

Array.isArray([]) 用于确定一个未知值是否是数组，返回true或false

arr.length = 3  修改数组长度会截断数组