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

方法总览

concat

连接两个或者更多数组，并返回结果
```
var array = [1,3,4];
var array2 = [2, 4, 6];
array.concat(array2);	// (6) [1, 3, 4, 2, 4, 6]
```

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

filter

对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组


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

forEach

对数组中的每一项运行给定函数，这个方法没有返回值


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

join

将所有的数组连接成一个字符串


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

indexOf

接受一个参数，返回第一个与参数相等的数组元素的索引，如果没有返回-1
```
var array = [1,3,7,4,5,4];
array.indexOf(4); 				//  3
array.indexOf(22); 				// -1
```
LastIndexOf

接受一个参数，返回最后一个与参数相等的数组元素的索引，如果没有返回-1
```
var array = [1,3,7,4,5,4];
array.lastIndexOf(4); 				//  5
array.indexOf(22); 				// -1
```

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

reverse

颠倒数组中元素的顺序


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

slice

切片，将数组选中位置返回一个新的数组
第一个参数start position，第二个参数 end position
```
var array = [1,3,7,4,5,4];
array.slice(1, 3);	// (2) [3, 7]
```
some

对数组中的每一项运行给定函数，如果任一项返回true，则为true。相当于逻辑或。
```
var array = [1,3,7,4,5,4];
array.some((value) => {
	if (value >5) return true;
});
// true
```

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]

toString

将数组作为字符串返回


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

判断是否属于数组

typeof：不能使用typeof 判断是否属于数组

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

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

用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方法。

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