javascript数组常用操作总结

        // 元素插入删除：push、pop、shift、unshift------------------
        var arr = new Array('number');
        // 从尾部插入m多个元素，返回新数组的长度
        var result = arr.push('one','two','three','four');
        console.log('push:', result, arr);
        
        // 从尾部移除一个元素，返回移除的元素
        result = arr.pop();
        console.log('pop:', result, arr);
        
        // 从头部移除一个元素，返回移除的元素
        result = arr.shift();
        console.log('shift:', result, arr);
        
        // 从头部插入m多个元素，返回新数组的长度
        result = arr.unshift('five','six');
        console.log('unshift:', result, arr);
        

        // 元素截取：splice:操作数组本身，slice：不操作数组本身---------
        // 第一个参数：起始位置(下标从0开始)
        // 第二个参数：表示截取的个数
        // 第三个参数以后：表示追加的新元素(从截取的位置开始追加)
        // 返回被移除的数，直接改变原来的数组
        var arrSlice = arr.splice(1,3,'O','P','Q');
        console.log(arrSlice,arr);
        // 特殊用法，2参数：只截取，不追加；1参数：从起始位置截取到末尾
        console.log(arr.splice(1,2),arr);
        console.log(arr.splice(1),arr);
        
        var newArr = ['zero','one','two','three','four','five','six'];
        // 截取范围（左闭右开区间）,返回截取的内容
        var arrSlice = newArr.slice(2,4);
        console.log(arrSlice,newArr);
        

        // 数组操作的方法：concat、join
        var array = ['seven'];
        // 数组的并集操作（不操作数组本身）,并且concat进来的元素在后面
        var result = newArr.concat(array);
        console.log(newArr,result);
        console.log(array.concat(newArr));
        // 在元素之间添加参数，返回一个字符串，不操作数组本身
        var result = newArr.join('|');
        console.log(result,newArr);
        

        // 排序：sort正序排序、reverse倒叙排序
        var arr = [9,10,20,8,4,5,7,3,6];
        // 正序排序，返回排序后的数组，会改变原来的数组，注意：sort是把元素当作字符串进行排序，不适用于数字排序
        // 如果需要对数字进行排序，则需要自定义排序规则
        var result = arr.sort();
        console.log(result,arr);
        
        var arr = [9,10,20,8,4,5,7,3,6];
        // 倒叙排序，只是按照原来的集合位置进行反转，并不是真正的排序，会改变原来的数组
        var result = arr.reverse();
        console.log(result,arr);
        
        // 自定义排序规则
        var arr = [9,10,20,8,4,5,7,3,6];
        var result = arr.sort(compare);
        console.log(result,arr);




        // 自定义排序:正序：value1<value2 return -1;  倒序：value1<value2 return 1;判断反过来即可 
        function compare(value1,value2) {
            if(value1 < value2) {
                return -1;
            }else if(value1 > value2) {
                return 1;
            }else {
                return 0;
            }
        }

ECMAScript5特性：

/*
    * ECMA5特性
    * 位置方法：indexOf、lastIndexOf
    * 迭代方法：every、 filter、forEach、some、map
    * 缩小方法：reduce、reduceRight
    */

    var arr = [10,12,3,7,5,6,7,4,9,0,5,6,7,8];
    // 一个参数的时候表示参数在数组的索引位置（index从0开始），返回参数在数组的位置,不存在则返回-1
    var index = arr.indexOf(3);
    console.log(index,arr);
    // 第一个参数表示从索引位置开始找，第二个参数代表值，返回的是当前值在数组的位置，不存在则返回-1
    var index = arr.indexOf(5,5);
    console.log(index);
    
    // 从后往前查，返回当前值在数组的索引，跟indexOf类似
    var index = arr.lastIndexOf(5);
    console.log(index);


    // every：对数组的每一个元素执行一个函数，如果都返回true则最后返回true，如果有一个返回false，则最后返回false
    // item:每一个元素，index：元素的索引，array：当前数组
    var result = arr.every(function name(item,index,array) {
        return item> 2;
    });
    console.log(result);


    // filter：对数组的每一个元素执行一个函数，把过滤后的结果返回
    var result = arr.filter(function name(item,index,array) {
        return item> 5;
    });
    console.log(result);

    // forEach：循环，对数组的每一个元素执行一个方法
    arr.forEach(function name(item,index,array) {
        console.log(item,index,array);
    })

    // map: 对一个数组的每一个元素执行一个方法，可以经过函数执行把新的结果返回
    var result = arr.map(function name(item,index,array) {
        // 每一个元素乘以2
        return item*2;
    })
    console.log(result);
    
    // some：对于数组每一个元素进行一个函数运行，如果有一项返回true则最后返回true，如果全部返回false，则最后才返回false
    var result = arr.some(function name(item,index,array) {
        return item >2;
    })
    console.log(result);

    
    // reduce    reduceRight
    // previous:前一个值,current：当前值,currentIndex：当前索引位置,array：原数组
    var result = arr.reduce(function name(previous,current,currentIndex,array) {
        // 相加运算
        return previous + current;
    })
    console.log(result);
    // 类似reduce，只是遍历位置是从后遍历
    var result = arr.reduceRight(function name(previous,current,currentIndex,array) {
        // 相加运算
        return previous + current;
    })
    console.log(result);

 

转载于:https://my.oschina.net/duanxianme/blog/1609922