JS数组Array的全部方法汇总

//constructor属性
var arr = [];
arr.constructor === Array
//true


//prototype属性
Array.prototype.max = function(){
	var max = this[0];
	for(var i = 1; i < this.length; i++){
		if(this[i] > max){
			max = this[i];
		}
	}
	return max;
}
console.log([2, 5, 2, 1, 3, 8, 5].max());
//8

//Array.from属性
function a(m, n, o){
	return arguments;
}
a(1, 2, 3);		//返回的是类数组
Array.from(a(1, 2, 3));		//返回的是数组
Array.prototype.slice.call(a(1, 2, 3));		//返回的是数组
 
//字符串
Array.from('abc');
//['a', 'b', 'c']
//类似于'abc'.split('')
 
//Set数据结构
var setObj = new Set(['a', 'b', 'c']);
var arr = Array.from(setObj);
console.log(arr);
//['a', 'b', 'c']
 
//箭头语法和映射函数
var arr = Array.from([1, 2, 3], x => x * 10);
//[10, 20, 30]


//Array.isArray()
Array.isArray([]);		//true
Array.isArray({});		//false
Array.isArray(null);	//false
 
//注意：typeof不能够区分对象和数组
typeof({}) === 'object'
typeof([]) === 'object'
typeof(null) === 'object'
typeof(undefined) === 'undefined'
typeof(0) === 'number'
typeof('0') === 'string'


//Array.of()
Array.of(1, 2, 3);		//[1, 2, 3]
new Array(1, 2, 3);		//[1, 2, 3]
//如果只有一个参数呢？
Array.of(3);			//[3]
new Array(3);			//[,,] 数组length为3，所有值均为undefined


//concat()连接数组
var a = [1, 2, 3];
var b = [4, 5];
var c = a.concat(b);			//[1, 2, 3, 4, 5]
//也可用于连接字符串
var d = c.concat('m', 'n');		//[1, 2, 3, 4, 5, m, n]


//entries数组迭代器
var e = ['a', 'b', 'c'].entries();
e.next().value	=== [0, 'a'];
e.next().value	=== [1, 'b'];
e.next().value	=== [2, 'c'];
//通过next()迭代返回数组的键值对
//keys和entries用法相似，但只返回键值
var e = ['a', 'b', 'c'].keys();
e.next().value	=== 0;
e.next().value	=== 1;
e.next().value	=== 2;


//every方法
//该方法用来确保数组中的所有成员是否都满足条件，是的话返回true，否则false
[1, 2].every(function(value){
	if(value === 1 || value === 2){
		return true;
	}else{
		return false;
	}
})
//true
 
//相对应的some方法
//该方法会升序对数组的每一个元素调用，若遇到返回true的，直接返回true，如果都为false，则返回false，可以理解为只要数组中有一个元素满足条件，则返回true
[1, 2, 3, 4].some(function(value){
	if(value === 3){
		return true;
	}else{
		return false;
	}
})
//true
[1, 2, 3, 4].some(function(value){
	if(value === 5){
		return true;
	}else{
		return false;
	}
})
//false


//fill方法
//fill(val, start, end)方法用于填充数组，第一个参数为值，第二个参数为开始位置索引，第三个参数为结束位置索引
[0, 0, 0].fill(7, 1);		//[0, 7, 7]
[0, 0, 0].fill(7);			//[7, 7, 7]
 
 
//filter方法
//返回数组中满足回调函数条件的元素
[1, 2, 3].filter(function(val){
	if(val === 1 || val === 2){
		return true;
	}else{
		return false;
	}
})
//[1, 2]


//findIndex方法
//用回调函数遍历数组，直到回调函数返回true，则返回相应的索引，如果一直没有，则返回-1
[1, 2, 3].findIndex(function(val){
	return val === 2 ? true : false;
})
//1(数值2的索引是1)


//forEach遍历
[1, 2, 3].forEach(function(val, index, arr){
	console.log(val);
})
//1 2 3


//indexOf方法
//用于判断数组中是否有相匹配的值，第二个参数表示从数组的某个开始位置往后检索
[1, 2, 3, 4, 2].indexOf(2);			//1
[1, 2, 3, 4, 2].indexOf(2, 2);		//4
//lastIndexOf表示从数组最后一个元素开始检索


//join方法拼接字符串
[1, 2, 3].join('-');
//1-2-3

//map方法
//注意：会返回一个新数组
[1, 2, 3].map(function(val){
	return val * 2;
})
//[2, 4, 6]


//pop方法，移除最后一个元素并返回这个元素，如果数组为空，返回undefined
[1, 2, 3].pop();	//3
//shift方法，类似pop方法，移除第一个元素并返回这个元素
[1, 2, 3].shift();	//3
//push方法，数组尾部追加元素，注意，这会更改原数组，并且返回的是新数组的长度，如果参数是一个数组的话，会当成一个元素添加进去
var arr = [1];
var a = arr.push(2, 3);		//a = 3, arr = [1, 2, 3]
var b = arr.push([4, 5]);	//b = 4, arr = [1, 2, 3, [4, 5]]
//unshift方法，数组头部追加元素，注意，这会更改原数组，并且返回的是新数组的长度，同于push方法
[1, 2, 3].unshift(9);	//4


//reduce方法
//对数组中的所有元素调用指定的回调函数，该回调函数的返回值为累计结果，并且在下一次调用该回调函数的时候作为参数提供
//reduce(callback, initialValue)
 
//第一种情况，没有初始值，第一次执行回调时，pre等于数组第一个元素，cur等于第二个元素
[1, 2, 3].reduce(function(pre, cur){
	return pre + '-' + cur;
})
//1-2-3
 
//第二种情况，有初始值，第一次执行回调时，pre等于初始值，cur等于第一个元素
[1, 2, 3].reduce(function(pre, cur){
	return pre + '-' + cur;
}, 8)
//8-1-2-3


//reduceRight方法
//类似于reduce方法，对数组是逆序操作
[1, 2, 3].reduceRight(function(pre, cur){
	return pre + '-' + cur;
})
//3-2-1
 
//运用此方法反转字符串
Array.prototype.reduceRight.call('12345', function(pre, cur){
	return pre + cur;
})
//54321


//reverse方法反转数组元素
//注意，此方法会修改原数组，并不会创建新数组
[1, 2, 3].reverse();
//[3, 2, 1]


//slice方法
//返回一个新数组，截取数组中的一部分，第一个参数为开始位置，第二个参数为结束位置，如果为负数的话，可以理解为数组的length加上这个start或者end的值，注意不包括end这个数
[1, 2, 3, 4].slice(1);		//[2, 3, 4]
[1, 2, 3, 4].slice(1, 2);	//[2]
[1, 2, 3, 4].slice(-1);		//[4]
[1, 2, 3, 4].slice(0, -1);	//[1, 2, 3]
 
//splice方法，从数组中移除元素，如有必要，在移除的位置上插入新的元素，并返回移除的元素
var a = [1, 2, 3, 4, 5, 6].splice(1, 2, 'a', 'b');
//a = [2, 3]
//数组变为[1, 'a', 'b', 4, 5, 6]


//sort方法排序
//注意，会操作原数组
[6, 2, 5, 1].sort(function(a, b){
	return a - b;
})


//toString方法
[1, 2, 3, 4].toString();
//1,2,3,4


//valueOf方法，返回指定对象的基元值
var arr = [1, 2];
var s = arr.valueOf();
arr === s
//true


//values方法，迭代器
var v = [1, 2, 3].values();
v.next().value === 1;
v.next().value === 2;
v.next().value === 3;