Tengo dos matrices, que representan dos versiones de la misma matriz, y me gustaría saber la diferencia entre ellas.
A diferencia de las preguntas anteriores , también me gustaría saber acerca de los elementos que simplemente se movieron . Si un elemento está en ambas matrices, pero está en diferentes lugares, me gustaría saberlo. Además, no quiero elementos en la diferencia de resultados que solo se movieron porque se agregaron o eliminaron otros elementos, lo que, por supuesto, hace que todos los elementos siguientes cambien de índice. Solo considero que los elementos se han movido, si cambiaron su posición relativa entre sí.
let old = [ "b", "c", "d", "e", "f", "g", "h", "i", "j" ]; let news = [ "a", "d", "c", "e", "f", "h", "i", "j" ]; // algo should result in let added = [ "a" ]; let removed = [ "b", "g" ]; let moved = [ "d", "c" ]; let old = [ "b", "c", "d", "e", "f", "g", "h", "i", "j" ]; let news = [ "a", "d", "c", "e", "f", "h", "i", "j" ]; let added = news.filter(item => !old.includes(item)); let removed = old.filter(item => !news.includes(item)); // find items that only changed place let oldCommon = old.filter(item => news.includes(item)); let newCommon = news.filter(item => old.includes(item)); let moved = newCommon.filter((item, i) => item != oldCommon[i]); console.log("added", added); console.log("removed", removed); console.log("moved", moved);Esta solución también se ocupa de problemas duplicados.
let oldArray = [ "b", "c", "d", "e", "f", "g", "h", "i", "j" ]; let newArray = [ "a", "d", "c", "e", "f", "h", "i", "j" ]; let added = newArray.filter(function(item) { return oldArray.indexOf(item) === -1; }); let removed = oldArray.filter(function(item) { return newArray.indexOf(item) === -1; }); let moved = newArray.filter(function(item) { return oldArray.indexOf(item) !== -1 && newArray.indexOf(item) !== -1 && oldArray.indexOf(item) !== newArray.indexOf(item); }); console.log(added); console.log(removed); console.log(moved);Los elementos agregados y eliminados deben ser claros. Para los elementos movidos, debemos realizar un seguimiento de los índices, en función de los elementos agregados y eliminados.
Recorro el newArray y si encuentro un elemento agregado, marco su índice con -1 y continuaré la indexación donde lo dejé, es decir: [0, 1, -1, 2, 3]
En el caso de los elementos eliminados, si encuentro un índice eliminado, aumentaré el índice actual y todos los siguientes, es decir: si el índice eliminado es 5, entonces [0,1,2,3,4,5,6, 7,8] se convierte en [0,1,2,3,4,6,7,8,9].
Finalmente, simplemente recorro newWithIndexes y comparo los índices (que calculé) con los índices oldArrays.
let oldArray = [ "b", "c", "d", "e", "f", "g", "h", "i", "j" ]; let newArray = [ "a", "d", "c", "e", "f", "h", "i", "j" ]; let added = newArray.filter(item => oldArray.indexOf(item) == -1); let removed = oldArray.filter(item => newArray.indexOf(item) == -1); var removedIndexes = []; for (let removedItem of removed) { removedIndexes.push(oldArray.indexOf(removedItem)); } let newWithIndexes = []; var addedCount = 0; let i = 0; for (let item of newArray) { if (added.includes(item)) { newWithIndexes.push({el: item, index: -1}); addedCount++; } else { newWithIndexes.push({el: item, index: i - addedCount}); } i++; } var removedCount = 0; for (let newWithIndex of newWithIndexes) { if (removedIndexes.includes(newWithIndex.index + removedCount)) { removedCount++; } if (newWithIndex.index != -1) { newWithIndex.index += removedCount; } } let moved = []; for (let newWithIndex of newWithIndexes) { if (newWithIndex.index != oldArray.indexOf(newWithIndex.el)) { moved.push(newWithIndex.el); } } console.log(added); console.log(removed); console.log(moved);