• 《javascript算法--对象的比较》


    方法一:JSON.stringify()

    此方法简单,适用于当两个对象的属性顺序相同的时候。
    var user1 = {name : "nerd", org: "dev"};
    var user2 = {name : "nerd", org: "dev"};
    var eq = user1 == user2;
    alert(eq); // gives false
    
    var eq1 = JSON.stringify(user1) == JSON.stringify(user2); alert(eq1); // gives true

    方法二:深度比较两个对象

    深度比较两个对象,当对象的属性类型相同且属性的值相同(对象的顺序可以不一样),两个对象就相等。
    function deepCompare(x, y) {
            var i, l, leftChain, rightChain;
    
            function compare2Objects(x, y) {
                var p;
    
                // remember that NaN === NaN returns false
                // and 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;
        }

    参考资料:

    1.http://stackoverflow.com/questions/1068834/object-comparison-in-javascript
    2.https://segmentfault.com/a/1190000008187911
  • 相关阅读:
    Javascript闭包的一些研究
    pytorchvision安装问题
    CUDA 基础
    语音识别入门推荐文献【转】
    【e2e】espnet框架安装问题集锦
    维特比算法与beam search
    kaldi识别问题集锦
    语音识别-重要开源数据
    git提交失败总结
    钟南山病后反思: 寿命长短, 不取决于衰老和疾病【转】
  • 原文地址:https://www.cnblogs.com/samli15999/p/7675849.html
Copyright © 2020-2023  润新知