专栏首页大前端_Webjs Array 数组相关的方法

js Array 数组相关的方法

版权声明:本文为吴孔云博客原创文章,转载请注明出处并带上链接,谢谢。 https://blog.csdn.net/wkyseo/article/details/51274550

判断数组中是否有相同的元素

第一种方法

     function isRepeat(arrs) {
        if(arrs.length > 0) {
            var sArrs = arrs.sort();
            for(var i = 0,ilen = sArrs .length; i < ilen; i+=1) {
                if(sArrs [i] == sArrs [i+1]) {
                    return true;
                }
            }
        }
        return false;
     }
    var arrs = [1,2,3];
    console.log(isRepeat(arrs)); // false
    arrs.push(2)//4
    console.log(isRepeat(arrs)); // true

第二种方法

    /*
     * 逻辑思路:定义一个对象 遍历数组,判断该对象的键有没有,有的话返回true,否则返回false
     */
    function isRepeat(arrs) {
        var has = {};
        if(arrs.length > 0) {
            for(var i = 0, len = arrs.length; i < len ; i=i+1) {
                if(has[arrs[i]]){//利用数组元素值作为对象下标
                    return true;
                }
                has[arrs[i]] = true;
            }
        }
        return false;
    }
    var arrs = ['a','b','c','d'];
    isRepeat(arrs)//false
    arrs.push('a')//5
    isRepeat(arrs)//true

计算一个数组中每个元素在数组中出现的次数

    function arrayElemCount(arrs) {
        var newArrs = [];
         if(arrs.length > 0) {
            for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {
                var temp = arrs[i];
                var count = 0;
                for(var j = 0,jlen = arrs.length; j < jlen; j+=1) {
                    if(arrs[j] == temp) {
                        count++;
                        arrs[j] = -1;//判断再赋值
                     }
                }
                newArrs.push(temp + ":" +count);
            }
         }
         return newArrs;
    }
    var arrs = [1,2,1,2,3,4,5,6,7,1,2,3];
    console.log(arrayElemCount(arrs)); 
    // 打印如下:["1:3", "2:3", "-1:6", "-1:6", "3:2", "4:1", "5:1", "6:1", "7:1", "-1:12", "-1:12", "-1:12"]
    // 键值为-1的,都可以去掉

第二种类似方法

    function arrayElemCount(arrs) {
        if(arrs.length > 0){
            for(var i = 0, len = arrs.length; i < len ; i=i+1) {
                var count = 0;
                var a = arrs[i];
                for(var j = 0;j < len;j++){
                    if(arrs[j] == a ){
                        count++;
                    }
                }
                var as = true;
                for(var k = 0;k < i;k++ ){
                    if(arrs[k]==arrs[i]){
                      as = false;
                    }
                }
                if(as){
                    console.log(arrs[i]+':'+count)
                }
            }
        }
    }
    var arrs = [1,2,1,2,3,4,5,6,7,1,2,3];
    arrayElemCount(arrs);//做一个条件赋值判断,为false不打印出来

删除数组重复元素的操作

使用indexOf方法

    /* 重复项 indexOf方法在IE8及IE8以下不支持,因此有必要封装一个
     * @return {newArrays} 返回新数组
     */
    function arrayUnique(arrs) {
        var newArrays = [];
        for(var i = 0,ilen = arrs.length; i < ilen; i++) {
            if(newArrays.indexOf) {
                if(newArrays.indexOf(arrs[i]) == -1) {
                    newArrays.push(arrs[i]);
                }
            }else {
                if(indexOf(arrs[i],newArrays) == -1) {
                    newArrays.push(arrs[i]);
                }
            }

        }
        return newArrays;
    }
    /*
     * 为了支持IE8及以下浏览器需要封装一个indexOf方法
     * @param {arr,arrs} 某一项 原数组
     * @return 返回数组某一项
     */
     function indexOf(arr,arrs){
        if(arrs.length > 0) {
            for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {
                if(arrs[i] == arr) {
                    return i;
                }
            }
        }
        return -1;
     }
    var arrs = [1,2,3,1,2,3];
    console.log(arrayUnique(arrs)); // [1,2,3]

    //数组下标判断法
    function arrayUnique(arrs) {
        var newArrays = [];
        if(arrs.length > 0) {
            for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {
                if(arrs.indexOf) {
                    if(arrs.indexOf(arrs[i]) == i) {
                        newArrays.push(arrs[i]);
                    }
                }else {
                    if(indexOf(arrs[i],arrs) == i) {
                        newArrays.push(arrs[i]);
                    }
                }

            }
        }
        return newArrays;
    }

    //数组排序对比法、循环对比新数组
        function arrayUnique(arrs) {
        var newArrays = [];
        if(arrs.length > 0) {
            arrs.sort();
            for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {
                //此处是跟newArrays的数组对比
                if(arrs[i] !== newArrays[newArrays.length - 1]) {
                    newArrays.push(arrs[i]);
                }
            }
        }
        return newArrays;
    }
    //对象键值对法
    function arrayUnique(arrs) {
        var newArrays = [];
        var hash = {};
        if(arrs.length > 0) {
            for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {
                if(!hash[arrs[i]]) {
                    hash[arrs[i]] = 1;
                    newArrays.push(arrs[i]);
                }
            }
        }
        console.log('hash'+hash);
        return newArrays;

    }

