Array对象

组织函数

Array是 JavaScript 的原生对象，同时也是一个组织函数，能够用它天生新的数组。

假如没有运用new，运转效果也是一样的。

var arr = new Array(2);
// 等同于var arr = Array(2);

Array组织函数有一个很大的瑕玷，就是差别的参数，会致使它的行动不一致。

// 无参数时，返回一个空数组
new Array() // []

// 单个正整数参数，示意返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]

// 非正整数的数值作为参数，会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length

// 单个非数值（比方字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]

// 多参数时，一切参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']

能够看到，Array作为组织函数，行动很不一致。因而，不发起运用它天生新数组，直接运用数组字面量是更好的做法。

// bad
var arr = new Array(1, 2);

// good
var arr = [1, 2];

注：ES6 引入了Array.of( )要领来处置惩罚这个题目。该要领的作用异常类似Array组织器，但在运用单个数值参数的时刻并不会致使特别效果。Array.of( )要领总会建立一个包括一切传入参数的数组，而不论参数的数目与范例：

let items = Array.of(1, 2);
console.log(items.length); // 2
console.log(items[0]); // 1
console.log(items[1]); // 2
items = Array.of(2);
console.log(items.length); // 1
console.log(items[0]); // 2

Array.of基本上能够用来替换Array()或newArray()，而且不存在因为参数差别而致使的重载，而且他们的行动异常一致。

静态要领

Array.isArray()

Array.isArray要领返回一个布尔值，示意参数是不是为数组。它能够填补typeof运算符的不足。

var arr = [1, 2, 3];

typeof arr // "object"
Array.isArray(arr) // true`

Array.from()

ES6特征，将伪数组对象或可遍历对象转换为真数组。假如一个对象的一切键名都是正整数或零，而且有length属性，那末这个对象就很像数组，称为伪数组。典范的伪数组有函数的arguments对象，以及大多数 DOM 元素集，另有字符串。

Array.of()

ES6特征，

实例要领

valueOf()，toString()

valueOf要领是一个一切对象都具有的要领，示意对该对象求值。差别对象的valueOf要领不尽一致，数组的valueOf要领返回数组自身。

var arr = [1, 2, 3];
arr.valueOf() // [1, 2, 3]

toString要领也是对象的通用要领，数组的toString要领返回数组的字符串情势。

var arr = [1, 2, 3];
arr.toString() // "1,2,3"

var arr = [1, 2, 3, [4, 5, 6]];
arr.toString() // "1,2,3,4,5,6"

push()、pop()

push、pop均是在数组末尾举行增删元素，都邑转变原数组。push要领用于在数组的末尾增加一个或多个元素，并返回增加新元素后的数组长度。pop要领用于删除数组的末了一个元素，并返回该元素。

var arr = [];

arr.push(1) // 1
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]


var arr = ['a', 'b', 'c'];

arr.pop() // 'c'
arr // ['a', 'b']

push和pop连系运用，就构成了“后进先出”的栈构造（stack）。

shift()、unshift()

shift、unshift均是在数组头举行增删元素，都邑转变原数组。shift()要领用于删除数组的第一个元素，并返回该元素。unshift()要领用于在数组的第一个位置增加元素，并返回增加新元素后的数组长度。

var a = ['a', 'b', 'c'];

a.shift() // 'a'
a // ['b', 'c']


var a = ['a', 'b', 'c'];

a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']

push()和shift()连系运用，就构成了“先进先出”的行列构造（queue）。

join()

join()要领以指定参数作为分开符，将一切数构成员衔接为一个字符串返回。假如不供应参数，默许用逗号分开。

var a = [1, 2, 3, 4];

a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"

concat()

concat要领用于多个数组的兼并。它将新数组的成员，增加到原数构成员的后部，然后返回一个新数组，原数组稳定。

['hello'].concat(['world'])
// ["hello", "world"]

['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]

[].concat({a: 1}, {b: 2})
// [{ a: 1 }, { b: 2 }]

[2].concat({a: 1})
// [2, {a: 1}]

[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]

reverse()

reverse要领用于倒置分列数组元素，返回转变后的数组。注重，该要领将转变原数组。

var a = ['a', 'b', 'c'];

a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]

