js Array 原生方法

Array.some(fn(v,i),thisArgs)

只要数组的一个值满足指定的测试，就返回true

thisArgs: fn方法中this指向，如果是object类型正常指向，如果是string类型，会按fn中的i去截取string中对位的位置的字符

var arr = [1,2,3,4];
var _this = ['_this'];
var re = arr.some(function(v,i){
    console.log(this); //['_this']
    return v==4;
},_this);
console.log(re); //true

Array.every(fn(v,i),thisArgs)

数组的所有成员是否满足指定的测试

var arr = [1,2,3,4];
var _this = ['_this'];
var re = arr.every(function(v,i){
    console.log(this); //['_this']
    return v>=0;
},_this);
console.log(re); //true

Array.map(fn(v,i),thisArgs)

对数组的每个元素调用定义的回调函数并返回包含结果的数组。

var arr = [1,2,3,4];
var _this = ['_this'];
var re = arr.map(function(v,i){
    console.log(this); //['_this']
    return ++v;
},_this);
console.log(re); //[2,3,4,5]

Array.indexOf(str,index)

和字符串的 indexOf 方法很接近，返回某个值在数组中的第一个匹配项的索引。

var arr = ['aa','cc','bb','cc','dd'];
var re = arr.indexOf('cc'); //1
var re2 = arr.indexOf('cc',2); //3

Array.includes(x)

是否包含给定的值，返回true 或false

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

Array.find(function(v,i,arr),thisArgs}

数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

v：数组值

i：索引

arr：当前数组

thisArgs：fn函数中this指向

var re = [1,2,3,4].find(function(v,i,arr){
    console.log(arr); //[1,2,3,4]
    console.log(this); //{this: 'this'}
    return v>=2;
},{this:'this'})
console.log(re); //2
var re2 = [1,2,3,4].find(function(v,i,arr){
    console.log(this); //{0: "_", 1: "t", 2: "h", 3: "i", 4: "s", length: 5}
    return v>=10;
},'_this')
console.log(re2); //undefined

Array.findIndex(fn(v,i,arr),thisArgs)

和find方法很类似，满足条件返回当前的索引值，不满足返回-1

Array.filter(fn(v,i),thisArgs)

过滤，返回数组中的满足回调函数中指定的条件的元素。

var arr = [1,2,3,4];
var _this = ['_this'];
var re = arr.filter(function(v,i){
    console.log(this); //['_this']
    return v%2==0;
},_this);
console.log(re); //[2,4]

Array.from(json,fn(v,i),thisArgs)

从类似数组的对象或可迭代的对象返回一个数组。

var tmpJson = {
    '0': '0',
    '1': '1',
    '2': '2',
    length: '3'
};
var _this = ['_this'];
var re = Array.from(tmpJson,function(v,i){
    console.log(this); //['_this']
    return v;
},_this);
console.log(re); //['0','1','2'];
var re2 = Array.from(tmpJson,function(v,i){
    console.log(this); //['_this']
    return +v+1;
},_this);
console.log(re2); //[1,2,3];

function fn(a,b,c){
    var arr = Array.from(arguments,function(v,i){
        console.log(this); //['_this']
        return v;
    },['_this']);
    arr.push('d');
    console.log(arr);   //['a','b','c','d'];
}
fn('a','b','c')

Array.of()

用于创建数组

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

Array.copyWithin(target, start = 0, end = this.length)

数组实例的copyWithin方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。

target（必需）：从该位置开始替换数据。start（可选）：从该位置开始读取数据，默认为0。如果为负值，表示倒数。end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。

[1, 2, 3, 4, 5].copyWithin(0, 3)    // [4, 5, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(0, 3, 4) // [4, 2, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)   // [4, 2, 3, 4, 5]
[].copyWithin.call({length: 5, 3: 1}, 0, 3) // {0: 1, 3: 1, length: 5}

Array.fill(x,start,end)

用于填充数组，会覆盖原来的值

x:填充值

start：起始位置

end：结束位置

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

new Set()

这是一种数据结构，不是数组方法。类似于数组，但是成员的值都是唯一的，可以用来给数组去重

var arr = [1,2,3,"1","2","3",1,2,3];
var re1 = Array.from(new Set(arr));
var re2 = [...new Set(arr)];
console.log(re1); //[1, 2, 3, "1", "2", "3"]
console.log(re2); //[1, 2, 3, "1", "2", "3"]

拥有以下方法，可以和数组互转做一些判断

add(value)：添加某个值，返回Set结构本身。
delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
has(value)：返回一个布尔值，表示该值是否为Set的成员。
clear()：清除所有成员，没有返回值。

var s = new Set();
s.add(1).add(2).add(2);
s.size // 2
s.has(1) // true
s.has(2) // true
s.has(3) // false
s.delete(2);
s.has(2) // false