求出2个数组的相同元素及不同元素,函数返回值可以是对象

    function getArrsSameAndDiffElem(arrs1,arrs2){
        var hash = {},
            sameElemArrs = [],
            diffElemArrs = [];
        if(arrs1.length > 0) {
            for(var i = 0,ilen = arrs1.length; i < ilen;i+=1) {
                hash[arrs1[i]] = 1;
            }
        }
        if(arrs2.length > 0) {
            for(var j = 0,jlen = arrs2.length; j < jlen; j+=1) {
                if(hash[arrs2[j]]) {
                // 说明有相同的元素,把相同的元素存入sameElemArrs数组里面去
                    sameElemArrs.push(arrs2[j]);
                }else {
                // 说明是不同的元素,把不同的元素存入diffElemArrs数组里面去
                    diffElemArrs.push(arrs2[j]);
                }
            }
        }
        return {
            sameElemArrs: sameElemArrs,
            diffElemArrs: diffElemArrs
        }
    }
     var arrs1 = ["aac","aab","cfg",'longen','tugenhua','single'];
     var arrs2 = ["aac","mnc","nba","cba","anta",'tugenhua','single'];
     console.log(getArrsSameAndDiffElem(arrs1,arrs2));

Array.prototype.slice.call(arguments); 即可将类数组转换为数组||[].slice.call(arguments)

JS二维数组排序组合

var arr = [["wu", "xia"], ["kong", "tao"], ["yun", "ou"]];
//不确定长度数组,使用递归
function doExchange(doublearrays) {

    var len = doublearrays.length;
    if(len >= 2) {
        var arr1 = doublearrays[0],
            arr2 = doublearrays[1];

        var len1 = arr1.length, 
            len2 = arr2.length;

        var index = 0;
        var totalLen = len1 * len2;
        var newArray = new Array(totalLen);

        for(var i=0; i<len1; i++) {
            for(var j=0; j<len2; j++) {
                newArray[index] = arr1[i] + arr2[j];
                index ++ ;
            }
        }

        var tempArr = [];
        tempArr[0] = newArray;
        for(var k=2; k<len; k++) {
            tempArr[k-1] = doublearrays[k];
        }

        return doExchange(tempArr);

    }else {
        return doublearrays[0];
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • ECMAScript 6笔记(let,const 和 变量的解构赋值)

    版权声明:本文为吴孔云博客原创文章,转载请注明出处并带上链接,谢谢。 https://blog.csdn.net/wkyseo/articl...

    空空云
  • easyUI组件datagrid的二次封装

    版权声明:本文为吴孔云博客原创文章,转载请注明出处并带上链接,谢谢。 https://blog.csdn.net/wkyseo/articl...

    空空云
  • JS自定义事件原生

    空空云
  • iOS 点击通知打开对应页面

    这时如果点击通知的显示按钮,会调用didFinishLaunchingWithOptions,不会调用didReceiveRemoteNotification方...

    剑行者
  • JS ES各版本特性

    JS包含三个部分:ECMAScript(核心),DOM(文档对象模型),BOM(浏览器对象模型)。ECMAScript是JS语言的基础。 ECMAScript的...

    剑行者
  • JavaScript基本类型与引用类型(二)

    前文已经对基本类型和引用类型作了简单的介绍,本文将进一步介绍基本类型和引用类型。 基本包装类型   为了方便操作基本类型的值,JavaScript提供了特殊的引...

    水击三千
  • js前端日期格式化处理

    Dream城堡
  • JavaScript第六节

    数组:是有序的元素集合 ,数组用于存放一组有序的数据,比如一个班级所有人的名字,一个班级所有人的成绩。

    用户3461357
  • ES6新特性概览

    前言 ECMAScript 6(以下简称ES6)是JavaScript语言的下一代标准,已经在2015年6月正式发布了。它的目标,是使得JavaScript语言...

    laixiangran
  • Prometheus学习之安装

    Prometheus,一个开源的监控系统,它通过获取应用程序中实时时间序列数据,然后根据强大的规则引擎,帮助用户监控机器和应用程序。

    kongxx

扫码关注云+社区

领取腾讯云代金券