美文网首页
怎么判断两个对象是否相等

怎么判断两个对象是否相等

作者: 勤能补拙的笨小孩 | 来源:发表于2019-12-13 21:49 被阅读0次

注:本篇在木A木文章基础上进行整理

方法一:通过JSON.stringify(obj)来判断两个对象转后的字符串是否相等

优点:用法简单,对于顺序相同的两个对象可以快速进行比较得到结果
缺点:这种方法有限制就是当两个对比的对象中key的顺序不是完全相同时会比较出错

方法二:getOwnPropertyNames()

// 对Object扩展一个方法chargeObjectEqual
Object.prototype.chargeObjectEqual = function(obj){
    // 当前Object对象
    //getOwnPropertyNames方法返回一个由指定对象的所有自身属性的属性名组成的数组
    var propsCurr = Object.getOwnPropertyNames(this);
    // 要比较的另外一个Object对象
    var propsCompare = Object.getOwnPropertyNames(obj);
    //如果两边数组长度不同,则两对象不同,直接返回false
    if (propsCurr.length != propsCompare.length) {
        return false;
    }
    //否则,进行遍历
    for (var i = 0,max = propsCurr.length; i < max; i++) {
        //用propName 代替属性名
        var propName = propsCurr[i];
        //如果属性值不同,则返回false
        if (this[propName] !== obj[propName]) {
            return false;
        }
    }
    //如果走到这里则说明二者相同
    return true;
}

优点:相对方法一进行了优化,可以应对不同顺序的Object进行比较,不用担心顺序不同而对比出错
缺点:从方法中可以看到只能获取到第一层的key组成的数组,当对象是复合对象时无法进行多层对象的比较

方法三:

//定义一个深度对比方法
function deepCompare(x, y) {
        //声明所需变量
        var i, l, leftChain, rightChain;
        //具体对比函数
        function compare2Objects(x, y) {
            var p;

            // 记得 NaN === NaN 返回 false
            // isNaN(undefined) returns true
            if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
                return true;
            }

            // Compare primitives and functions.     
            // Check if both arguments link to the same object.
            // Especially useful on the step where we compare prototypes
            if (x === y) {
                return true;
            }

            // Works in case when functions are created in constructor.
            // Comparing dates is a common scenario. Another built-ins?
            // We can even handle functions passed across iframes
            if ((typeof x === 'function' && typeof y === 'function') ||
                (x instanceof Date && y instanceof Date) ||
                (x instanceof RegExp && y instanceof RegExp) ||
                (x instanceof String && y instanceof String) ||
                (x instanceof Number && y instanceof Number)) {
                return x.toString() === y.toString();
            }

            // At last checking prototypes as good as we can
            if (!(x instanceof Object && y instanceof Object)) {
                return false;
            }

            if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
                return false;
            }

            if (x.constructor !== y.constructor) {
                return false;
            }

            if (x.prototype !== y.prototype) {
                return false;
            }

            // Check for infinitive linking loops
            if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
                return false;
            }

            // Quick checking of one object being a subset of another.
            // todo: cache the structure of arguments[0] for performance
            for (p in y) {
                if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                    return false;
                } else if (typeof y[p] !== typeof x[p]) {
                    return false;
                }
            }

            for (p in x) {
                if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                    return false;
                } else if (typeof y[p] !== typeof x[p]) {
                    return false;
                }

                switch (typeof(x[p])) {
                    case 'object':
                    case 'function':

                        leftChain.push(x);
                        rightChain.push(y);

                        if (!compare2Objects(x[p], y[p])) {
                            return false;
                        }

                        leftChain.pop();
                        rightChain.pop();
                        break;

                    default:
                        if (x[p] !== y[p]) {
                            return false;
                        }
                        break;
                }
            }

            return true;
        }

        if (arguments.length < 1) {
            return true; //Die silently? Don't know how to handle such case, please help...
            // throw "Need two or more arguments to compare";
        }

        for (i = 1, l = arguments.length; i < l; i++) {

            leftChain = []; //Todo: this can be cached
            rightChain = [];

            if (!compare2Objects(arguments[0], arguments[i])) {
                return false;
            }
        }

        return true;
    }

相关文章

  • python 高级编程①

    1 ‘==’ 与‘is ’的使用 ① ‘==’判断两个对象内容是否相等 ‘is’判断两个对象的地址是否相等 ②在p...

  • 关于isEqual

    isEqual,用来判断两个对象是否相等。但是,与“==”判断指针地址是否相等,不同的是,它判断的是对象的内容方...

  • JS 判断两个对象是否相等

    判断两个对象是否相等,执行结果:

  • C# 相等比较

    引用相等性 判断两个对象是否引用同一基础对象。使用 ReferenceEquals 方法判断: 值相等性 使用 =...

  • Java中判断两个对象相等,重写equals()方法和hashC

    基本概念 要比较两个对象是否相等时需要调用对象的equals() 方法:判断对象引用所指向的对象地址是否相等 对象...

  • python集合操作

    判断两个list是否相等 判断两个tuple是否相等 判断两个set是否相等 list转set list转tupl...

  • String中equals方法

    Java中使用“==”来判断两个对象是否相等是判断两个对象的引用是否相同Java中使用“equals”来判断两个对...

  • java重写equals方法需要注意

    为什么equals()方法要重写? 判断两个对象在逻辑上是否相等,如根据类的成员变量来判断两个类的实例是否相等,而...

  • iOS 快看漫画面试整理

    1, 如何判断两个对象相等 先判断是否为nil,然后比较对象的地址(用==),然后判断两个对象是否是同一个类(用i...

  • Java基础中Integer值用==和equal判断相等问题

    一、Integer equals()方法判断的是两个Integer对象值是否相等 二、Integer==判断两个对...

网友评论

      本文标题:怎么判断两个对象是否相等

      本文链接:https://www.haomeiwen.com/subject/kdeqnctx.html