你所不知道的数组（ES6）

Array.push（element…）

将一个或多个元素添加到数组的末尾，返回值：数组新长度

Tip：call 和 apply 合并数组：

var a = ['1', '2'];
var b = ['3', '4'];
var c = ["5" , "6"];

Array.prototype.push.apply(a, [b,c]);

console.log(a);[ "1" , "2" ,['3', '4'] ,["5" , "6"]]

// 类数组的push
var obj = {
  length:0,
  addEle:function addEle(elem){
    [].push.call(this,elem)
  }
}
obj.addEle("1");
obj.addEle({});
console.log(obj.length)
console.log(obj)

Array.of()

Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

Array.toString()

指定数组，返回数组元素所组成的字符串（逗号分隔）

Array.reverse

颠倒数组

Array.pop()

删除数组中最后一个元素。返回值：删除值，如果数组为空则返回undefined

Array.shift()

删除数组中的第一个元素。返回值：删除值，如果数组为空则返回undefined

var names = ["xiaoming","zhangsan","wangwu"]
while( (i = names.shift()) !== undefined) {
  console.log(i)
}
console.log(names) //[]

Array.unshift(element…)

数组头部添加元素，返回值：新增数组的长度

Array.indexOf(elem,index)

在数组中查找指定元素的第一个索引值，查找不到返回-1

elem: 指定元素
index：开始查找的索引位置

var a = [0,1,2,3,4,1];
console.log(a.indexOf(1));  //2
console.log(a.indexOf(1,2)); // 5

查找数组中元素出现的所有位置：

var arr1 = [];
var arr2 = [1,2,3,4,1];
var idx = arr2.indexOf(1); // 1 第一次出现的索引值
while(idx != -1){ // 如果找到，则加入数组，同时从后面元素中继续查找,直到所有
  arr1.push(idx);
  idx = arr2.indexOf(1, idx+1);
}
console.log(arr1);

Array.splice（start,deleteCount,items）

删除/替换/新增数组元素 。它可以改变原数组

start：索引开始位置（超过数组长度：数组末尾添加。负值：数组末位开始，如果负值超过数组长度，表示开始位置为0）
deleteCount：删除元素个数（deleteConut大于start/忽略没写则删除后面所有元素）
items：元素

var test = [1,2,3,4];
var test1 = test.splice(3,1);
console.log(test); // [1,2,3]
console.log(test1); // [4]

var test2 = [1,2,3,4];
var test3 = test2.splice(1);
console.log(test2)//[1]
console.log(test3) // [2,3,4]

Array.slice（begin，end）

slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end），返回一个新数组，它是一个浅拷贝

begin：
索引开始。如果索引为负数则表示从原数组中的倒数第几个元素开始提取
如果省略 begin，则 slice 从索引 0 开始
如果 begin 超出原数组的索引范围，则会返回空数组

end：索引结束
如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取
如果 end 被省略，则 slice 会一直提取到原数组末尾。
如果 end 大于数组的长度，slice 也会一直提取到原数组末尾

Tip：使用splice复制返回新数组

var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var fruits1 = fruits.slice(1, 3);
var fruits2 = fruits.slice(2);
var fruits3 = fruits.slice();
var fruits4 = fruits.slice(1);
console.log(fruits1);//["Orange","Lemon"]
console.log(fruits2);//["Lemon","Apple","Mango"]
console.log(fruits3);//["Banana","Orange","Lemon","Apple","Mango"]
console.log(fruits4);//["Orange","Lemon","Apple","Mango"]

Array.concat(values)

合并两个或多个数组,不更改现有数组，返回新数组（浅拷贝）

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

Array.sort（）

按照某种规则进行排序，返回数组
规则：默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列
无参数：元素按照转换为的字符串的各个字符的Unicode位点进行排序

const months = ['M1',"A1",'F1','D1'];
months.sort();
console.log(months);

const array1 = [1, 5, 13, 100000];
array1.sort();
console.log(array1);

Array.entries()

返回一个新的Array Iterator对象

Tip: Array Iterator 是一个对象，它的原型上有一个next（）方法，用于遍历数组取得原数组的key和value
{ “value”:[0,“a”],“done”:false } ——> iterator.next()

const array1 = ["a","b","c"];
const iterator1 = array1.entries();
console.log(iterator1); //[object Array Iterator]
console.log(iterator1.next().value);//[0,"a"]
console.log(iterator1.next().value);//[1,"b"]

遍历：iterator.next

var arr = ["a","b","c"];
var iter = arr.entries();
var a = [];

for(var i=0; i< arr.length+1; i++){ //0 0+1 1+1
  var tem = iter.next();
  console.log(tem.done);
  if(tem.done !== true){
    console.log(tem.value);
    a[i]=tem.value;
  }
} 
console.log(a); 
=

遍历： for of

var arr = ["a","b","c"];
var iter = arr.entries();
var array = [];
for(let e of iter){
  array.push(e)
}
console.log(array);

Array.flat(depth)

数组扁平化

depth：深度，默认一层

Array.fill(value,start,end)

let array1 = [1,2,3,4];
array.fill(); undefine,undefined,undefined,undefined
array.fill(0,1,3) // 1,0,0,0
array.fill(1); // 1,1,1,1

Array.filter(callback(item,index,array),thisArg)

过滤

callback(item,index,array)
thisArg: 调用callback的this值

function filter1(element) {
	return element >= 5
}
let element = [1,6,1,7].filter(filter1);

//过滤数据
let arr = [
  { id: 1 },
  { id: 2 },
  { id: 3 },
  { id: "张九" },
  { id: "王二" },
  { id: undefined },
  { id: null },
  { id: NaN },
];

function isNumber(obj) {
  return  obj !== undefined && typeof(obj) === "number" && !isNaN(obj);
}

function filterByID(item) {
  if (isNumber(item.id) && item.id !== 0) {
    return true;
  }
  return false;
}

var arrByID = arr.filter(filterByID);

console.log(arrByID);

Array.reducer（acc,value,index,array）

求和:
let total = [1,2,3,4].reducer((acc,cur)=>{
	return acc + cur;
})

二维数组扁平化:
let fletten = [[1],[2]].reducer((arr,cur)=>{
  acc.concat(cur);
},[])

Array.join()

指定字符分隔数组，返回一个字符串

const elements = ['S', 'D', 'P'];
console.log(elements.join()); "S,D,P"
console.log(elements.join(''));"SDP"

Array.values()

返回一个新的数组可迭代对象

const array1 = ['a', 'b', 'c'];
const iterator = array1.values();

for (let item of array1) {
  console.log(item);
}

Array.forEach

Array.copyWithin

Array.every

Array.map

Array.keys

Array.isArray

Array.includes

Array.form

Array.indexOf

Array.flatMap

Array.find

Array.findIndex

补充

常用操作

创建数组：
	var a = [];
	var b = new Array(3);
	b.push(4);
	console.log(b); //[,,,4]

索引访问：
	var a = [1,2,3];
	var b = a[0]; // 1
	var b = a(a.length-1); //获取尾部元素 -   3