方法總覽

1. concat

   連線兩個或者更多陣列，並返回結果

   
   var array = [1,3,4];
   var array2 = [2, 4, 6];
   array.concat(array2);	// (6) [1, 3, 4, 2, 4, 6]
   
   

2. every

   對陣列中的每一項執行給定函式，如果該函式的每一項都返回true則返回true。相當於邏輯與

   
   var array = [1,3,4];
   array.every((value, index) => {
   	console.log(value, index);
   	if(value) return true;
   });
   
   // 1 0
   // 3 1
   // 4 2
   // true
   
    
   

3. filter

   對陣列中的每一項執行給定函式，返回該函式會返回true的項組成的陣列

   
   var array = [1,3,7,4,5];
   array.filter((value) => {
   	if (value > 3) return true;
   })
   //  [7, 4, 5]
   
   

4. forEach

   對陣列中的每一項執行給定函式，這個方法沒有返回值

   
   var array = [1,3,7,4,5];
   array.forEach((value) => {
   	if (value > 3) return true;
   })
   //  undefined
   
   

5. join

   將所有的陣列連線成一個字串

   
   var array = [1,3,7,4,5];
   array.join(); 				// "1,3,7,4,5"
   array.join("+"); 			// "1+3+7+4+5"
   
   

6. indexOf

   接受一個引數，返回第一個與引數相等的陣列元素的索引， 如果沒有返回-1

   
   var array = [1,3,7,4,5,4];
   array.indexOf(4); 				//  3
   array.indexOf(22); 				// -1
   
   

7. LastIndexOf

   接受一個引數，返回最後一個與引數相等的陣列元素的索引， 如果沒有返回-1

   
   var array = [1,3,7,4,5,4];
   array.lastIndexOf(4); 				//  5
   array.indexOf(22); 				// -1
   
    
   

8. map

   對陣列中的每一項執行制定函式，返回每次函式呼叫的結果組成的陣列

   
   var array = [1,3,7,4,5,4];
   array.map((value, index) =>{
   	return  `index:${index}, value${value}`;
   })
   //(6) ["index:0, value1", "index:1, value3", "index:2, value7", "index:3, value4", "index:4, value5", "index:5, value4"]
   
   

9. reverse

   顛倒陣列中元素的順序

   
   var array = [1,3,7,4,5,4];
   array.reverse()；	// (6) [4, 5, 4, 7, 3, 1]
   
   

10. slice

    切片， 將陣列選中位置返回一個新的陣列 第一個引數start position， 第二個引數 end position

    
    var array = [1,3,7,4,5,4];
    array.slice(1, 3);	// (2) [3, 7]
    
    

11. some

    對陣列中的每一項執行給定函式， 如果任一項返回true，則為true。相當於邏輯或。

    
    var array = [1,3,7,4,5,4];
    array.some((value) => {
    	if (value >5) return true;
    });
    // true
    
    

12. sort

    按照字母順序對陣列排序，支援傳入指定的排序方法的函式作為引數。

    
    var array = [1,3,7,4,15,4];
    // 無參
    array.sort();
    //  (6) [1, 15, 3, 4, 4, 7]
    
    // 傳入排序方法作為引數
    array.sort((a, b) => {
    	return a-b
    })
    // (6) [1, 3, 4, 4, 7, 15]
    

13. toString

    將陣列作為字串返回

    
    var array = [1,3,7,4,15,4];
    array.toString();		// "1,3,7,4,15,4"
    
    

判斷是否屬於陣列

1. typeof：不能使用typeof 判斷是否屬於陣列

   var a = [1,3,4];
   typeof a;		//  "object"
   var b = new Array();
   typeof b;		//	"object"
   

2. instanceof： instanceof運算子可以用來判斷某個建構函式的prototype屬性所指向的物件是否存在於另外一 個要檢測物件的原型鏈上。在使用的時候語法如下

    object instanceof constructor
   

   var a = [1,3,4];
   a instanceof Array;		//  true
   a instanceof Object; 	// true
   var b = new Array();
   b instanceof Array;		//	true
   var c = {};
   c instanceof Array; 		// false
   

3. 用Object的toString方法判斷 如果一個物件的toString方法沒有被重寫過的話，那麼toString方法將會返回"[object type]"， 其中的type代表的是物件的型別，根據type的值，我們就可以判斷這個疑似陣列的物件到底是 不是陣列了。

   const a = ['Hello','Howard'];
   const b = {0:'Hello',1:'Howard'};
   const c = 'Hello Howard';
   Object.prototype.toString.apply(a);//"[object Array]"
   Object.prototype.toString.apply(b);//"[object Object]"
   Object.prototype.toString.apply(c);//"[object String]"
   

   call()能達到同樣的效果

   const a = ['Hello','Howard'];
   const b = {0:'Hello',1:'Howard'};
   const c = 'Hello Howard';
   Object.prototype.toString.call(a);//"[object Array]"
   Object.prototype.toString.call(b);//"[object Object]"
   Object.prototype.toString.call(c);//"[object String]"
   

   所以可以

   const isArray = (something)=>{
       return Object.prototype.toString.call(something) === '[object Array]';
   }
   
   cosnt a = [];
   const b = {};
   isArray(a);//true
   isArray(b);//false
   

   前提是沒有胡亂修改Object原型鏈上的toString方法。

4. 用Array物件的isArray方法判斷 Array.isArray() 用於確定傳遞的值是否是一個 Array。 語法規則：Array.isArray(obj)

   // 下面的函式呼叫都返回 true
   Array.isArray([]);
   Array.isArray([1]);
   Array.isArray(new Array());
   // 鮮為人知的事實：其實 Array.prototype 也是一個數組。
   Array.isArray(Array.prototype); 
   

   // 下面的函式呼叫都返回 false
   Array.isArray();
   Array.isArray({});
   Array.isArray(null);
   Array.isArray(undefined);
   Array.isArray(17);
   Array.isArray('Array');
   Array.isArray(true);
   Array.isArray(false);
   Array.isArray({ __proto__: Array.prototype });