array类型的方法

var arr1 = [12,454,'dafda','feagfag',23];
var arr2 = [46468,'ffwfe','dafs','dfsfs'];
arr1.indexOf('dafda');   //args:数组里面的值     return:Number下标
arr1.lastIndexOf('dafda');  //args:数组里面的值     return:Number下标
arr1.length; //返回数组的个数。
arr1.join('---');  //连接数组为字符串 返回一个String,"12---454---dafda---feagfag"
arr1.pop();  //删除数组最后一个,返回被删除的项;
arr1.push(12,'djaiji')  //向数组的末尾添加一个或更多元素,并返回新的长度(length。
console.log(arr1);  //return  [12, 454, "dafda", "feagfag", 12, "djaiji"] 说明改变了数组的原始值。
arr1.reverse();  //颠倒数组的顺序
arr1.shift();   //与pop()相对,删除的是第一个数组元素,并返回。
arr1.slice(1,3);  //return Array 选取下标内的数组元素组合成数组,并返回。
arr1.sort();  //数组按照string类型的排序调整顺序。
//    arr1.splice(index要添加的位置,应该删除多少元素,要添加到数组的新元素)   //数组的增、删、改
//    前面两个参数’必需的‘
arr2.splice(1,0,'ddddddd',45454);   //return  被删除的项组成的数组。
console.log(arr2);
arr2.toString(); //将数组转为字符串,用逗号隔开。
arr2.unshift('234');  //可向数组的开头添加一个或更多元素,返回数组的length
arr2.valueOf();
arr2.concat(arr1);  //合并数组。
arr2.constructor;   //return   function Array() { [native code] }返回构造函数
arr2.prototype.tostring = function(){   //重写了toString方法
    alert(1)
}

 完整篇:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>array操作</title>
</head>
<body>
    <script src="http://libs.baidu.com/jquery/1.8.3/jquery.min.js"></script>
    <script type="text/javascript">
        var arr = ['red',false,1,5,9,3,6,'blue','green',true,false,5,0,2,5,2];
        //array1.concat(array2,array3,...,arrayX)  该方法不会改变现有的数组,而仅仅会返回被连接数组的一个副本。
        //返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组,那么添加的是数组中的元素,而不是数组。
        //通过concat复制数组
        var arrConcat = arr.concat([]);
        console.log(arrConcat);   //["red", false, 1, 5, 9, 3, 6, "blue", "green", true, false, 5, 0, 2, 5, 2]
        arrConcat.push('新增1','新增2');
        console.log(arrConcat);
        //["red", false, 1, 5, 9, 3, 6, "blue", "green", true, false, 5, 0, 2, 5, 2, "新增1", "新增2"]
        console.log(arr); //["red", false, 1, 5, 9, 3, 6, "blue", "green", true, false, 5, 0, 2, 5, 2]

        //array.every(function(currentValue,index,arr), thisValue)   IE8及以下不支持  返回一个boolean值。接受一个函数参数。类似与sort方法。但是此参数是必须的。不能没有。
        //every() 方法用于检测数组所有元素是否都符合指定条件(通过函数提供)。
        // every() 方法使用指定函数检测数组中的所有元素:
        // 如果数组中检测到有一个元素不满足,则整个表达式返回 false ,且剩余的元素不会再进行检测。
        // 如果所有元素都满足条件,则返回 true。
        // 注意: every() 不会对空数组进行检测。
        // 注意: every() 不会改变原始数组。
        function checkArr(arr){
            return arr>2;
        }
        var boolean1 = arr.every(checkArr);
        console.log(boolean1);   //false

        //array.filter(function(currentValue,index,arr), thisValue)   IE8及一下不支持  返回值为一个符合条件的所有元素的新的数组。如果没有匹配的则返回空数字。
        //filter() 不会对空数组进行检测。
        //filter() 不会改变原始数组。
        var arrFilter = arr.filter(checkArr);
        console.log(arrFilter);   //[5, 9, 3, 6, 5, 5]

        //array.indexOf(item,start)   返回指定项在数组中首次出现的位置。返回一个Number值,如果没有搜索到则返回-1。
        //start:可选,从第几项开始查找
        //array.lastIndexOf(item,start)  返回指定项在数组中最后一次出现的位置。
        var numindexOf = arr.indexOf(true,4);
        console.log(numindexOf);   //9
        var numlastIndexOf = arr.lastIndexOf(2);
        console.log(numlastIndexOf);   //15

        //array.map(function(currentValue,index,arr), thisValue)  不改变原始值
        //IE8及以下不支持
        //返回一个新数组,数组中的元素为原始数组元素调用函数处理后的值。
        //map() 方法按照原始数组元素顺序依次处理元素。
        function arrmap(item){
            return item+10;
        }
        var _arrMap = arr.map(arrmap);
        console.log(_arrMap);//["red10", 10, 11, 15, 19, 13, 16, "blue10", "green10", 11, 10, 15, 10, 12, 15, 12]

        // array.pop()  只能移除最后一个元素,不接受参数。返回删除的项。
        //pop() 方法用于删除数组的最后一个元素并返回删除的元素。
        //注意:此方法改变数组的长度!
        //return 所有类型*
        var arrpop = arr.pop();
        console.log(arr); //["red", false, 1, 5, 9, 3, 6, "blue", "green", true, false, 5, 0, 2, 5]
        console.log(arrpop);  //2

        //array.push(item1, item2, ..., itemX)
        //向数组的后面推入项。改变原始数组。
        // return number   新数组的长度
        var arrpush = arr.push('新增push1','新增push2');
        console.log(arr);
        //["red", false, 1, 5, 9, 3, 6, "blue", "green", true, false, 5, 0, 2, 5, "新增push1", "新增push2"]
        console.log(arrpush);        //17
        //array.reverse()颠倒数组的顺序
        //return 颠倒后的数组,即会改变原来的数组
        arr.reverse();
        console.log(arr);
        //["新增push2", "新增push1", 5, 2, 0, 5, false, true, "green", "blue", 6, 3, 9, 5, 1, false, "red"]

        //array.shift()  改变原来的数组   不接收参数,一次只能删除一个
        //shift() 方法用于把数组的第一个元素从其中删除,并返回第一个元素的值。
        //return 数组原来的第一个元素的值(移除的元素)
        var arrShift = arr.shift();
        console.log(arrShift);  //'新增push2'
        console.log(arr); //["新增push1", 5, 2, 0, 5, false, true, "green", "blue", 6, 3, 9, 5, 1, false, "red"]

        //array.unshift(item1,item2, ..., itemX) 接收N个参数
        //向数组的开头添加一个或更多元素。
        //return 新的长度
        var numUnshift = arr.unshift('新增unshift1','新增unshift2');
        console.log(numUnshift);  //18
        console.log(arr);
        //["新增unshift1", "新增unshift2", "新增push1", 5, 2, 0, 5, false, true, "green", "blue", 6, 3, 9, 5, 1, false, "red"]

        //slice(start,end) 至少接收一个参数,如果不写第二个参数的话,就是截取到末尾。
        //return array 新的截取的数组, 不改变原来的数组
        var arrSlice = arr.slice(4,10);
        console.log(arr);
