Array 对象是用于构造数组的全局对象，数组是类似列表的高阶对象。

Array.from()

从一个类似数组或可迭代对象中创建一个新的数组实例。

  1. // 语法
  2. Array.from(arrayLike[, mapFn[, thisArg]])
  4. // arraylike  想要转换成数组的伪数组对象和可迭代对象
  5. // mapFn  如果指定了该参数，新数组中的每个元素会指定返回调函数
  6. // thisArg  执行回调函数 mapFn 时 this 对象
  8. // 返回值  一个新的数组实例
  1. Array.from('foo') // ['f', 'o', 'o']
  3. let s = new Set(['foo', window])
  4. Array.from(s)  // ['foo', window]
  6. let m = new Map([[1, 2], [2, 4], [4, 8]])
  7. Array.from(m)  // [[1, 2], [2, 4], [4, 8]]
  9. function f() {
  10.     return Array.from(arguments)
  11. }
  12. f(1, 2, 3)  // [1, 2, 3]
  14. Array.from([1, 2, 3], x => x + x)  // [2, 4, 6]
  16. Array.from({length: 5}, (v, i) => i)  // [0, 1, 2, 3, 4]
  18. // 数组去重合并
  19. function combine() {
  20.     let arr = [].concat.apply([], arguments)
  21.   return Array.from(new Set(arr))
  22. }
  23. let m = [1, 2, 2]
  24. let n = [2, 3, 3]
  25. combine(m, n)  //[1, 2, 3]

Array.isArray()

用于确定传递的值是否是一个Array

  1. // 语法
  2. Array.isArray(obj)
  4. Array.isArray([1, 2, 3])  // true
  5. Array.isArray({foo: 123}) // false
  6. Array.isArray("foobar")  // false
  7. Array.isArray(undefined) // false

Array.of()

用于创建一个具有可变数量参数的新数组实例，而不考虑参数的数量和类型。

  1. Array.of(7)  // [7]
  2. Array.of(1, 2, 3)  // [1, 2, 3]
  3. Array.of(undefined)  // [undefined]
  5. Array(7)  // [ , , , , , , , ]
  6. Array(1, 2, 3)  // [1, 2, 3]
  7. Array(undefined)  // [undefined]

Array.prototype.concat()

用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

  1. var new_array = old_array.concat(vaue1[, value2[, ...[, valueN]]])
  3. // 返回一个新的 Array 实例
  1. var alpha = ['a', 'b', 'c']
  2. var numeric = [1, 2, 3]
  3. alpha.concat(numeric)  // ['a', 'b', 'c', 1, 2, 3]
  5. let num1 = [1, 2],
  6.         num2 = [3, 4],
  7.     num3 = [5, 6];
  8. var nums = num1.concat(num2, num3);  // nums [1, 2, 3, 4, 5, 6]
  10. let alhpa = ['a', 'b', 'c'];
  11. let alphaNum = alpha.concat(1, [2, 3]);  // alphaNum  ['a', 'b', 'c', 1, 2, 3]
  13. // 合并嵌套数组
  14. let num1 = [[1]]
  15. let num2 = [2, [3]]
  16. let nums = num1.concat(num2)  // nums [[1], 2, [3]]
  17. num1[0].push(4) // nums [[1, 4], 2, [3]]

Array.prototype.copyWithin()

浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。

  1. arr.copyWitnin(target[, start[, end]])
  2. // 返回改变后的数组
  4. let numbers = [1, 2, 3, 4, 5]
  5. numbers.copyWithin(-2)  // [1, 2, 3, 1, 2]
  7. numberss.copyWithin(0, 3, 4)  // [4, 2, 3, 4, 5]

Array.prototype.entries()

