jQuery/JavaScript JSON对象比较

是否可以比较两组json对象的差异？我有一个脚本，它通过jquery$post（）轮询JSON对象。我想做的是把刚刚轮询的对象与存储的对象进行比较。其中，如果从一个对象到另一个对象有任何更改，请将它们应用到存储对象或替换它（无论哪种方式），但从UI的角度来看，我正在使用的是无缝地将更改应用到JSON对象，方法是查找两个对象之间的差异。我想这样做是因为现在我有了它，所以无论是否有更改，UI都会完全重新加载每个轮询，从用户体验的角度来看，这基本上像**

---

我想如果我能找到这两个对象之间的差异（如果有的话），我会启动一个函数，我会编辑特定于差异的UI。

一个可能的解决方案是使用jQuery的extend。只要对象具有相同的属性，就可以很好地解决这个问题

var newJSON = $.extend({},oldJSON,serverData);

然后，您将保留旧对象，并使用旧对象中的任何属性（如果新对象中不存在这些属性）创建一个新对象，并使用来自服务器的新数据中的属性覆盖任何现有属性

我想做的是把刚刚轮询的对象与存储的对象进行比较。其中，如果从一个到另一个有任何更改，则将其应用于存储对象或替换它（任意一种方式）

如果您愿意使用一个非常简单的“它是否以任何方式发生了变化？是/否”解决方案，如果它发生了变化，您只需将以前的对象替换为新对象（根据我引用的问题部分），那么您可以在解析之前保存JSON响应，即以web服务器发送的字符串格式保存。然后，当下一个响应出现时，将新字符串与旧字符串进行比较。如果它们不同（或者如果这是第一个请求），则解析JSON并对其进行适当的处理以显示。当然，这假设服务器端代码以一致的格式创建JSON字符串（而不是，例如，更改属性的顺序）

如果我们假设您已经得到（已解析的）对象，

isEqual（a，b）

函数确实应该处理嵌套对象、数组属性等。这可以递归完成，只需返回true或false，但a

getDifferences（a，b）

函数在报告嵌套对象中的差异时会变得混乱。考虑这个简单的例子：

old: {"mum" : "Maria", "dad" : "Pierre", "kids" : ["Joe", "Mike", "Louisa"] }
new: {"mum" : "Julie", "dad" : "Pierre", "kids" : ["Joe", "Mary"] }

区别是不是{“妈妈”：“朱莉”，“孩子”：[“玛丽”]}？“妈妈”变了，“孩子”的名单也变了，但“迈克”变为“玛丽”了吗？还是“迈克”和“路易莎”都不见了，而“玛丽”是新的，还是。。。？也许应该是

“kids”：[“Joe”，“Mary”]

，因为这是新的价值观。您如何表示删除？这只是我脑海中的第一个例子，我不知道你想如何处理这些差异。情况可能会很快变得更糟：如果“kids”数组包含对象而不是字符串来表示整个家谱呢？如果新的“mum”属性是

[“Maria”，“Julie”]

（允许继父继母等）会怎样

如果您知道您的特定数据只有一维对象，那么您可以执行以下简单操作：

function getDifferences(oldObj, newObj) {
   var diff = {};

   for (var k in oldObj) {
      if (!(k in newObj))
         diff[k] = undefined;  // property gone so explicitly set it undefined
      else if (oldObj[k] !== newObj[k])
         diff[k] = newObj[k];  // property in both but has changed
   }

   for (k in newObj) {
      if (!(k in oldObj))
         diff[k] = newObj[k]; // property is new
   }

   return diff;
}

对于上面允许嵌套对象的最简单的更改是，假设一个属性是一个对象/数组，那么您只关心它在任何方面是否不同，而不是深入报告到底哪些“子属性”发生了更改。如果是这样，只需使用上述函数并进行更改：

else if (oldObj[k] !== newObj[k])

到

其中，

isEqual（）

是web或web上浮动的许多比较函数之一

（注意：我没有为上面的

.hasOwnProperty（）

烦恼，因为我假设作为JSON返回到Ajax请求的对象不会从原型链继承属性为此，函数不需要担心属性是函数，它只需要担心JSON字符串中的有效内容。）

