精华内容
下载资源
问答
  • 本文实例讲述了JS判断两个对象内容是否相等的方法。分享给大家供大家参考,具体如下: 我们知道,如果两个对象即使内容,JavaScript也会判断它们不相等。但是有时候,我们仅仅需要判断两个对象的内容是否相等。那么...
  • // 判断是否为obj对象 function isObj(object) { return object && typeof(object) == 'object' && Object.prototype.toString.call(object).toLowerCase() == "[object object]"; } // 判断是否...
    1、工具函数
    // 判断是否为obj对象
    function isObj(object) {
        return object && typeof(object) == 'object' && Object.prototype.toString.call(object).toLowerCase() == "[object object]";
    }
    // 判断是否为数组对象
    function isArray(object) {
        return object && typeof(object) == 'object' && object.constructor == Array;
    }
    //获取obj对象的长度
    function getLength(object) {
        var count = 0;
        for(var i in object) count++;
        return count;
    }

    2、比较主函数

    function Compare(objA, objB) {
        if(!isObj(objA) || !isObj(objB)) return false; //判断类型是否正确
        if(getLength(objA) != getLength(objB)) return false; //判断长度是否一致
        return CompareObj(objA, objB, true); //默认为true
    }
    
    function CompareObj(objA, objB, flag) {
        for(var key in objA) {
            if(!flag) //跳出整个循环
                break;
            if(!objB.hasOwnProperty(key)) {
                console.log("hasOwnProperty..........");
                flag = false;
                break;
            }
            if(isArray(objA[key])) { //子级是数组时,
                console.log("array..........");
                if(!isArray(objB[key])) {
                    console.log("B not array..........");
                    flag = false;
                    break;
                }
                var oA = objA[key],
                    oB = objB[key];
                if(oA.length != oB.length) {
                    console.log("A and B array.length not eq..........");
                    flag = false;
                    break;
                }
                for(var k in oA) {
                    if(!flag) //这里跳出循环是为了不让递归继续
                        break;
                    flag = CompareObj(oA[k], oB[k], flag);
                }
    
            }
            else if(isObj(objA[key])){//子级是obj时,
                if(!isObj(objB[key])){
                    flag= false;
                    break;
                };
                if(getLength(objA[key]) != getLength(objB[key]))
                    flag  = false; //判断长度是否一致
                if(!flag) //这里跳出循环是为了不让递归继续
                    break;
                flag = CompareObj(objA[key], objB[key], true); //默认为true
    
    
            }
            else {//子级既不是array,也不是obj,即子级时字符串或者数字
                if(objB[key] != objA[key]) {
                    console.log("not array...value.......",objB[key],objA[key]);
                    flag = false;
                    break;
                };
            }
        }
        return flag;
    }
    

    3、测试环节

    var jsonObjA = {
        "Name": "MyName",
        "Company": "MyCompany",
        "Infos": [
            {
            "Age": "100"
            },
            {
                "Box": [{
                    "Height": "100"
                },
                    {
                        "Weight": "200"
                    }
                ]
            }
        ],
        "Address": "马栏山",
         "obj":{
            "a":5566,
         }
    }
    var jsonObjB = {
        "Name": "MyName",
        "Company": "MyCompany",
        "Infos": [
            {
            "Age": "100"
        },
            {
                "Box": [{
                    "Height": "100"
                },
                    {
                        "Weight": "200"
                    }
                ]
            }
        ],
        "Address": "马栏山",
        "obj":{
            "a":5566,
        }
    }
    var result = Compare(jsonObjA, jsonObjB);
    console.log(result); // true or false

     

    展开全文
  • 主要介绍了JS中如何比较两个Json对象是否相等实例代码的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了C#使用Equals()方法比较两个对象是否相等的方法,涉及C#操作对象的相关技巧,需要的朋友可以参考下
  • 本文通过实例代码给大家介绍了js比较两个单独的数组或对象是否相等 ,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了JS 比较两个Json对象的值是否相等的实例,有需要的朋友可以参考一下
  • 主要介绍了python实现比较类的两个instance(对象)是否相等的方法,结合实例形式分析了Python判断类的实例是否相等的判断操作实现技巧,需要的朋友可以参考下
  • js比较两个对象是否相等

    千次阅读 2019-07-05 18:51:55
    两个Object类型对象,即使拥有相同属性、相同值,当使用 == 或 === 进行比较时,也不认为他们相等。这就是因为他们是通过引用(内存里的位置)比较的,不像基本类型是通过值比较的。 var obj1 = { name: ...

    前言:如何判断两个对象是否相等?

    两个Object类型对象,即使拥有相同属性、相同值,当使用 == 或 === 进行比较时,也不认为他们相等。这就是因为他们是通过引用(内存里的位置)比较的,不像基本类型是通过值比较的。

    var obj1 = {
        name: "xiaoming",
        sex : "male"
    }
     
    var obj2 = {
        name: "xiaoming",
        sex : "male"
    }
     
    console.log(obj1 === obj2); // false
    复制代码

    但是如果浅拷贝指向同一内存的时候,此时两个对象相等。

    var obj1 = {
        name: "xiaoming",
        sex : "male"
    };
     
    var obj2 = {
        name: "xiaoming",
        sex : "male"
    };
     
    var obj3 = obj1;
     
    console.log(obj1 === obj3); // true
     
    console.log(obj2 === obj3); // false
    
    复制代码

    正如你所看想的,检查对象的“值相等”我们基本上是要遍历的对象的每个属性,看看它们是否相等

    
    /*
     * @param x {Object} 对象1
     * @param y {Object} 对象2
     * @return  {Boolean} true 为相等,false 为不等
     */
    var deepEqual = function (x, y) {
      // 指向同一内存时
      if (x === y) {
        return true;
      }
      else if ((typeof x == "object" && x != null) && (typeof y == "object" && y != null)) {
        if (Object.keys(x).length != Object.keys(y).length)
          return false;
    
        for (var prop in x) {
          if (y.hasOwnProperty(prop))
          {  
            if (! deepEqual(x[prop], y[prop]))
              return false;
          }
          else
            return false;
        }
    
        return true;
      }
      else 
        return false;
    }
    复制代码

    虽然这个简单的实现适用于我们的例子中,有很多情况下,它是不能处理。例如:

    1. 如果该属性值之一本身就是一个对象吗?
    2. 如果属性值中的一个是NaN(在JavaScript中,是不是等于自己唯一的价值?
    3. 如果一个属性的值为undefined,而另一个对象没有这个属性(因而计算结果为不确定?)

    结语:

    检查对象的“值相等”的一个强大的方法,最好是依靠完善的测试库,涵盖了各种边界情况。Underscore和Lo-Dash有一个名为_.isEqual()方法,用来比较好的处理深度对象的比较。

    最后附上Underscore里的_.isEqual()源码地址: github.com/hanzichi/un…

     

    展开全文
  • Java中如何判断两个对象是否相等

    千次阅读 2019-08-17 17:53:45
    如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下几个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。 2、hashcode的作用及与equals的关系。 1、...

    如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。
    从以下几个点来理解equals和hashCode方法:

    1、equals的作用及与==的区别。
    2、hashcode的作用及与equals的关系。

    1、equals的作用及与== 的区别。
    equals被用来判断两个对象是否相等。
    equals通常用来比较两个对象的内容是否相等,用来比较两个对象的地址是否相等。
    equals方法默认等同于“

    Object类中的equals方法定义为判断两个对象的地址是否相等(可以理解成是否是同一个对象),地址相等则认为是对象相等。这也就意味着,我们新建的所有类如果没有复写equals方法,那么判断两个对象是否相等时就等同于“==”,也就是两个对象的地址是否相等。
    Object类中equals的方法实现如下:

    public boolean equals(Object obj) {
    return (this == obj);
    }
    但在我们的实际开发中,通常会认为两个对象的内容相等时,则两个对象相等,equals返回true。对象内容不同,则返回false。
    所以可以总结为两种情况
    1、类未复写equals方法,则使用equals方法比较两个对象时,相当于==比较,即两个对象的地址是否相等。地址相等,返回true,地址不相等,返回false。
    2、类复写equals方法,比较两个对象时,则走复写之后的判断方式。通常,我们会将equals复写成:当两个对象内容相同时,则equals返回true,内容不同时,返回false。
    举个例子:

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10,"张三");
            Person p2 = new Person(10,"张三");
            System.out.println(p1.equals(p2));
        }
    }
    class Person{
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    

    Person未复写equals方法,则默认使用了Object中的equals,即为两个对象(p1和p2)的内存地址判断,p1和p2很明显内存地址不同,所以输出结果很明显为false。
    如果我们复写equals方法呢?我们认为名字和年龄一样的就是同一个人,那么p1和p2都表示10岁的张三,这两个对象应该是相等的。复写的equals方法如下:

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    

    同样的,执行上述用例,得到的结果是true。
    BTW:如果equals方法返回true,那么是否也是true?
    不一定是true。equals返回true有两种可能,一种是两个对象地址相同,一种是两个对象内容相同。当内容相同时,地址可能不同,所以
    比较的结果可能为false。
    我们把main方法加上对==的判断,如下:

    public static void main(String[] args) {
    	Person p1 = new Person(10,"张三");
    	Person p2 = new Person(10,"张三");
    	System.out.println(p1.equals(p2));
    	System.out.println(p1 == p2);
    }
    

    输出结果很明显 p1==p2的结果是false。

    补充Java中对Equals的要求:

    1. 对称性:如果x.equals(y)返回是"true",那么y.equals(x)也应该返回是"true"。
    2. 反射性:x.equals(x)必须返回是"true"。
    3. 类推性:如果x.equals(y)返回是"true",而且y.equals(z)返回是"true",那么z.equals(x)也应该返回是"true"。
    4. 一致性:如果x.equals(y)返回是"true",只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是"true"。
    5. 非空性,x.equals(null),永远返回是"false";x.equals(和x不同类型的对象)永远返回是"false"。

    2、hashCode的作用及与equals的关系。
    hashCode的作用是用来获取哈希码,也可以称作散列码。实际返回值为一个int型数据。用于确定对象在哈希表中的位置。
    Object中有hashcode方法,也就意味着所有的类都有hashCode方法。
    但是,hashcode只有在创建某个类的散列表的时候才有用,需要根据hashcode值确认对象在散列表中的位置,但在其他情况下没用。
    java中本质上是散列表的类常见的有HashMap,HashSet,HashTable
    所以,如果一个对象一定不会在散列表中使用,那么是没有必要复写hashCode方法的。但一般情况下我们还是会复写hashCode方法,因为谁能保证这个对象不会出现再hashMap等中呢?
    举个例子:
    两个对象equals相等的时候,hashcode并不一定相等。

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10, "张三");
            Person p2 = new Person(10, "张三");
            System.out.println(
                    "p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" +p2.hashCode());
        }
    }
    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }
    

    Person没有复写hashCode方法,使用Object默认的hashCode实现,输出结果如下:

    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    

    从结果可以看出,equals虽然相同,但是p1和p2的hashcode并不相同。

    如果Person用于散列表的类中呢,这里用HashSet来做测试。

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10, "张三");
            Person p2 = new Person(10, "张三");
            System.out.println(
                    "p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" +p2.hashCode());
            HashSet<Person> set = new HashSet<Person>();
            set.add(p1);
            set.add(p2);
            System.out.println(set);
        }
    }
    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "Person [age=" + age + ", name=" + name + "]";
        }
    }
    

    输出结果

    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    [Person [age=10, name=张三], Person [age=10, name=张三]]
    

    p1和p2的equals相同,我们认为是两个对象相等,但是这两个对象竟然同时出现再hashSet中,hashSet中是不会出现两个相同的元素的。
    那问题在哪里?
    hashset在添加一个元素的时候,会做如下判断:
    1、如果添加元素的hashcode相等并且 对象equals为true或对象== 时,则认为是同一个元素,不添加到新元素中。
    2、如果不符合上述条件,则认为是一个新元素,添加到set中。
    所以,虽然p1和p2equals比较时相等,但是hashcode并不一样,所以在往set中添加的时候认为是两个不同的元素,所以才会出现了p1和p2同时在set中的情况。

    我们改进下,复写一下hashcode方法,如下:

    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "Person [age=" + age + ", name=" + name + "]";
        }
    }
    

    重新执行结果:

    p1.equals(p2)=true, p1.hashcode=776160, p2.hashcode=776160
    [Person [age=10, name=张三]]
    

    于是看到set中仅有一个Person值了。

    补充几点:
    1、新建一个类,尤其是业务相关的对象类的时候,最好复写equals方法。
    2、复写equals方法时,同时记着要复写hashCode方法,谁能保证说这个对象一定不会出现在hashMap中呢?如果你用的是eclipse的自动代码生成,你会发现eclipse中复写equals和hashCode是在一起的。

    引申出几个经常在面试中问到的问题:
    1、两个对象,如果a.equals(b)==true,那么a和b是否相等?
    相等,但地址不一定相等。
    2、两个对象,如果hashcode一样,那么两个对象是否相等?
    不一定相等,判断两个对象是否相等,需要判断equals是否为true。

    注意:
    是否可以直接根据hashcode值判断两个对象是否相等吗?肯定是不可以的,因为不同的对象可能会生成相同的hashcode值。虽然不能根据hashcode值判断两个对象是否相等,但是可以直接根据hashcode值判断两个对象不等,如果两个对象的hashcode值不等,则必定是两个不同的对象。如果要判断两个对象是否真正相等,必须通过equals方法。

    也就是说对于两个对象,如果调用equals方法得到的结果为true,则两个对象的hashcode值必定相等;

    如果equals方法得到的结果为false,则两个对象的hashcode值不一定不同;

    如果两个对象的hashcode值不等,则equals方法得到的结果必定为false;

    如果两个对象的hashcode值相等,则equals方法得到的结果未知。

    展开全文
  • 主要介绍了JS判断两个数组或对象是否相同的方法,结合实例形式分析了javascript针对简单数组与对象进行判断的相关操作技巧,需要的朋友可以参考下
  • 在本篇文章里小编给大家分享的是关于java比较两个list是否相同equals的代码详解,有需要的朋友们可以参考学习下。
  • 假设现在有两个以下的数组 let arr1 = [1,2,3,4] let arr2 = [1,2,3,5] 你现在需要去比较这两个数组是否相等

    假设现在有两个以下的数组

    let arr1 = [1,2,3,4]
    let arr2 = [1,2,3,5]
    

    你现在需要去比较这两个数组是否相等,我来分享一下我的做法,主要是栈的做法来完成这个需求.

    if (!Array.isArray(arr1) ||!Array.isArray(arr2) ||arr1.length !== arr2.length) {
    	return false;
    }
    const queue = [{ arr1, arr2 }];
    while (queue.length) {
    	let shift = queue.shift();
    	let first = shift.arr1.shift();
    	let second = shift.arr2.shift();
    	if (first === second ) {
    		if (shift.arr1.length > 0 && shift.arr2.length > 0) {
    			queue.push({
    				arr1: [...shift.arr1],
    				arr2: [...shift.arr2],
    			});
    		}
    	} else {
    		return false;
    	}
    	}
    	return true;
    

    这样就完成了两个数组之间的比较,但实际上我们在工作中,可能需要比较的是两个json对象,例如你在做某个富文本编辑的模块的时候,用户在输入然后点击"返回"按钮时,你可能需要提示用户,"还没有保存是否需要离开"的字眼,它的本质就是用当前的输入对象和你进来时深拷贝的对象是否相等.
    假设现在有以下两个数组对象:

    let arr1 = [{ name: "1" }, { name: "2" }, { name: "3" }, { name: "4" }];
    let arr2 = [{ name: "1" }, { name: "2" }, { name: "3" }, { name: "4" }];
    
    function compareFun(arr1, arr2, func) {
    				if (!func) {
    					func = defaultCompare;
    				}
    
    				if (
    					!Array.isArray(arr1) ||
    					!Array.isArray(arr2) ||
    					arr1.length !== arr2.length
    				) {
    					return false;
    				}
    				const queue = [{ arr1, arr2 }];
    				while (queue.length) {
    					let shift = queue.shift();
    					let first = shift.arr1.shift();
    					let second = shift.arr2.shift();
    					if (func(first, second)) {
    						if (shift.arr1.length > 0 && shift.arr2.length > 0) {
    							queue.push({
    								arr1: [...shift.arr1],
    								arr2: [...shift.arr2],
    							});
    						}
    					} else {
    						return false;
    					}
    				}
    				return true;
    				function defaultCompare(a, b) {
    					return a === b;
    				}
    			}
    let compareFun1 = function (a, b) { // 自定义的比较函数
    	return a.name === b.name;
    };
    console.log(compareFun(arr1, arr2, compareFun1));
    
    展开全文
  • 比较对象相等性的四种方法

    千次阅读 2018-12-14 13:40:35
    比较对象相等性的四种方法  System.Object定义了3个不同的方法,来比较对象相等性:ReferenceEquals()和两个版本... (1)值类型的比较:一般我们就是判断两个值类型实例的各自包含的值是否相等  (2)引用类...
  • function(object1, object2) { for (var key in object1) { // 校验当前键的值是否一致 if (object1[key] != object2[key]) { return false; } } for (var key in object2) {...
  • js中比较两个对象是否相同

    万次阅读 2017-03-15 15:19:14
    js中,很轻易就可以比较2个普通字符串/数字是否相同,但是,如何比较2个对象是否相同呢? 在此我便给出较为简单的方法,如下://比较2个对象是否相同 function isObjEqual(o1,o2){ var props1 = Object....
  • java比较两个对象是否相等

    千次阅读 2018-06-21 00:25:22
    java比较两个对象,可以通过重写equals()实现。1.比较对象时, ==比较的是地址,而equals()比较的是对象内容2.重写equals()方法必须重写hashCode()示例代码如下:Person.java可以自动生成get()、set()、构造函数、...
  • JS--比较两个对象是否相同

    千次阅读 2019-06-05 11:15:10
    比较对象类型 export const compareParams = (a, b) => { let aProps = Object.getOwnPropertyNames(a); let bProps = Object.getOwnPropertyNames(b); let flag = true; if (aProps.length !== ...
  • 本文实例讲述了js中比较两个对象是否相同的方法。分享给大家供大家参考,具体代码如下,如有需要可直接复制使用,亲测有效: js代码: data() { return { old: {}, //定义一个装旧数据的对象 flag1: false,//...
  • let objArr = [{ nema: "123", age: "19" }, { name: "234", age: "22" }]; let obj2Arr = [{ nema: "123", age: "19" ...console.log(JSON.stringify(objArr) === JSON.stringify(obj2Arr)); //true
  • 如何比较两个数组/对象或数组对象是否相等? 我们可以通过使用JSON.stringify()方法来转换比较 具体示例: 1.比较两个数组(数组中是对象是否全等: let objArr = [{ nema: "123", age: "19" }, { ...
  • 主要将BigDecimal类型转换为Double类型。然后再进行比较
  • 主要介绍了JavaScript比较两个对象是否相等的方法,通过对js对象进行各方面的比较来判断两个对象是否相等,具有一定参考借鉴价值,需要的朋友可以参考下
  • 当两个数组元素类型相同,顺序相同时,直接判断是否相等,结果不相等;转化为字符串后,结果相等; var a=[1, 2, 3, 4]; var b = a.slice(); console.log(a); console.log(b); console.log(a == b); console.log...
  • 上篇文章《C#之相等比较(常规比较)》写了C#中比较是否相等的常规方法的使用说明,但是在实际开发中,往往也会用到两个引用类型的对象进行比较,而引用类型中有包含引用类型的属性或字段。 例如: 有一个引用类型...
  • 在使用数据库以及做详细的权限控制的时候,遇到要比较两个对象的情况,获得两个对象是否相同以及有那些字段被修改了,以判断用户是否有权限修改对象。apache commons提供的只有collections的对比,因此,本文利用...
  • js比较两个对象数组是否相同

    千次阅读 2021-01-18 17:51:09
    js 比较两个对象数组是否完全相同 let obj1 = [{"id" : 1, "name" : "xiaoMing"}]; let obj2 = [{"id" : 1, "name" : "xiaoMing"}]; var isEqualN = JSON.stringify(obj1) === JSON.stringify(obj2); console.log...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,325,771
精华内容 930,308
关键字:

对象比较是否相同