//["新增unshift1", "新增unshift2", "新增push1", 5, 2, 0, 5, false, true, "green", "blue", 6, 3, 9, 5, 1, false, "red"]
        console.log(arrSlice);
        //[2, 0, 5, false, true, "green"]

        //array.some(function(currentValue,index,arr),thisValue)
        //some() 方法用于检测数组中的元素是否满足指定条件(函数提供)。
        // some() 方法会依次执行数组的每个元素:
        // 如果有一个元素满足条件,则表达式返回true , 剩余的元素不会再执行检测。
        // 如果没有满足条件的元素,则返回false。
        // 注意: some() 不会对空数组进行检测。
        // 注意: some() 不会改变原始数组。
        //return 布尔值。如果数组中有元素满足条件返回 true,否则返回 false。
        var blnSome = arr.some(checkArr);
        console.log(blnSome);  //true

        //array.sort(sortfunction)   !!!!!!这种方法会改变原始数组!!!!!!!
        //sort() 方法用于对数组的元素进行排序。
        // 排序顺序可以是字母或数字,并按升序或降序。
        // 默认排序顺序为按字母升序。
        // 注意:当数字是按字母顺序排列时"40"将排在"5"前面。
        // 使用数字排序,你必须通过一个函数作为参数来调用。
        // 函数指定数字是按照升序还是降序排列。
        // return 原来的数组
        var arrsort = [10,4,5,20,16,50];
        console.log(arrsort);  //[10, 4, 5, 20, 16, 50]
        arrsort.sort(function(val1,val2){
            return val1-val2;
        });
        console.log(arrsort);  //[4, 5, 10, 16, 20, 50]

        //array.splice(index,howmany,item1,.....,itemX)  这种方法会改变原始数组!
        //index:从什么位置开始添加删除替换
        //howmany:删除多少个项目
        //item:需要添加的项
        //return 如果从 arrayObject 中删除了元素,则返回的是含有被删除的元素的数组。
        var arrsplice = arr.splice(2,10,'新增splice');
        console.log(arr);   //["新增unshift1", "新增unshift2", "新增splice", 3, 9, 5, 1, false, "red"]
        console.log(arrsplice); //"新增push1", 5, 2, 0, 5, false, true, "green", "blue", 6]

        //array.toString()  不改变原来的数组
        //return String  数组的所有值用逗号隔开
        var strString = arr.toString();
        console.log(arr);  //["新增unshift1", "新增unshift2", "新增splice", 3, 9, 5, 1, false, "red"]
        console.log(strString);  //"新增unshift1,新增unshift2,新增splice,3,9,5,1,false,red"

        // array.valueOf()
        // valueOf() 方法返回 Array 对象的原始值。
        // 该原始值由 Array 对象派生的所有对象继承。
        // valueOf() 方法通常由 JavaScript 在后台自动调用,并不显式地出现在代码中。
        // 注意: valueOf() 方法不会改变原数组。
        // return Array    valueOf() 返回数组值
        var arrValueOf = arr.valueOf();
        console.log(arrValueOf);  //["新增unshift1", "新增unshift2", "新增splice", 3, 9, 5, 1, false, "red"]
        console.log(arr); //["新增unshift1", "新增unshift2", "新增splice", 3, 9, 5, 1, false, "red"]


        //扩展Array方法
        $.extend(Array.prototype, function() {
            /**
             * @description 查找某一obj在array中的位置
             */

            function indexOf(obj) {
                var result = -1,
                    length = this.length,
                    i = length - 1;
                for (; i >= 0; i--) {
                    if (this[i] == obj) {
                        result = i;
                        // 如果已找到,则跳出循环
                        break
                    }
                }
                return result
            }

            /**
             * @description 判断数组中是否存在obj
             */

            function contains(obj) {
                return this.indexOf(obj) >= 0
            }

            /**
             * @description 数组末尾添加数组中没有的元素obj
             */

            function append(obj) {
                if (!this.contains(obj)) {
                    this[this.length] = obj
                }
            }

            /**
             * @description 在数组中移除obj
             */

            function remove(obj) {
                var index = this.indexOf(obj);
                return index >= 0 ? this.splice(index, 1) : false;
            }

            /**
             * @description 对Array的每一个元素运行一个函数。
             * @method each
             * @param arr(this) 待处理的数组.
             * @param callback 需要执行的函数,该执行函数可传入两个参数,第一个代表当前对象,第二个为当前对象在数组中的索引
             * @return {void}
             * @example var a = [8,2,3]; a.each(function(o,i){console.log(o);console.info(i)});
             */

            function each(callback) {
                for (var i = 0, len = this.length; i < len; i++) {
                    if (i in this) {
                        callback.call(this, this[i], i);
                    }
                }
            }

            /**
             * @description 从一个数组中取出n个不同的值
             * @param {Array} arr 原始数组
             * @param {Number} 需取出的个数
             * @return {Array} 返回数组中n个不同的随机值组成的数组
             * @example var aaa = ['a', 'b', 'e', 'fs','we']; aaa.randArray(3);
             */

            function randArray(n) {
                var leng = this.length;
                //如果arr中总数量小于等于想取出的数量,直接返回arr
                if (leng <= n) {
                    return this;
                } else {
                    var randArr = [],
                        str = ',';
                    //从0开始,共执行n次
                    while (randArr.length < n) {
                        var rand = FS.getRandom(0, leng - 1);
                        //如果这个随机数没有被取过,将该随机数添加到data数组中,跳出这层循环
                        while (str.indexOf(',' + rand) === -1) {
                            str += rand + ',';
                            randArr.push(this[rand]);
                            break;
                        }
                    }
                    return randArr;
                }
            }

            /**
             * @description 数组去重
             * @return {Array} [description]
             * @example [1, 2, 3, 4, 5, true , false, "a", "bbb", 0, "", 0, 3, 4, 5, 6, 7, true, false, "a", " ", "3", "5", "7"].unique()
             */
            function unique() {
                var _this = this;
                // 先让数组排序
                var _sortArr = _this.sort();

                // 逐个比较左右数据,把重复的删掉
                for (var i = _sortArr.length - 1; i >= 0; i--) {
                    if (_sortArr[i] === _sortArr[i - 1]) {
                        _sortArr.splice(i, 1);
                    }
                }

                // 返回新数组
                return _sortArr;
            }

            return {
                indexOf: indexOf,
                contains: contains,
                append: append,
                remove: remove,
                each: each,
                randArray: randArray,
                unique: unique
            }
        }());
    </script>
</body>
</html>
原文地址:https://www.cnblogs.com/qianduanjingying/p/5129441.html