Array()

  1. let arr1 = new Array() // 空数组
  2. let arr2 = new Array(3)   // 指定长度
  3. let arr3 = new Array("hello")  // 元素

Array.from()

将伪数组转化为数组

  1. Array.from("hello,world")
  2. // (11) ["h", "e", "l", "l", "o", ",", "w", "o", "r", "l", "d"]
  4. const arrayLikeObject = {
  5. 0: 1,
  6. 1: 2,
  7. 2: 3,
  8. 3: 4,
  9. length: 4   // 必须有length属性
  10. };
  12. Array.from(arrayLikeObject)
  13. (4) [1, 2, 3, 4]
  16. // 可以指定map函数和this
  17. const a1 = [1, 2, 3, 4];
  18. const a2 = Array.from(a1, x => x**2);
  19. const a3 = Array.from(a1, function(x) {return x**this.exponent}, {exponent: 2});
  20. alert(a2); // [1, 4, 9, 16]
  21. alert(a3); // [1, 4, 9, 16]

Array.of()

将参数转换为数组

  1. Array.of(1,2,3,4)
  2. // (4) [1, 2, 3, 4]
  3. Array.of({name:"hello"}, 1, 2, "yes")
  4. // (4) [{…}, 1, 2, "yes"]
  6. Array.of(...[1,2,3])
  7. (3) [1, 2, 3]

Array holes

ES6后和ES6前对待稀疏数组的方式不同，应避免使用稀疏数组

  1. const options = [1,,,,5];
  2. // map() will skip the holes entirely
  3. alert(options.map(() => 6)); // [6, undefined, undefined, undefined, 6]
  4. // join() treats holes as empty strings
  5. alert(options.join('-')); // "1----5"

判断数组

  1. let arr = [1, 2, 3]
  3. arr instanceof Array  // 只能用于单页面的global scope
  4. // true
  5. Array.isArray(arr)   // 可以用于任何环境
  6. // true

keys(), values(), entries()

  1. const a = ["foo", "bar", "baz", "qux"];
  2. for(let i of a.keys()) console.log(i) //  0 1 2 3
  3. for(let value of a.values()) console.log(value) // foo bar baz qux
  4. for(let [key, value] of a.entries()) console.log(key, value) //  0 "foo" 1 "bar" 2 "baz" 3 "qux"

fill(), copyWithin()

fill()给指定位置填充一个数值，原数组会被改变

  1. let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. a.fill("H")
  3. // (10) ["H", "H", "H", "H", "H", "H", "H", "H", "H", "H"]
  4. a.fill("H", 3, 4) // 指定开始和结束的index
  5. // (10) [0, 1, 2, "H", 4, 5, 6, 7, 8, 9]

copyWithin()复制指定位置到指定位置，原数组会被改变

  1. let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. a.copyWithin(6)  // 第一个参数是替换的起始位置index
  3. // (10) [0, 1, 2, 3, 4, 5, 0, 1, 2, 3]
  4. a.copyWithin(6, 0, 2)  // 第二三参数是复制的开始和结束位置
  5. // (10) [0, 1, 2, 3, 4, 5, 0, 1, 8, 9]

join()

将数组转换为字符串

  1. let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. a.join("+")  // 指定连接符号
  3. "0+1+2+3+4+5+0+1+2+3"

unshift()，push()

在数组头/尾插入任意多个元素，返回数组长度

  1. let a = []
  2. a.push(1,2)
  3. // 2
  4. a.unshift('a','b')
  5. // 4
  6. a
  7. // (4) ["a", "b", 1, 2]

shift(), pop()

从数组头/尾弹出元素，并返回这个元素

  1. a.shift()
  2. // "a"
  3. a.pop()
  4. // 2

reverse()

将数组反转

sort()

默认先将每个元素转换为字符串，再排序

  1. let a = [15, 10, 1, 2, 25, 3]
  2. a.sort()
  3. // (6) [1, 10, 15, 2, 25, 3]

sort()接受一个比较函数

  1. a.sort((a,b)=>a-b)
  2. // (6) [1, 2, 3, 10, 15, 25]

compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

concat()

返回原数组和arguments组成的新数组，如果什么参数都不传，则仅复制原数组

  1. let a = ['a']
  2. a.concat("hello", [1,2,3], {0:"a",1:"b"})
  3. // (6) ["a", "hello", 1, 2, 3, {…}]

可以给数组或对象设置Symbol.isConcatSpreadable属性，指定是否被拍平

  1. let colors = ["red", "green", "blue"];
  2. let newColors = ["black", "brown"];
  4. let moreNewColors = {
  5. [Symbol.isConcatSpreadable]: true,   // 默认是false
  6. length: 2,
  7. 0: "pink",
  8. 1: "cyan"
  9. };
  11. newColors[Symbol.isConcatSpreadable] = false;  // 默认是true
  12. // Force the array to not be flattened
  14. let colors2 = colors.concat("yellow", newColors);
  15. // Force the array-like object to be flattened
  16. let colors3 = colors.concat(moreNewColors);
  17. alert(colors); // ["red", "green","blue"]
  18. alert(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"]]
  19. alert(colors3); // ["red", "green", "blue", "pink, "cyan"]

slice()

切片，不改变原数组
参数：开始index和结束index(不包含),
如果参数是负数，则加上length

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

splice()

参数：起始位置，删除个数，插入元素
会改变数组，返回的是删除的元素

  1. let a = [1, 2, 3, 4, 5, 6, 7]
  2. a.splice(1,3,'a','b')
  3. // (3) [2, 3, 4]  返回被删元素
  4. a
  5. // (6) [1, "a", "b", 5, 6, 7]

indexOf()，lastIndexOf(), includes()

都接受一个要寻找的元素，和要开始查找的位置，找不到返回-1或false

  1. let a = [1, 2, 3, 3, 2, 1]
  3. a.indexOf(3)
  4. // 2
  5. a.lastIndexOf(3)
  6. // 3
  7. a.includes(3)
  8. // true
  9. a.includes(3, 5)
  10. // false

必须精确相等

  1. let person = { name: "Nicholas" };
  2. let people = [{ name: "Nicholas" }];
  3. let morePeople = [person];
  5. people.indexOf(person); // -1
  6. morePeople.indexOf(person); // 0
  7. people.includes(person); // false
  8. morePeople.includes(person); // true

find(), findIndex()

都接受一个函数 predicate(element, index, array) , 将函数的返回值作为找寻条件

  1. let a = [1, 2, 3, 3, 2, 1 ]
  3. a.find(item => item < 3)  // 找到第一个符合条件的元素就不再往后找
  4. // 1
  5. a.findIndex(item => item < 3)
  6. // 0
  7. a.find(item => item > 4)
  8. // undefined
  9. a.findIndex(item => item > 4)
  10. // -1

every(), some()

**every()** 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。
**some()** 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回一个布尔值。

  1. let a = [1, 2, 3, 4, 5]
  3. a.every((item, index, array) => item > 3)
  4. // false
  5. a.some((item, index, array) => item > 3)
  6. // true

filter(), map()

**filter()** 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
**map()** 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

  1. let a = [1,3, 5, 2, 4, 2, 5, 6]
  3. a.filter((item, index, array) => item > 3)
  4. // (4) [5, 4, 5, 6]
  5. a.map((item, index, array)=> item ** 2)
  6. // (8) [1, 9, 25, 4, 16, 4, 25, 36]

forEach()

**forEach()** 方法对数组的每个元素执行一次给定的函数。没有返回值，相当于for循环

  1. a.forEach((item,index, array)=> console.log(item**2)) // 1 9 25 4 16 4 25 36

reduce(), reduceRight()

**reduce()** 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值，reduce()接受两个参数，一个function，一个初始值；function接受4个参数，the accumulator value, the current value, the item’s index, and the array object，
如果没给初始值，遍历从第二个元素开始，accumulator是第一个元素，current是第二元素，对一个item执行完函数之后都更新accumulator 的值；
如果给了初始值，遍历从第一个元素开始；
reduceRight()与reduce()的方向相反，从数组末尾开始

  1. let a = [1,2,3,4,5,6]
  2. a.reduce((accu,cur,index, array)=> accu + cur)
  3. // 21
  4. a.reduce((accu,cur,index, array)=> accu + cur, 100)
  5. // 121

reduce实现filter

  1. let arr = [1, 2, 3, 4, 5]
  2. arr.reduce((result, item)=>{
  3.   if(item%2 === 1){
  4.     return result
  5.   }else{
  6.     return result.concat(item)
  7.   }
  8. }, [])
  10. arr.reduce((result, item)=> result.concat(item%2 === 1 ? [] : item), [])