数组的建立

var arrayObj = []; //一般数组建立
var arrayObj = new Array();　//建立一个数组
var arrayObj = new Array([size]);　//建立一个数组并指定长度，注重不是上限，是长度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　//建立一个数组并赋值

数组的增加

• push()要领将一个或多个新元素增加到数组末端，并返回数组新长度,数组稳定

var arr = [1]
console.log(arr.push(2)) //2
console.log(arr) //[1, 2]

• unshift()要领将一个或多个新元素增加到数组头部，并返回数组新长度,数组稳定

var arr = [1]
console.log(arr.unshift(2)) //2
console.log(arr) //[2, 1]

• splice()将一个或多个新元素插进去到数组的指定位置，插进去位置的元素自动后移，返回””。

var arr = [1,2,3,4,5]
arr.splice(2,0,'insert') //示意在第二个位置插进去，删除0个元素,返回[]
console.log(arr) //[1, 2, "insert", 3, 4, 5]

var newArr = [1,2,3,4,5]
newArr.splice(2,1,'insert') //示意删除第二个位置后的1个元素并插进去
console.log(newArr) //[1, 2, "insert", 4, 5]

数组的删除

• pop()移除末了一个元素并返回该元素值

• shift()移除最前一个元素并返回该元素值，数组中元素自动前移

• splice(deletePos,deleteCount)删除从指定位置deletePos最先的指定数目deleteCount的元素，数组情势返回所移除的元素

数组的截取和兼并

• concat()将多个数组（也可所以字符串，或者是数组和字符串的夹杂）衔接为一个数组，返回衔接好的新的数组

var a = [1]
var b = [2]
a.concat(b) //[1,2] 既不是a也不是b

• slice(start, [end])以数组的情势返回数组的一部分，注重不包含 end 对应的元素，假如省略 end 将复制 start 以后的一切元素

数组的拷贝

arrayObj.slice(0); //返回数组的拷贝数组，注重是一个新的数组，不是指向
arrayObj.concat(); //返回数组的拷贝数组，注重是一个新的数组，不是指向

数组元素的排序

arrayObj.reverse(); //反转元素（最前的排到末了、末了的排到最前），返回数组地点
arrayObj.sort(); //对数组元素排序，返回数组地点

数组元素的字符串化

join()要领是一个异常有用的要领，它把当前Array的每一个元素都用指定的字符串衔接起来，然后返回衔接后的字符串：

arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值衔接在一起，中心用 separator 离隔。
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'

数组的查找

• indexOf()

• lastIndexOf()

• find()要领，用于找出第一个相符前提的数构成员

find要领的回调函数能够吸收三个参数，依次为当前的值、当前的位置和原数组。

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

• findIndex()返回第一个相符前提的数构成员的位置，假如一切成员都不相符前提，则返回-1。

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

推断是不是为数组

• typeof 操作符

  var arr=new Array("1","2","3","4","5");
  alert(typeof(arr));  // Object

• instanceof()运算符会返回一个 Boolean 值，指出对象是不是是特定类的一个实例。

  var arrayStr=new Array("1","2","3","4","5");
  alert(arrayStr instanceof Array);  //true

• Array.isArray()用来推断某个值是不是为数组。假如是，则返回 true，不然返回 false。

  // 下面的函数挪用都返回 true
  Array.isArray([]);
  Array.isArray([1]);
  Array.isArray(new Array());
  // 不为人知的现实：实在 Array.prototype 也是一个数组。
  Array.isArray(Array.prototype); 

数组迭代

• filter()运用指定的函数测试一切元素，并建立一个包含一切经由过程测试的元素的新数组。

  function isBigEnough(element) {
    return element >= 10;
  }
  var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
  // filtered is [12, 130, 44]

• forEach()让数组的每一项都实行一次给定的函数。

  function logArrayElements(element, index, array) {
      console.log("a[" + index + "] = " + element);
  }
  [2, 5, 9].forEach(logArrayElements);
  // logs:
  // a[0] = 2
  // a[1] = 5
  // a[2] = 9

• every()测试数组的一切元素是不是都经由过程了指定函数的测试。

  //检测数组中的一切元素是不是都大于 10
  function isBigEnough(element, index, array) {
    return (element >= 10);
  }
  var passed = [12, 5, 8, 130, 44].every(isBigEnough);
  // passed is false
  passed = [12, 54, 18, 130, 44].every(isBigEnough);
  // passed is true

• map()返回一个由原数组中的每一个元素挪用一个指定要领后的返回值构成的新数组。

  const arr = [1,2,3]
  arr.map((item,index) => {
    console.log(item)
  })

• some()测试数组中的某些元素是不是经由过程了指定函数的测试。

  //检测在数组中是不是有元素大于 10。
  function isBigEnough(element, index, array) {
    return (element >= 10);
  }
  var passed = [2, 5, 8, 1, 4].some(isBigEnough);
  // passed is false
  passed = [12, 5, 8, 1, 4].some(isBigEnough);
  // passed is true

• reduce()吸收一个函数作为累加器（accumulator），数组中的每一个值（从左到右）最先缩减，终究为一个值。

语法: arr.reduce(callback,[initialValue])

callback:实行数组中每一个值的函数，包含四个参数

• previousValue上一次挪用回调返回的值，或者是供应的初始（initialValue）

• currentValue 数组中当前被处置惩罚的元素

• index 当前元素在数组中的索引

• array 挪用 reduce 的数组 initialValue: 作为第一次挪用 callback 的第一个参数。

var total = [0, 1, 2, 3].reduce(function(a, b) {
  return a + b;
});
// total == 6

• Array.from()用于将两类对象转为真正的数组：相似数组的对象（array-like object）和可遍历（iterable）的对象（包含ES6新增的数据结构Set和Map）。

  let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
  };
  
  // ES6的写法
  let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

• Array.of()要领用于将一组值，转换为数组。

  Array.of(3, 11, 8) // [3,11,8]
  Array.of(3) // [3]
  Array.of(3).length // 1

• fill()要领运用给定值，添补一个数组。

  ['a', 'b', 'c'].fill(7)
  // [7, 7, 7]
  new Array(3).fill(7)
  // [7, 7, 7]

fill要领还能够吸收第二个和第三个参数，用于指定添补的肇端位置和完毕位置。

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

遍历数组

• ·keys()`是对键名的遍历

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

• values()是对键值的遍历

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

• entries()是对键值对的遍历。

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

• includes()