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;