JavaScript数组方法及数组检测方法

方法总览

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 });