返回一个新的 Array iterator 对象，该对象包含数组中每个索引的键/值对。

  1. var arr = ['a', 'b', 'c']
  2. var iterator = arr.entries()
  4. // iterator.next 方法运行
  5. var a = []
  6. for (var i=0; i<arr.length+1; i++) {
  7.     var tem = iterator.next()
  8.   if (tem.done !== true) {
  9.       a[i]=tem.value
  10.   }
  11. }
  12. // a [[0, 'a'], [1, 'b'], [2, 'c']]
  14. // 二维数组按行排序
  15. function sortArr(arr) {
  16.     var goNext = true
  17.   var entries = arr.entries()
  18.   while(goNext) {
  19.       var result = entries.next()
  20.     if (result.done !== true) {
  21.         result.value[1].sort((a, b) => a - b)
  22.       goNext = true
  23.     } else {
  24.         goNext = false
  25.     }
  26.   }
  27.   return arr;
  28. }
  30. var arr = [[1,34],[456,2,3,44,234],[4567,1,4,5,6],[34,78,23,1]];
  31. sortArr(arr);  // [[1, 34], [2, 3, 44, 234, 456], [1, 4, 5, 6, 4567]]
  33. // 使用 for...of 循环
  34. for (let e of iterator) {
  35.     console.log(e)
  36. }
  37. // [0, "a"] 
  38. // [1, "b"] 
  39. // [2, "c"]

Array.prototye.every()

测试数组的所有元素是否都通过了指定函数的测试。
所有元素都符合条件才返回true;空数组也返回 true.

  1. function isBigEnough(element, index, array) {
  2.     return (element >= 10)
  3. }
  5. var passed = [12, 5, 8, 130, 44].every(isBigEnough) // false
  6. var passed2 = [12, 54, 18, 130, 44].every(isBigEnough)  // true

Array.prototype.fill()

用一个固定值填充一个数组从其实索引到终止索引内的全部元素。不包括终止索引。

  1. arr.fill(value[, start[, end]])
  3. [1, 2, 3].fill(4) // [4, 4, 4]
  4. [1, 2, 3].fill(4, 1) // [1, 4, 4]
  5. [1, 2, 3].fill(4, 1, 2) // [1, 4, 3]
  6. [1, 2, 3].fill(4, 1, 1) // [1, 2, 3]
  7. [1, 2, 3].fill(4, 3, 3) // [1, 2, 3]
  8. [1, 2, 3].fill(4, -3, -2) // [4, 2, 3]
  9. [1, 2, 3].fill(4, NaN, NaN) // [1, 2, 3]
  10. [1, 2, 3].fill(4, 3, 5) // [1, 2, 3]
  11. Array(3).fill(4)  // [4, 4, 4]
  12. [].fill.call({ length: 3 }, 4)  // {0: 4, 1: 4, 2: 4}

Array.prototype.filter()

创建一个新数组，其包含通过所提供函数实现的测试的所有元素。

  1. // > 10
  2. function isBigEnough(element) {
  3.     return element > 10
  4. }
  5. var filtered = [12, 5, 8, 130].filter(isBigEnough) // [12, 130]
  7. // 过滤Json中无效条目
  8. var arr = [
  9.   { id: 15 },
  10.   { id: -1 },
  11.   { id: 0 },
  12.   { id: 3 },
  13.   { id: 12.2 },
  14.   { },
  15.   { id: null },
  16.   { id: NaN },
  17.   { id: 'undefined' }
  18. ];
  20. function isNumber(obj) {
  21.     return obj !== undefined && typeof(obj) === 'number' && !isNaN(obj)
  22. }
  23. function filterById(item) {
  24.     if (isNumber(item.id) && item.id !== 0) {
  25.       return true
  26.   }
  27. }
  28. var arrById = arr.filter(filterById)  // [{id: 15}, {id: -1}, {id: 3}, {id: 12.2}]
  30. // es6
  31. const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
  33. const filterItems = (query) => {
  34.     return fruits.filter(el => el.toLowerCase().indexOf(query.toLowerCase()) > -1)
  35. }
  36. filterItems('ap') // ['apple', 'grapes']
  37. filterItems('an') // ['banana', 'mango', 'orange']

Array.prototype.find()

返回数组中满足条件的第一个元素的值，没有就返回 undefined.

// 用对象的属性查找数组里的对象

  1. var inventory = [
  2.     {name: 'apples', quantity: 2},
  3.   {name: 'banans', quantity: 0},
  4.   {name: 'cherries', quantity: 5}
  5. ]
  6. inventory.find(v => v.name === 'cherries')  // {name: 'cherries', quantity: 5}

当在回调函数中删除数组中的一个值时，当访问这个位置时，返回 undefined.

  1. var a = [0, 1,,,4, 5]
  2. a.find(function(value, index) {
  3.     if (index === 0) {
  4.       delete a[4]; // 将a[4]设置为undefined
  5.     a.pop();  // 在find()仍能访问到最后一项
  6.   }
  7.   console.log(`index: ${index}; value: ${value}`)
  8. })

Array.prototype.findIndex()

返回数组中满足条件的第一个元素的索引，否则返回 -1

  1. arr.findIndex(callback[, thisArg])
  2. // callbak 自动传入三个参数 
  3. element 当前元素
  4. index  当前元素索引
  5. array  调用findIndex 的数组

查找数组中首个质数元素的索引

  1. function isPrime(element, index, array) {
  2.     var start = 2;
  3.   while(start <= Math.sqrt(element)) {
  4.       if (element % start++ < 1) {
  5.         return false
  6.     }
  7.   }
  8.   return element > 1
  9. }
  10. console.log([4, 6, 8, 12].findIndex(isPrmise))  // -1
  11. console.log([4, 6, 7, 12].findIndex(isPrmise))  // 2

Array.prototoype.flat()

这是个实验中的功能，需要考虑浏览器的兼容性
flat() 用于递归到指定深度将所有子数组连接，并返回一个新数组.

  1. var newArray = arr.flat(depth)  // depth 指定嵌套数组中的结构深度， 默认为1

扁平化嵌套数组

  1. var arr1 = [1, 2, [3, 4]]
  2. arr1.flat()  // [1, 2, 3, 4]
  4. var arr2 = [1, 2, [3, 4, [5, 6]]]
  5. arr2.flat()  // [1, 2, 3, 4, [5, 6]]
  7. var arr2 = [1, 2, [3, 4, [5, 6]]]
  8. arr2.flat(2)  // [1, 2, 3, 4, 5, 6]
  10. // Infinity 展开所有嵌套数组
  11. var arr3 = [1, 2, [3, 4, [5, 6]]]
  12. arr3.flat(Infinity)  // [1, 2, 3, 4, 5, 6]

扁平化与空项（flat() 会移除数组中的空项）

  1. var arr4 = [1, 2, , 4, 5]
  2. arr4.flat()  // [1, 2, 4, 5]

Array.prototype.flatMap()

这是一个实验中的方法，尽量不要在生产环境中使用它。
flatMap() 首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。

将包含几句话的数组拆分成到哪儿汉字组成的新数组。

  1. let arr = ['今天天气不错', '', '早上好']
  2. arr.map(s => s.split("")) // [["今", "天", "天", "气", "不", "错"],[""],["早", "上", "好"]]
  3. arr.flatMap(s => s.split('')) // ["今", "天", "天", "气", "不", "错", "早", "上", "好"]

Array.prototyp.forEach()

forEach() 对数组的每个元素执行一个提供的函数。
返回值： undefined
没有办法中止或跳出forEach() 循环，除了抛出一个异常。

打印数组的内容

  1. function logArrayElements(element, index, array) {
  2.     console.log('a['+ index +'] = ' + element)
  3. }
  5. // 索引2被跳过了，因为数组中的这个位置没有项
  6. [2, 5, , 9].forEach(logArrayElements)

如果数组在迭代时被修改了，则其它元素会被跳过

  1. var words = ['one', 'two', 'three', 'four']
  2. words.forEach(function(word) {
  3.     console.log(word)
  4.   if (word === 'two') {
  5.       words.shift();
  6.   } 
  7. })
  8. // 输出  one two four
  9. // words ['two', 'three', 'four']

当达到tow 项时，整个数组的第一项被移除了，导致所有剩下的项上移一个位置。因为元素four 限制在数组跟前的位置， three 会被跳过

扁平化数组

  1. function flatten(array) {
  2.     let result = [];
  3.     array.forEach(v => {
  4.       if (Array.isArray(v)) {
  5.         result.push(...flatten[i])
  6.     } else {
  7.             result.push(i)    
  8.     }
  9.   })  
  11.   return result;
  12. }