slice()、splice()

slice要领用于提取目标数组的一部分，返回一个新数组，原数组稳定。

arr.slice(start, end);

它的第一个参数为肇端位置（从0最先），第二个参数为停止位置（但该位置的元素自身不包括在内）。假如省略第二个参数，则一向返回到原数组的末了一个成员。假如slice要领的参数是负数，则示意倒数盘算的位置。

var a = ['a', 'b', 'c'];

a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]


var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]

splice要领用于删除原数组的一部分红员，并能够在删除的位置增加新的数构成员，返回值是被删除的元素。注重，该要领会转变原数组。
arr.splice(start, count, addElement1, addElement2, ...);

splice的第一个参数是删除的肇端位置（从0最先），第二个参数是被删除的元素个数。假如背面另有更多的参数，则示意这些就是要被插进去数组的新元素。肇端位置假如是负数，就示意从倒数位置最先删除。假如只是纯真地插进去元素，splice要领的第二个参数能够设为0。假如只供应第一个参数，等同于将原数组在指定位置拆分红两个数组。

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]


var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]


var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"]


var a = [1, 1, 1];

a.splice(1, 0, 2) // []
a // [1, 2, 1, 1]


var a = [1, 2, 3, 4];
a.splice(2) // [3, 4]
a // [1, 2]

sort()

sort要领对数构成员举行排序，默许是根据字典递次排序。排序后，原数组将被转变。

['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']

[4, 3, 2, 1].sort()
// [1, 2, 3, 4]

[11, 101].sort()
// [101, 11]

[10111, 1101, 111].sort()

数值会被先转成字符串，再根据字典递次举行比较，所以101排在11的前面。

假如想让sort要领根据自定义体式格局排序，能够传入一个函数作为参数。

[10111, 1101, 111].sort(function (a, b) {
  return a - b;
})
// [111, 1101, 10111]


[
  { name: "张三", age: 30 },
  { name: "李四", age: 24 },
  { name: "王五", age: 28  }
].sort(function (o1, o2) {
  return o1.age - o2.age;
})
// [
//   { name: "李四", age: 24 },
//   { name: "王五", age: 28  },
//   { name: "张三", age: 30 }
// ]

map()、forEach（）

map要领和forEach要领很类似，也是对数组的一切成员顺次实行参数函数。map要领将数组的一切成员顺次传入参数函数，然后把每一次的实行效果构成一个新数组返回。forEach要领不返回值，只用来操纵数据。这就是说，假如数组遍历的目标是为了获得返回值，那末运用map要领，不然运用forEach要领。

map、forEach要领接收一个函数作为参数。该函数调用时，map要领向它传入三个参数：当前成员、当前位置和数组自身。

[1, 2, 3].map(function(elem, index, arr) {
  return elem * index;
});
// [0, 2, 6]


function log(element, index, array) {
  console.log('[' + index + '] = ' + element);
}

[2, 5, 9].forEach(log);
// [0] = 2
// [1] = 5
// [2] = 9

上面代码中，map、forEach要领的回调函数有三个参数，elem为当前成员的值，index为当前成员的位置，arr为原数组（[1, 2, 3]）。map要领还能够接收第二个参数，用来绑定回调函数内部的this变量。

var arr = ['a', 'b', 'c'];

[1, 2].map(function (e) {
  return this[e];
}, arr)
// ['b', 'c']


var out = [];

[1, 2, 3].forEach(function(elem) {
  this.push(elem * elem);
}, out);

out // [1, 4, 9]

map、forEach要领不会跳过undefined和null，然则会跳过空位。
注：forEach要领没法中缀实行，老是会将一切成员遍历完。假如愿望相符某种前提时，就中缀遍历，要运用for轮回。

var arr = [1, 2, 3];

for (var i = 0; i < arr.length; i++) {
  if (arr[i] === 2) break;
  console.log(arr[i]);
}
// 1

fliter

filter要领用于过滤数构成员，满足前提的成员构成一个新数组返回。它的参数是一个函数，一切数构成员顺次实行该函数，返回效果为true的成员构成一个新数组返回。该要领不会转变原数组。