var objectsAreEqual=function（obj1，x）{
var MAX_DEPTH=10；
var testEq=功能（obj1，x，深度）{
如果（深度<最大深度）{
用于（obj1中的var p）{
if（typeof（obj1[p]）！==typeof（x[p]）返回false；
if（（obj1[p]==null）！==（x[p]==null））返回false；
开关（类型（obj1[p]））{
案例“未定义”：
if（typeof（x[p]）！=“undefined”）返回false；
打破
案例“对象”：
如果（obj1[p]！==null&&x[p]！==null&&（obj1[p].constructor.toString（）！==x[p].constructor.toString（）| |！testEq（obj1[p]，x[p]，depth+1）），则返回false；
打破
案例“功能”：
如果（p！=“equals”&&obj1[p].toString（）！=x[p].toString（））返回false；
打破
违约：
如果（obj1[p]！==x[p]）返回false；
}
}
}
返回true；
};
//这有点难看，但是上面的算法在以下方面失败了：testEq（[[1,2]，[[1,2]，[1,3]]，0）
返回测试Q（obj1，x，0）和测试Q（x，obj1，0）；
};

很抱歉回答老问题，但我的回答可能会帮助其他可能面临相同问题的人。比较两个json对象的最简单和最短代码如下。谢谢

<script type="text/javascript">
    $(document).ready(function () {
        var a = { "id": "210", "memberlist": "john" };
        var b = { "id": "210", "memberlist": "john1" };

        alert(JSON.stringify(a) != JSON.stringify(b) ? 'not same' : ' same');
    });
</script>

$（文档）.ready（函数（）{
var a={“id”：“210”，“成员列表”：“john”}；
var b={“id”：“210”，“成员列表”：“john1”}；
警报（JSON.stringify（a）！=JSON.stringify（b）-“不相同”：“相同”）；
});

这是我的代码：

    function getDifferences(oldObj, newObj) {
    var diff = {};

    for (var k in oldObj) {
        if (!(k in newObj)){
            diff[k] = undefined;  // old key does not exist in new
        } else {
            switch (typeof oldObj[k]){
                case "array": {
                    String(oldObj[k]) !== String(newObj[k]) ? diff[k] = newObj[k] : null;
                    break;
                } case "object": {                        
                    Object.keys(oldObj[k]).forEach(key =>{                           
                        if(oldObj[k][key] !== newObj[k][key]){
                            if(diff[k]){
                                diff[k][key] = newObj[k][key];
                            } else {
                                diff[k] = {[key]: newObj[k][key]}
                            }
                        }
                    });
                    //JSON.stringify(oldObj[k]) !== JSON.stringify(newObj[k]) ? diff[k] = newObj[k] : null; Optional basic comparision
                    break;
                } default: { //Values are strings or numbers
                    oldObj[k] !== newObj[k] ? diff[k] = newObj[k] : null;
                    break;
                }
            }
        }
    }

    for (k in newObj) {
        if (!(k in oldObj))
        diff[k] = newObj[k]; // property is new
    }     
    return diff;
}

---

我们获取元素的类型，并对相等性进行内部比较。

如果您做得不对，您不会从服务器发送类似的对象，并在客户端手动查找差异。Y

<script type="text/javascript">
    $(document).ready(function () {
        var a = { "id": "210", "memberlist": "john" };
        var b = { "id": "210", "memberlist": "john1" };

        alert(JSON.stringify(a) != JSON.stringify(b) ? 'not same' : ' same');
    });
</script>

    function getDifferences(oldObj, newObj) {
    var diff = {};

    for (var k in oldObj) {
        if (!(k in newObj)){
            diff[k] = undefined;  // old key does not exist in new
        } else {
            switch (typeof oldObj[k]){
                case "array": {
                    String(oldObj[k]) !== String(newObj[k]) ? diff[k] = newObj[k] : null;
                    break;
                } case "object": {                        
                    Object.keys(oldObj[k]).forEach(key =>{                           
                        if(oldObj[k][key] !== newObj[k][key]){
                            if(diff[k]){
                                diff[k][key] = newObj[k][key];
                            } else {
                                diff[k] = {[key]: newObj[k][key]}
                            }
                        }
                    });
                    //JSON.stringify(oldObj[k]) !== JSON.stringify(newObj[k]) ? diff[k] = newObj[k] : null; Optional basic comparision
                    break;
                } default: { //Values are strings or numbers
                    oldObj[k] !== newObj[k] ? diff[k] = newObj[k] : null;
                    break;
                }
            }
        }
    }

    for (k in newObj) {
        if (!(k in oldObj))
        diff[k] = newObj[k]; // property is new
    }     
    return diff;
}