对象与递归函数

Question

考虑下面的函数的蓝图，它试图比较两个对象的比较：

function objectCompare(a,b,path){ 
    for (var prop in a) { 
     path=prop; 
     if (a.hasOwnProperty(prop) && !(b.hasOwnProperty(prop))) { 
       ... 
      return false; 
     } 
     ... 
     if (detectType(a[prop])==='Object'){ 
      if (!objectCompare(a[prop],b[prop],path)) 
       return false; 
     } 
     ... 
    } 
     return true; 
} 

detectType是我自己的函数检查一个变量的类型。我的问题是，每次我们有递归调用时，我都想丰富变量path。然而，在当递归调用结束的同时，path必须遍历初始对象的剩余财产的名称，而不浓... 试想以下对象：

var Obj1 = { 
     p1: 's', 
     p2: { 
      p1: {a: { propA: 'a', propB: 'b' }}, 
      p2: 'g', 
     } 
     }; 

var Obj2 = { 
     p1: 's', 
     p2: { 
      p1: {a: { propA: 'a', propB: 'c' }}, 
      p2: 'g', 
     } 
     }; 

我想path时功能objectCompare返回具有以下值：p2.p1.a.propB即，使两个对象不同的点。我如何实现这一目标？

Answer 1

您必须将当前密钥添加到路径并将新路径传递给递归调用。试想一下：

console.info=function(x){document.write('<pre>'+JSON.stringify(x,0,3)+'</pre>')} 
 
//-- 
 

 
// compare: return path if a,b are different, null otherwise 
 

 
function compare(a, b, path) { 
 

 
    var ta = typeof a, 
 
     tb = typeof b; 
 

 
    // different types - fail 
 
    
 
    if (ta !== tb) { 
 
     return path; 
 
    } 
 
    
 
    // scalars - null if equal, path if not 
 

 
    if (ta !== 'object') { 
 
     return a === b ? null : path; 
 
    } 
 
    
 
    // make a set of keys from both objects 
 

 
    var keys = Object.keys(a).concat(Object.keys(b)).filter(function(x, i, self) { 
 
     return self.indexOf(x) === i; 
 
    }); 
 

 
    // for each key in set, compare values 
 
    
 
    var res = null; 
 

 
    keys.some(function(k) { 
 
     return res = compare(a[k], b[k], path.concat(k)); 
 
    }); 
 

 
    // return null or the first failed path 
 
    
 
    return res; 
 
} 
 

 
// 
 

 
var Obj1 = { 
 
     p1: 's', 
 
     p2: { 
 
      p1: {a: { propA: 'a', propB: 'b' }}, 
 
      p2: 'g', 
 
     } 
 
     }; 
 

 
var Obj2 = { 
 
     p1: 's', 
 
     p2: { 
 
      p1: {a: { propA: 'a', propB: 'c' }}, 
 
      p2: 'g', 
 
     } 
 
     }; 
 

 

 

 
var res = compare(Obj1, Obj2, []) 
 
console.info(res);

Answer 2

图书馆deep-diff做你所需要的。

上面参考呈现该示例中的代码：

var diff = require('deep-diff').diff; 

var lhs = { 
    name: 'my object', 
    description: 'it\'s an object!', 
    details: { 
     it: 'has', 
     an: 'array', 
     with: ['a', 'few', 'elements'] 
    } 
}; 

var rhs = { 
    name: 'updated object', 
    description: 'it\'s an object!', 
    details: { 
     it: 'has', 
     an: 'array', 
     with: ['a', 'few', 'more', 'elements', { than: 'before' }] 
    } 
}; 

var differences = diff(lhs, rhs); 

上面的代码段将导致以下结构描述不同之处：

[ { kind: 'E', 
    path: [ 'name' ], 
    lhs: 'my object', 
    rhs: 'updated object' }, 
    { kind: 'E', 
    path: [ 'details', 'with', 2 ], 
     lhs: 'elements', 
     rhs: 'more' }, 
    { kind: 'A', 
    path: [ 'details', 'with' ], 
    index: 3, 
    item: { kind: 'N', rhs: 'elements' } }, 
    { kind: 'A', 
    path: [ 'details', 'with' ], 
    index: 4, 
    item: { kind: 'N', rhs: { than: 'before' } } } ] 

值得注意的是，path属性很像所需输出。