JS里去除数组中的重复值

如果你把测试数组简化为 [1, 2, "2", 2, 3]，然后在每一步使用 consolelog 输出，看得就清楚了

函数中使用 typeof 是为了区别 2 和 “2”（number 和 string）

Arrayprototypedel = function() {

    var a = {}, c = [], l = thislength;

    for (var i = 0; i < l; i++) {

        var b = this[i];

        // for 循环第 1 次：1

        // for 循环第 2 次：2

        // for 循环第 3 次："2"

        // for 循环第 4 次：2

        // for 循环第 5 次：3

        consolelog(b);

    

        var d = (typeof b) + b;

    

        // for 循环第 1 次：number1

        // for 循环第 2 次：number2   <--- 重复

        // for 循环第 3 次：string2

        // for 循环第 4 次：number2   <--- 重复

        // for 循环第 5 次：number3

        consolelog(d);

    

        // for 循环第 1 次：number1 为 undefined

        // for 循环第 2 次：number2 为 undefined

        // for 循环第 3 次：string2 为 undefined

        // for 循环第 4 次：注意 {} 中已经有了 number2，所以不为 undefined

        // for 循环第 5 次：number3 为 undefined

        consolelog(a[d]);

    

        // a[d] 代表将 d 设为 a 的属性，例如 a = {number2}，但没有值

        if (a[d] === undefined) {

            // 1, 2, "2", 3 被 push

            cpush(b);

    

            // 这里 = 1 只是给此属性一个值，例如 a = {number2: 1}

            a[d] = 1;

    

            // for 循环第 1 次：{number1=1}

            // for 循环第 2 次：{number1=1, number2=1}

            // for 循环第 3 次：{number1=1, number2=1, string2=1}

            // for 循环第 4 次：因为 number2 存在，此次被忽略

            // for 循环第 5 次：

            //      {number1=1, number2=1, string2=1, number3=1}

            consolelog(a);

        }

    }

    return c;

}

    

alert([1, 2, "2", 2, 3]del());

let numArr = [1, 1, 2, 3, 4, 5, 6, 7, 7, 7, 8]

let tempObj = {}

let result = []

numArrmap(i => {

if (!tempObj[i]) {

tempObj[i] = i

resultpush(i)

}

})

consolelog(result)

原生js的数组是不包含去重函数的。

可以自己编写去重函数。

下面是一个简单的例子

$arrayextend({

    unique : function (fn) {

        var len = thislength,

            result = thisslice(0),

            i, datum;

             

        if ('function' != typeof fn) {

            fn = function (item1, item2) {

                return item1 === item2;

            };

        }

        

        while (--len > 0) {

            datum = result[len];

            i = len;

            while (i--) {

                if (fn(datum, result[i])) {

                    resultsplice(len, 1);

                    break;

                }

            }

        }

 

        len = thislength = resultlength;

        for ( i=0; i<len; i++ ) {

            this[ i ] = result[ i ];

        }

 

        return this;

    }

});

JS判断一个数组中是否有重复值的三种方法

方法一:

//将数组转换成字符串，遍历数组，移除一个元素後若还能找到该元素，那么这个元素就是重复的var s = aryjoin(",")+",";for(var i=0;i<arylength;i++) { if(sreplace(ary[i]+",","")indexOf(ary[i]+",")>-1) { alert("数组中有重复元素：" + ary[i]); break; }}

方法二:

//对数组进行排序，查上一个和下一个是否相等

var ary = new Array("111","22","33","111");var nary=arysort();for(var i=0;i<arylength;i++){ if (nary[i]==nary[i+1]){ alert("数组重复内容："+nary[i]); }}

方法三:

//以数组值为键，持续向一个对象里面加值，

//如果在加值之前就发现这个属性在对象中已经存在，那么他就是重复的

function isRepeat(arr){ var hash = {}; for(var i in arr) { if(hash[arr[i]]) return true; hash[arr[i]] = true; } return false;}

以上是简单类型数据数组的重复校验方法，若数组的元素为对象，处理方式就需要变化一下，取关键属性作为依据

var c = aconcat(b),//合并成一个数组

temp = {},//用于id判断重复

result = [];//最后的新数组

//遍历c数组，将每个itemid在temp中是否存在值做判断，如不存在则对应的item赋值给新数组，并将temp中itemid对应的key赋值，下次对相同值做判断时便不会走此分支，达到判断重复值的目的；

cmap((item,index)=>{

if(!temp[itemid]){

resultpush(item);

temp[itemid] = true

}

})

consolelog(result)

数组去重，就是在数组中查找相同的元素，保留其中一个，去除其他元素的程。

从这句话揭示了数组去重的两个关键因素：

找到重复项

去除重复项

本文告诉你在遇到去重问题时该如何思考，并以 JavaScript 为例，进行详细解释。使用 JavaScript 示例主要是因为它环境比较好找，而且直接对象 (Plain Object) 用起来很方便。

JavaScript 的环境：Nodejs 或者浏览器的开发者控制台。

找到重复项

找到重复项最关键的算法是判定元素是否相同。判定相同，说起来似乎很简单 —— 用比较运算符就好了嘛！真的这么简单吗？

用 JavaScript 来举个例：

const a = { v: 10 };

const b = { v: 10 };

肉眼观察，这里的a和b相同吧？但是 JavaScript 不这么认为：

consolelog(a == b); // false

consolelog(a === b); // false

肉眼观察和程序比较使用了不同的判断方法。肉眼观察很直接的采用了字符串比对的方法，而程序压根没管是不是数据相同，只是直接判断它们是不是同一个对象的引用。我们一般会更倾向于使用符合人眼直观判断的方法，所以可能会想到使用JSONstringify()把对象变成字符串来判断：

consolelog(JSONstringify(a) === JSONstringify(b)); // true

现在如果我们把a和b略作改变，又该如何？

const a = { v: 10, n: "1" };

const b = { n: "1", v: 10 };

乍一看，a和b不同。用JSONstringify()的结果来比对，也确实不同。但是仔细一看，他们的属性是完全相同的，唯一的区别在于属性的顺序不一样。那么到底顺序应不应该作为一个判断相同的依据呢？

这个问题现在真没法回答。“该如何”取决于我们的目标，也就是业务需求。

从上面的例子我们可以了解：判断相同并不是一个简单的事情，根据不同的业务要求，需要选择不同的判断方法；而不同的判断方法，可能产生不同的判断结果。

接下来先讲讲常见的判断方法。

最直接的：比较运算符

比较运算符主要用于比较基本类型的值，比如字符串、数、布尔等。

普通比较运算符 (==) 在比较不同类型的值时，会先把它们转换为相同类型再来比较；而严格比较运算符 (===) 则更为严格，会直接将类型不同值判定为不同。这些都是基本的 JavaScript 语法知识。现代开发中为了能更好的利用工具，除极少数特殊情况外，都应该使用===来进行判断。尤其是在 TypeScript 中，几乎都不会出现==了。

JavaScript 中，比较运算符不会比较对象属性，只会比较对象的引用是否相同。如果要比较对象具体信息，需要用到接下来讲到的方法。

从i=0开始循环

看s[i]有没有被取到过

如果没取到tmp就增加一个元素s[i]

o[s[i]]就是用来判断s[i]有没有出现过

所以取到一次后就把o[s[i]]

设成1

以上就是关于JS里去除数组中的重复值全部的内容，包括:JS里去除数组中的重复值、js定义一个数组存放number类型然后把数组重复的数字去掉、JavaScript数组中包含数组如何去重等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！