Come è stato chiesto, ecco una funzione di confronto di oggetti ricorsivi. E un po 'di più. Supponendo che l'uso primario di tale funzione sia l'ispezione degli oggetti, ho qualcosa da dire. Un confronto profondo completo è una cattiva idea quando alcune differenze sono irrilevanti. Ad esempio, un confronto profondo cieco nelle asserzioni TDD rende i test inutili e fragili. Per questo motivo, vorrei introdurre una diff parziale molto più preziosa . È un analogo ricorsivo di un precedente contributo a questo thread. Ignora le chiavi non presenti in a
var bdiff = (a, b) =>
_.reduce(a, (res, val, key) =>
res.concat((_.isPlainObject(val) || _.isArray(val)) && b
? bdiff(val, b[key]).map(x => key + '.' + x)
: (!b || val != b[key] ? [key] : [])),
[]);
BDiff consente di verificare i valori previsti tollerando altre proprietà, che è esattamente ciò che si desidera per l' ispezione automatica . Ciò consente di creare tutti i tipi di asserzioni avanzate. Per esempio:
var diff = bdiff(expected, actual);
// all expected properties match
console.assert(diff.length == 0, "Objects differ", diff, expected, actual);
// controlled inequality
console.assert(diff.length < 3, "Too many differences", diff, expected, actual);
Tornando alla soluzione completa. Costruire un diff tradizionale con bdiff è banale:
function diff(a, b) {
var u = bdiff(a, b), v = bdiff(b, a);
return u.filter(x=>!v.includes(x)).map(x=>' < ' + x)
.concat(u.filter(x=>v.includes(x)).map(x=>' | ' + x))
.concat(v.filter(x=>!u.includes(x)).map(x=>' > ' + x));
};
L'esecuzione sopra la funzione su due oggetti complessi genererà qualcosa di simile a questo:
[
" < components.0.components.1.components.1.isNew",
" < components.0.cryptoKey",
" | components.0.components.2.components.2.components.2.FFT.min",
" | components.0.components.2.components.2.components.2.FFT.max",
" > components.0.components.1.components.1.merkleTree",
" > components.0.components.2.components.2.components.2.merkleTree",
" > components.0.components.3.FFTResult"
]
Infine, per avere un'idea di come differiscono i valori, potremmo voler valutare direttamente () l'output diff. Per questo, abbiamo bisogno di una versione più brutta di bdiff che produca percorsi sintatticamente corretti:
// provides syntactically correct output
var bdiff = (a, b) =>
_.reduce(a, (res, val, key) =>
res.concat((_.isPlainObject(val) || _.isArray(val)) && b
? bdiff(val, b[key]).map(x =>
key + (key.trim ? '':']') + (x.search(/^\d/)? '.':'[') + x)
: (!b || val != b[key] ? [key + (key.trim ? '':']')] : [])),
[]);
// now we can eval output of the diff fuction that we left unchanged
diff(a, b).filter(x=>x[1] == '|').map(x=>[x].concat([a, b].map(y=>((z) =>eval('z.' + x.substr(3))).call(this, y)))));
Questo produrrà qualcosa di simile a questo:
[" | components[0].components[2].components[2].components[2].FFT.min", 0, 3]
[" | components[0].components[2].components[2].components[2].FFT.max", 100, 50]
Licenza MIT;)