ES6数组方法（转载）

零、数组类型判断

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]

let helper = {
    add (value) {
        return value+1;
    }
}
function translate () {
    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

 

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] ]

 

前端笔记网站导航

网站导航 ：https://www.jianshu.com/p/3e0ec1588160

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