Question

所以，让我们说我有对象A和对象B。对象A有许多子对象，其中对象B具有多个相同的子对象。如何找出对象B中缺少的对象和对象A中添加的对象之间的差异，然后将它们放入自己的对象或二维数组中。

例如，第一个数组是添加到第二个数组的数组：

var changes = [["google.com", "yahoo.com"],["facebook.com", "bing.com"]]

我正在尝试使用crossrider比较存储书签的快照和当前书签列表。

Answer 1

我相信这是以下问题的后续内容，因此我将它们全部合并到一个在后台作用域（ background.js ）中运行的代码示例中： realtime with non-event programming， crossrider: store snapshot of bookmarks in local database and compare to current bookmarks list

因此对于 getChanges 函数，我更喜欢将书签树转换为哈希列表，然后比较列表以进行更改。在以下示例中，我使用 createHash 创建哈希列表，使用 cloneNode 创建节点对象的浅层克隆，然后在 getChanges 中我比较了添加，修改和删除的哈希列表：

appAPI.ready(function() {
  // Poll every 30 seconds
  setInterval(function() {
    appAPI.db.async.get('prevBookmarks', function(value) {
      // Load or initialize the previous bookmarks list
      var prevBookmarks = (value) ? value : {};

      // Get current bookmarks
      appAPI.bookmarks.getTree(function(nodes) {
        // Save bookmark hash for comparison in next interval
        appAPI.db.async.set('prevBookmarks', createHash(nodes[0]));

        // Get hash list of curent bookmarks
        var currBookmarks = createHash(nodes[0]);

        // Get changes between the lists
        var changes = getChanges(prevBookmarks, currBookmarks);

        // Post changes to your API server
        appAPI.request.post({
          url: http://yourAPIserver.com,
          postData: changes,
          contentType: 'application/json'
        });
      });
    });
  }, 30 * 1000);

  // Function to create a hash list from a bookmark tree
  function createHash(node) {
    var hash = {};
    if (typeof node === 'object') hash[node._id] = cloneNode(node);

    if (node.isFolder && typeof node.children !== 'undefined' && node.children.length > 0)  {
      node.children.forEach(function(child) {
        var childHash = createHash(child);
        for (var key in childHash) {
          if (!hash[key]) hash[key] = cloneNode(childHash[key]);
        }
      });
    }
    return hash;
  }

  // Function to create shallow clones of bookmark nodes
  function cloneNode(node) {
    var clone = appAPI.JSON.parse(appAPI.JSON.stringify(node));
    delete clone.children;
    delete clone.dateAdded;
    return clone;
  }

  // Get changes between current and previous bookmark hash lists
  function getChanges(prev, curr) {
      // Initialize return object
      var changes = {added:{}, modified:{}, removed:{}};

      // Search for added or modified nodes
      for (var key in curr) {
          if (!prev[key])
            changes.added[key] = curr[key];
          else if (appAPI.JSON.stringify(prev[key]) !== appAPI.JSON.stringify(curr[key]))
            changes.modified[key] = curr[key];
      }

      // Search for removed nodes
      for (var key in prev) {
          if (!curr[key])
            changes.removed[key] = prev[key];
      }
      return changes;
  }
});

免责声明：我是Crossrider员工

Answer 2

如果要比较的两个对象都是一维数组，那么只需使用Underscore.js中的设置算术函数，例如_.difference和_.intersection。

或者，使用相同的逻辑，交叉（未优化）就像这样简单：

array1.filter(function(v){return array2.indexOf(v)!==-1);});

如果您正在寻找一种通用的方法来找到任意深度和复杂度的两个任意对象之间的差异，那么这不是一个明确定义的问题。

比较两个JavaScript对象

2 个答案: