精华内容
下载资源
问答
  • // 思路:1,判断两个对象的地址是否相等。2,判断两个对象的键的个数是否相等。3,判断每个键对应的值是否相等。 function isObjectValueEqual(a, b) { // 1,判断两个对象的引用地址是否相等 if (a === b) ...
    // 思路:1,判断两个对象的地址是否相等。2,判断两个对象的键的个数是否相等。3,判断每个键对应的值是否相等。
    
    function isObjectValueEqual(a, b) {
            // 1,判断两个对象的引用地址是否相等
            if (a === b) return true;
            // 2,判断两个对象的键的个数是否相等
            let aProps = Object.getOwnPropertyNames(a);
            let bProps = Object.getOwnPropertyNames(b);
            if (aProps.length !== bProps.length) return false;
    
            //3,判断每个键对应的值是否相等
            for (const k in a) {
              if (b.hasOwnProperty(k)) {
                if(typeof a[k] === 'object'){
                  // 递归
                  if(!isObjectValueEqual(a[k], b[k])) return false
                }else {
                  if(a[k] !== b[k]) return false
                }
              } else {
                return false;
              }
            }
            return true
          }
    
          let element1 = { name: "jacky", age: 18, attribute: { width: 100 } ,list: [1,2,3] };
          let element2 = { name: "jacky", age: 18, attribute: { width: 100 } ,list: [1,2,3] };
          let result = isObjectValueEqual(element1, element2);
          console.log("result", result); //true
    
    展开全文
  • 本来只打算写一个判断数组的方法,结果发现数组里可能有对象,还得判断两个对象是否相等,然而对象里面也有可能有数组,所以两个方法相辅相成,缺一不可(aa:判断数组,bb:判断对象,本人英语水平有限就不用单词了...

    本来只打算写一个判断数组的方法,结果发现数组里可能有对象,还得判断两个对象是否相等,然而对象里面也有可能有数组,所以两个方法相辅相成,缺一不可(aa:判断数组,bb:判断对象,本人英语水平有限就不用单词了。另外这里的对比不考虑对象或者数组里面含有function的情况。欢迎指正)    

     function myTypeOf(obj) { // 判断数据类型

                return Object.prototype.toString.call(obj)

            }

            function bb(obj1, obj2) { // 判断两个对象每一项的值是否相等

                var res = true

                // debugger

                for (var key in obj1) {

                    var cur = obj1[key]

                    var type = myTypeOf(cur)

                    if (type !== myTypeOf(obj2[key])) {

                        return false

                    }

                    if (type.indexOf('Object') > -1) {

                        for (var k in cur) {

                            res = bb(cur[k], obj2[k])

                            if (res === false) {

                                return false

                            }

                        }

                    } else if (type.indexOf('Array') > -1) {

                        res = aa(cur, obj2[key])

                        if (res === false) {

                            return false

                        }

                    } else {

                        if (cur !== obj2[key]) {

                            return false

                        }

                    }

                }

                return res

            }

            function aa(arr1, arr2) { // 判断两个数组每一项的值是否相等

                var res = true

                // debugger

                if (arr1.length !== arr2.length) {

                    return false

                }

                for (var i = 0; i < arr1.length; i++) {

                    var cur = arr1[i]

                    var type = myTypeOf(cur)

                    if (type !== myTypeOf(arr2[i])) {

                        return false

                    }

                    if (type.indexOf('Object') > -1) {

                        res = bb(cur, arr2[i])

                        if (res === false) {

                            return false

                        }

                    } else if (type.indexOf('Array') > -1) {

                        res = aa(cur, arr2[i])

                        if (res === false) {

                            return false

                        }

                    } else {

                        if (cur !== arr2[i]) {

                            return false

                        }

                    }

                }

                return res

            }

     

            var arr = [1, { a: 1, b: 2 }, 1, [{ a: 1, b: '2', c: true, d: { a: 1, b: 2 } }]]

     

            var arr2 = [1, { b: 2, a: 1 }, [{ a: 1, b: '2', c: true, d: { a: 1, b: 2 } }], 1]

            console.log(aa(arr,arr2))

    展开全文
  • Java 判断两个对象是否相等 一、使用 == 与 equals ==: 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不是同一个对象。(基本数据类型==比较的是值,引用数据类型==比较的是内存地址) equals(): 它...

    Java 判断两个对象是否相等

    一、使用 == 与 equals

    == : 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不是同一个对象。(基本数据类型==比较的是值,引用数据类型==比较的是内存地址)

    equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况:

    • 情况1:类没有覆盖equals()方法。则通过equals()比较该类的两个对象时,等价于通过“==”比较这两个对象。
    • 情况2:类覆盖了equals()方法。一般,我们都覆盖equals()方法来两个对象的内容相等;若它们的内容相等,则返回true (即,认为这两个对象相等)。

    举个例子:

    复制代码

    public class test1 {
        public static void main(String[] args) {
            String a = new String("ab"); // a 为一个引用
            String b = new String("ab"); // b为另一个引用,对象的内容一样
            String aa = "ab"; // 放在常量池中
            String bb = "ab"; // 从常量池中查找
            if (aa == bb) // true
                System.out.println("aa==bb");
            if (a == b) // false,非同一对象
                System.out.println("a==b");
            if (a.equals(b)) // true
                System.out.println("aEQb");
            if (42 == 42.0) { // true
                System.out.println("true");
            }
        }
    }

    复制代码

    说明:

    • String中的equals方法是被重写过的,因为object的equals方法是比较的对象的内存地址,而String的equals方法比较的是对象的值。
    • 当创建String类型的对象时,虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象,如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

    二、使用 hashCode 与 equals

    面试官可能会问你:“你重写过 hashcode 和 equals 么,为什么重写equals时必须重写hashCode方法?”

    hashCode()介绍

    hashCode() 的作用是获取哈希码,也称为散列码;它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中,这就意味着Java中的任何类都包含有hashCode() 函数。另外需要注意的是: Object 的 hashcode 方法是本地方法,也就是用 c 语言或 c++ 实现的,该方法通常用来将对象的 内存地址 转换为整数之后返回。

    按 Ctrl+C 复制代码

     

    按 Ctrl+C 复制代码

    散列表存储的是键值对(key-value),它的特点是:能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码!(可以快速找到所需要的对象)

    为什么要有hashCode

    我们以“HashSet如何检查重复”为例子来说明为什么要有hashCode:

    当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他已经加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象,这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同,HashSet就不会让其加入操作成功。如果不同的话,就会重新散列到其他位置。(摘自我的Java启蒙书《Head fist java》第二版)。这样我们就大大减少了equals的次数,相应就大大提高了执行速度。

    hashCode()与equals()的相关规定

    1. 如果两个对象相等,则hashcode一定也是相同的
    2. 两个对象相等,对两个对象分别调用equals方法都返回true
    3. 两个对象有相同的hashcode值,它们也不一定是相等的
    4. 因此,equals方法被覆盖过,则hashCode方法也必须被覆盖
    5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)

    为什么两个对象有相同的hashcode值,它们也不一定是相等的?

    以下内容摘自《Head Fisrt Java》:

    因为hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞,但这也与数据值域分布的特性有关(所谓碰撞也就是指的是不同的对象得到相同的 hashCode)。我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候,同样的 hashcode 有多个对象,它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。

    展开全文
  • //判断两个对象是否相等 'isObjectValueEqual': function (a, b) { if(!b||!a){ return false } var aProps = Object.getOwnPropertyNames(a); var bProps = Object.getOwnPropertyNames(b); ...
    //判断两个对象是否相等
    'isObjectValueEqual':  function (a, b) {
    
        if(!b||!a){
            return false
        }
        var aProps = Object.getOwnPropertyNames(a);
        var bProps = Object.getOwnPropertyNames(b);
    
    
        if (aProps.length != bProps.length) {
            return false;
        }
    
        for (var i = 0; i < aProps.length; i++) {
            var propName = aProps[i];
    
            if (a[propName] !== b[propName]) {
                return false;
            }
        }
        return true;
    },
    
    
    

     

    主要是加了判断,如果所给的值存在空或者undefined的时候,下面的语句就会报错,判断对象相等,先判断对象属性的长度是否相等,再判断每个属性的值是否相等

    展开全文
  • 如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下几个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。2、hashcode的作用及与equals的关系。 1、...
  • 如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下几个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。 2、hashcode的作用及与equals的关系。 1、...
  • js判断两个对象是否相等的办法,包含绝对相等和形状内容相等.pdf
  • 一,最简单的JSON.stringify JSON.stringify({a:1})===JSON.stringify({a:1}) //true JSON.stringify({a:1})===JSON.stringify({a:2}) //true 二,递归 这里可以参考js判断两个对象是否相等
  • Java 中判断两个对象是否相等

    千次阅读 2020-04-28 18:21:08
    嗯先铺垫一下Java中的相等问题,比较方法有equals和==,比较的方向有内容相等和对象相等。 1.equals:只能比较对象,比较对象地址是否相等;可以重写equals方法,比如String重写equals方法改为内容是否相等。 2.==:...
  • #coding=utf-8#比较两个对象是否相等#python 2中使用cmp(),==,is#is ...#== 用来判断两个对象的值是否相等(跟 Java 不同,Java 中 == 用来判断是否是同一个对象)a = 256b = 256print id(a)print id(b)print a is b...
  • 判断两个对象是否相等: var modefyFlag = false; for(var val in oldValue){ if(newValue.hasOwnProperty(val) && eval("newValue."+ val) != eval("oldValue."+ val)){
  • Object.is 方法只能判断两个对象的引用地址是否一致,但是要比对两个对象的内容是否相等时就不能用这个方法了 let obj1 = { a: 11, b: 22 } let obj2 = { a: 11111111111, b: 22222222222 } let obj3 =...
  • C#判断两个对象是否相等

    千次阅读 2015-10-08 17:43:01
    判断C#中两个对象是否相等
  • 判断两个对象是否相等的js函数

    千次阅读 2014-10-28 09:50:21
    判断两个对象是否相等的js函数 如果两个对象属性在初始化时出现的顺序不一样 但数目及值一样,最终比较结果也是true 支持每个属性又是其他类型,如对象、数组、数字、字符串  function equal(objA, ...
  • 所以在java的集合中,判断两个对象是否相等的规则是: 1,判断两个对象的hashCode是否相等 如果不相等,认为两个对象也不相等,完毕 如果相等,转入2 2,判断两个对象用equals运算是否相等 如果不相等,认为...
  • 前段时间在学习如何封装 instanceof 函数的时候无意间想到了如何判断两个对象是否相等,尝试了一下自己封装了一个isEqual函数 JS对象在内存中的存储方式 在JS中,对象是引用数据类型,变量中存储的是其在堆中的内存地址...
  • JavaScript中 如何判断两个对象是否相等? object类型作为JavaScript中的基本数据类型,也是实际前端开发中经常使用的一种数据类型。 对于数字(Number)、字符串(String)、Boolean类型等数据,判断其是否相等,...
  • python中判断两个对象是否相等

    千次阅读 2017-11-03 13:35:00
    #coding=utf-8#比较两个对象是否相等#python 2中使用cmp(),==,is#is ...#== 用来判断两个对象的值是否相等(跟 Java 不同,Java 中 == 用来判断是否是同一个对象)a = 256b = 256print id(a)print id(b)print a is b...
  • 前言:如何判断两个对象是否相等? 两个Object类型对象,即使拥有相同属性、相同值,当使用 == 或 === 进行比较时,也不认为他们相等。这就是因为他们是通过引用(内存里的位置)比较的,不像基本类型是通过值比较...
  • 判断两个对象object1和object2相等用equals()方法,若该方法返回true,则表明这两个对象相等。但是当在比较大的集合中找出相等的对象用equals()方法比较消耗性能。 所以: 1、如果object1==object2,则说明这两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 686,526
精华内容 274,610
关键字:

判断两个对象是否相等