es6数组方法

https://www.jianshu.com/p/941ee41a264a
零、数组类型判断
Array.isArray()
将数组作为参数传入，返回值为布尔值

let arr = [1,2,3]
let res = Array.isArray(arr) // true

一、数组创建
Array构造函数的特性
如果使用Array构造函数传入一个数值型的值，那么数组的长度length属性会被设置为该值；

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

如果传入一个非数值型的值，那么这个值会成为目标数据的唯一项；
如果传入多个值，无论这些值是不是数值型的，都会变为数组的元素。

Array.of()
无论有多少参数，参数是什么类型的，Array.of()方法总会创建一个包含所有参数的数组。

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

二、伪数组转数组
ES5方式一

function makeArray (arrayLike) {
    var result = [];
    for (var i = 0, len = arrayLike.length; i < len; i++ ) {
        result.push(arrayLike[i]);
    }
    return result;
}
console.log(makeArray('hello')); //  ["h", "e", "l", "l", "o"]

ES5方式二

function makeArray (arrayLike) {
    return Array.prototype.slice.call(arrayLike);
}
console.log(makeArray('world')); // ["w", "o", "r", "l", "d"]

ES6方式一

let str = "hello";
let arr = [...str];
console.log(arr); // ["h", "e", "l", "l", "o"]

ES6方式二

let str = "hello";
let arr = Array.from(str);
console.log(arr); // ["h", "e", "l", "l", "o"]

Array.from()可接收三个参数，第一个参数为类数组对象，第二个参数为映射函数，如果使用了映射函数，可以传第三个参数表示映射函数的this值。

function translate () {
    return Array.from(arguments, (value) => value+1);
}
let numbers = translate(1, 2, 3);
console.log(numbers); // [2, 3, 4]

//如果用映射函数处理对象，也可以给from方法传入第三个参数表示映射函数的this值
let helper = {
    diff:1,
    add (value) {
        return value+this.diff;
    }
}

function translate () {
    //由于add方法使用了this.diff属性，所以需要提供第三个参数helper来指定this的值
    return Array.from(arguments, helper.add, helper);
}

let numbers = translate(1, 2, 3);
console.log(numbers); // [2, 3, 4]

三、查找元素
find()和findIndex()
ES5中可以通过indexOf()和lastIndexOf()查找与特定值匹配的元素，
而ES6中的find()和findIndex()可以根据某个条件去查找匹配的元素。
参数为回调函数和回调函数的this值，
回调函数的参数同forEach()，分别为：元素，索引，数组本身。
find()返回查找的值，findIndex()返回查找的值的索引，两者都只返回第一个满足条件的值

let numbers = [1, 2, 3, 4, 5];
console.log(numbers.find(n => n > 3)); // 4
console.log(numbers.findIndex(n => n > 3)); // 3

fill()方法用指定的值填充一至多个数组元素，当传入一个值时，fill()方***用这个值重写数组中的所有值。如果只想改变数组某一部分的值，可以在第二个和第三个参数传入开始索引和结束索引（不包含结束索引当前值），传入第三个就使用数组length属性作为结束索引。

copyWithin()，这个方法是从数组中复制元素的值，调用方法需要传入两个参数：一个是该方法开始填充值的索引位置，另一个是开始复制值得索引位置。还有一个可选参数：用来限制被重写元素的数量，不包含结束索引，用于指定停止复制值的位置。

let numbers = [1,2,3,4];
numbers.copyWithin(2,0);
console.log(numbers.toString()); // 1,2,1,2
numbers.copyWithin(2,0,1);
console.log(numbers.toString()); // 1,2,1,4

includes()
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。
语法： arr.includes(searchElement, fromIndex) fromIndex可选

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

如果fromIndex 大于等于数组长度 ，则返回 false 。该数组不会被搜索:

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

arr.includes('c', 3);   //false
arr.includes('c', 100); // false

如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。如果计算出的索引小于 0，则整个数组都会被搜索。

// 数组长度是3
// fromIndex 是 -100
// computed index 是 3 + (-100) = -97

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

arr.includes('a', -2); // false
arr.includes('a', -100); // true

四、数组遍历
forEach()
forEach不能中断遍历，没有返回值

let arr = [1, 2, 3];
arr.forEach((item, index, arr) => {
    console.log(item)
})

map()
map返回一个新的数组

let arr = [1, 2, 3];
let newArr = arr.map((item, index, arr) => {
    return item * 2;
})
console.log(arr) // [1, 2, 3]
console.log(newArr) // [2, 4, 6]

filter()
filter可以过滤数组，包含满足条件的数组项，返回一个新数组

let arr = [1, 2, 3];
let newArr = arr.filter((item, index, arr) => {
    return item <= 2;
})
console.log(arr) // [1, 2, 3]
console.log(newArr) // [1, 2]

some()
some返回布尔值，如果有一个满足条件的值则返回true

let arr = [1, 2, 3];
let result = arr.some((item, index, arr) => {
    return item < 2;
})
console.log(result) // true

every()
every返回布尔值，如果所有数组项都满足条件则返回true

let arr = [1, 2, 3];
let result = arr.every((item, index, arr) => {
    return item < 2;
})
console.log(result) // false

五、遍历器
keys()
返回一个包含数组中每个索引键的Array Iterator对象。

let arr = ['a', 'b', 'c'];
let iterator = arr.keys()
for (let key of iterator) {
  console.log(key); // expected output: 0 1 2
}

对象也有相应的方法，获取对象所有属性的键

var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys);  // [0, 1, 2]

values()
values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值。

let arr = ['a', 'b', 'c'];
let iterator = arr.values();

for (const value of iterator) {
  console.log(value); // expected output: "a" "b" "c"
}

对象也有相应的方法，获取对象所有属性的值

var arr = ["a", , "c"];
var sparseKeys = Object.values(arr);
var denseKeys = [...arr.values()];
console.log(sparseKeys); // ["a", "c"]
console.log(denseKeys);  // ["a", undefined, "c"]

entries()
entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

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

// for(var i=0; i< arr.length; i++){   // 实际使用的是这个 
for(var i=0; i< arr.length+1; i++){    // 注意，是length+1，比数组的长度大
    var tem = iter.next();             // 每次迭代时更新next
    console.log(tem.done);             // 这里可以看到更新后的done都是false
    if(tem.done !== true){             // 遍历迭代器结束done才是true
        console.log(tem.value);
        a[i]=tem.value;
    }
}

console.log(a);                         // 遍历完毕，输出next.value的数组

对象也有相应的方法，获取对象所有属性的键值对

const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

作者：lesdom
链接：https://www.jianshu.com/p/941ee41a264a
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。