Array.prototype.includes()

用来判断一个数组是否包含一个指定的值，如果包含返回true，否则false.

  1. arr.includes(valueToFind[, fromIndex])
  3. // valueToFind  需要查找的元素值
  4. // fromIndex  从该索引处开始查找，如果是负值，则按升序从 array.length - fromIndex 的索引开始搜。默认0
  6. // 返回值 Boolean

示例

  1. [1, 2, 3].includes(3, 3) // false
  2. [1, 2, 3].includes(3, -1) // true
  3. [1, 2, NaN].includes(NaN) // true

fromIndex 大于等于数组的长度，则会返回false, 且该数组不会被搜索。

  1. var arr = ['a', 'b', 'c']
  3. arr.includes('c', 3) // false
  4. arr.includes('c', 100)  // false

如果fromIndex 为负值，计算出的索引将作为开始搜索的位置。如果计算出的索引小于0，则整个数组都会被搜索。

  1. var arr = ['a', 'b', 'c']
  3. arr.includes('a', -100);  // true
  4. arr.includes('b', -100);  // true
  5. arr.includes('a', -2);  // false

Array.prototype.indexOf()

返回在数组中可以找到的给定元素的第一个索引，如果不存在，则返回 -1.

判断一个元素是否在数组里，不在则更新数组。

  1. function updateVegetablesCollection(veggies, veggie) {
  2.     if (veggies.indexOf(veggie) === -1) {
  3.       veggies.push(veggie)
  4.   } else if ( veggies.indexOf(veggie) > -1) {
  5.       console.log(veggie + 'already exists in the veggies collection.')
  6.   }
  7. }
  9. var veggies = ['potato', 'tomato']
  10. updateVegetablesCollection(veggies, 'spinach')  // ['patato', 'tomato', 'spinach']

Array.prototype.join()

join() 将一个数组（或类数组对象）的所有元素连接成一个字符串并返回这个字符串。
如果数组只有一个项目，那么将返回该项目而不使用分隔符。

  1. arr.join([spearator])
  3. // spearator 默认为‘,’.如果spearator是空字符串(""),则所有元素之间都没够任何字符。
  5. 返回值： 一个所有数组元素连接的字符串。如果arr.length 为 0，则返回空字符串。
  7. 如果一个元素为 undefined 或 null, 它会被转换成空字符。

示例

  1. var a ['Wind', 'Rain', 'Fire']
  3. var myVal1 = a.join(); // "Wind,Rain,Fire"
  4. var myVal2 = a.join(", ") // "Wind, Rain, Fire"
  5. var myVal3 = a.join(" + ") // "Wind + Rain + Fire"
  6. var myVal4 = a.join('') // "WindRainFire"

Array.prototype.keys()

key() 返回一个包含数组中每个索引键的 Array Iterator 对象

返回值： 一个新的 Array 迭代器对象

索引迭代器会包含那些没有对应元素的索引。

  1. var arr = ['a', 'c']
  2. var sparsekeys = Object.keys(arr); // ['0', '1']
  3. var denseKeyss = [...arr.keys()]; // [0, 1]

Array.prototype.lastIndexOf()

返回指定元素再数组中的最后一个索引，如果不存在则返回 -1. 从数组的后面向前查找，从 fromIndex 开始。

Array.prototype.map()

map() 创建一个新数组。
返回值： 一个新数组，每个元素都是回调函数的结果。

数组中每个元素的平方根

  1. let numbers = [1, 4, 9]
  2. var roots = numbers.map(Math.sqrt)
  4. // roots [1, 2, 3]
  5. // numbers = [1, 4, 9]

使用技巧

  1. ['1', '2', '3'].map(parseInt) // [1, NaN, NaN]
  2. ['1', '2', '3'].map(str => parseInt(str)) // [1, 2, 3]
  3. ['1', '2', '3'].map(Number) // [1, 2, 3]
  4. ['1.1', '2.2e2', '3e300'].map(Number) // [1.1, 220, 3e+300]