zoukankan      html  css  js  c++  java
  • 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>
  • 相关阅读:
    [Luogu P2563]质数和分解
    数据处理、降维--线性判别分析(linear discriminant analysis LDA)
    endnote导入参考文献及国标(Chinese standard)
    朴素贝叶斯分类器
    R语言--apply家族
    R语言--解决4*x+y之奇技淫巧、重复数字去重
    R语言中级--自定义方程
    R语言--一整套数据处理流程及简单的控制流
    R语言图形初阶
    R基础、进阶-矩阵数据框的操作
  • 原文地址:https://www.cnblogs.com/qianduanjingying/p/5129441.html
Copyright © 2011-2022 走看看