【JS】JS操作数组的方法

//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;