[1, 2, 3, 4, 5].filter(function (elem, index, arr) {
  return index % 2 === 0;
});
// [1, 3, 5]

filter要领还能够接收第二个参数，用来绑定参数函数内部的this变量。

some()，every()

返回一个布尔值，示意推断数构成员是不是相符某种前提。它们接收一个函数作为参数，一切数构成员顺次实行该函数。该函数接收三个参数：当前成员、当前位置和全部数组，然后返回一个布尔值。some要领是只需一个成员的返回值是true，则全部some要领的返回值就是true，不然返回false。

every要领是一切成员的返回值都是true，全部every要领才返回true，不然返回false。

var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false

some和every要领还能够接收第二个参数，用来绑定参数函数内部的this变量。

indexOf()，lastIndexOf()

indexOf要领返回给定元素在数组中第一次涌现的位置，假如没有涌现则返回-1。indexOf要领还能够接收第二个参数，示意搜刮的最先位置。

var a = ['a', 'b', 'c'];

a.indexOf('b') // 1
a.indexOf('y') // -1

['a', 'b', 'c'].indexOf('a', 1) // -1

lastIndexOf要领返回给定元素在数组中末了一次涌现的位置

var a = [2, 5, 9, 2];
a.lastIndexOf(2) // 3
a.lastIndexOf(7) // -1

find() 和 findIndex()

两者皆是ES6新特征，数组实例的find要领，用于找出第一个相符前提的数构成员。它的参数是一个回调函数，一切数构成员顺次实行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。假如没有相符前提的成员，则返回undefined。

数组实例的findIndex要领的用法与find要领异常类似，返回第一个相符前提的数构成员的位置，假如一切成员都不相符前提，则返回-1。

[1, 4, -5, 10].find((n) => n < 0) // -5


[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) 
// 2

includes()

ES6新特征，Array.prototype.includes要领返回一个布尔值，示意某个数组是不是包括给定的值。该要领的第二个参数示意搜刮的肇端位置，默许为0。假如第二个参数为负数，则示意倒数的位置，假如这时候它大于数组长度（比方第二个参数为-4，但数组长度为3），则会重置为从0最先。

[1, 2, 3].includes(2)   // true
[1, 2, 3].includes(3, -1); // true
[1, 2, 3, 5, 1].includes(1, 2); // true

没有该要领之前，我们一般运用数组的indexOf要领，搜检是不是包括某个值。indexOf要领有两个瑕玷，一是不够语义化，它的寄义是找到参数值的第一个涌现位置，所以要去比较是不是不等于-1，表达起来不够直观。二是，它内部运用严厉相称运算符（===）举行推断，这会致使对NaN的误判。

[NaN].indexOf(NaN) // -1
[NaN].includes(NaN) // true

reduce()，reduceRight()

reduce要领和reduceRight要领顺次处置惩罚数组的每一个成员，终究累计为一个值。它们的差别是，reduce是从左到右处置惩罚（从第一个成员到末了一个成员），reduceRight则是从右到左（从末了一个成员到第一个成员），其他完整一样。

[1, 2, 3, 4, 5].reduce(function (a, b) {
  console.log(a, b);
  return a + b;
})
// 1 2
// 3 3
// 6 4
// 10 5
//末了效果：15

数组实例的 entries()，keys() 和 values()

ES6 供应entries()，keys()和values(),用于遍历数组。它们都返回一个遍历器对象，能够用for…of轮回举行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

for (let index of ['a', 'b'].keys()) {
  console.log(index);
}
// 0
// 1

for (let elem of ['a', 'b'].values()) {
  console.log(elem);
}
// 'a'
// 'b'

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

总结

1. push、pop、shift、unshift、reverse、splice、sort会转变原数据，其他不会；

罕见东西要领

字符串、类数组对象拼接

Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"

var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

类数组对象转为数组

Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']

Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);

找出字符长度最长的数构成员

function findLongest(entries) {
  return entries.reduce(function (longest, entry) {
    return entry.length > longest.length ? entry : longest;
  }, '');
}

findLongest(['aaa', 'bb', 'c']) // "aaa"