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