//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;
JS数组Array的全部方法汇总
本文转载:CSDN博客