javascript - teclado - ¿La mejor manera de obtener la intersección de las teclas de dos objetos?

keypress javascript

Question

Tengo dos objetos literales como este:

var firstObject =
{
    x: 0,
    y: 1,
    z: 2,

    a: 10,
    b: 20,
    e: 30
}

var secondObject =
{
    x: 0,
    y: 1,
    z: 2,

    a: 10,
    c: 20,
    d: 30
}

Quiero obtener la intersección de las claves que estos dos literales de objeto tienen como:

var intersectionKeys  = [''x'', ''y'', ''z'', ''a'']

Obviamente puedo hacer un bucle y ver si existe una clave con el mismo nombre en el otro objeto, pero me pregunto si este sería un buen caso para alguna programación funcional y uso de mapas / filtros / reducir. Yo mismo no he hecho mucha programación funcional, pero tengo la sensación de que podría existir una solución limpia e inteligente para este problema.

Answer 1

El procedimiento que sugeriré es:

1. Obtenga la array de claves utilizando Object.keys() para uno de los objetos.
2. Encuentre la intersección de la matriz utilizando .filter y .filter si el segundo objeto contiene una clave que coincida con la primera matriz.

var firstObject = {
  x: 0,
  y: 1,
  z: 2,

  a: 10,
  b: 20,
  e: 30
}

var secondObject = {
  x: 0,
  y: 1,
  z: 2,

  a: 10,
  c: 20,
  d: 30
}

function getIntKeys(obj1, obj2){

    var k1 = Object.keys(obj1);
    return k1.filter(function(x){
        return obj2[x] !== undefined;
    });
  
}

alert(getIntKeys(firstObject, secondObject));

Answer 2

Las respuestas dadas son agradables y asombrosas, pero podría haber un problema en la answer void y eso es: " ¿Qué pasa si uno de los valores de propiedad se establece intencionalmente como undefined ? "

La answer es buena (realmente fantástica) pero como estamos al borde del mañana de JavaScript, creo que la mía no será tan mala:

var a = { x: undefined, y: 1, z: 2, a: 10, b: 20, e: 30 }
var b = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30 }

function intersect(o1, o2){
    return Object.keys(o1).filter(k => k in o2)
}

document.write(''<pre>'' + JSON.stringify(intersect(a, b)) + ''</pre>'');

Actualizar

onalbi mencionó algún problema de rendimiento en los comentarios, que es racional y, por lo tanto, el código de abajo parece ser una mejor manera de manejar el problema:

var a = { x: undefined, y: 1, z: 2, a: 10, b: 20, e: 30};
var b = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30};

function intersect(o1, o2) {

  const [k1, k2] = [Object.keys(o1), Object.keys(o2)];
  const [first, next] = k1.length > k2.length ? [k2, o1] : [k1, o2];
  return first.filter(k => k in next);
}

document.write(''<pre>'' + JSON.stringify(intersect(a, b)) + ''</pre>'');

Answer 3

Una solución sin indexOf .

var firstObject = { x: 0, y: 1, z: 2, a: 10, b: 20, e: 30 },
    secondObject = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30 };

function intersection(o1, o2) {
    return Object.keys(o1).concat(Object.keys(o2)).sort().reduce(function (r, a, i, aa) {
        if (i && aa[i - 1] === a) {
            r.push(a);
        }
        return r;
    }, []);
}

document.write(''<pre>'' + JSON.stringify(intersection(firstObject, secondObject), 0, 4) + ''</pre>'');

Segundo intento con O (n).

var firstObject = { x: 0, y: 1, z: 2, a: 10, b: 20, e: 30 },
    secondObject = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30 };

function intersection(o1, o2) {
    return Object.keys(o1).filter({}.hasOwnProperty.bind(o2));
}

document.write(''<pre>'' + JSON.stringify(intersection(firstObject, secondObject), 0, 4) + ''</pre>'');

Answer 4

Función recursiva

Esta es otra solución, tal vez te ayude. Utilicé una función recursiva para interceptar dos objetos. La ventaja de esta solución es que no necesita preocuparse por los atributos que son objetos al mismo tiempo.

En este caso, la función intercepta los atributos que existen en ambos objetos y asigna el valor de ''objSource'' como el valor final del atributo interceptado.

{
        function interceptObjects(objSource, objInterface) {
            let newObj = {};
            for (const key in objSource) {
                if (objInterface.hasOwnProperty(key)) {
                    // in javascript an array is a object too.
                    if (objSource[key] instanceof Object && !Array.isArray(objSource[key]) && objInterface[key] instanceof Object && !Array.isArray(objInterface[key])) {
                        newObj[key] = {};
                        newObj[key] = interceptObjects(objSource[key], objInterface[key])
                    } else {
                        newObj[key] = objSource[key];
                    }

                }
            }
            return newObj;
        }
        
        
        // FOR TESTING


    let objSource = {
            attr1: '''',
            attr2: 2,
            attr3: [],
            attr4: {
                attr41: ''lol'',
                attr42: 12,
                attr43: 15,
                attr45: [1, 4],
            },
            attr5: [2, 3, 4],
        };


        let objInterface = {
            attr1: null,
            attr4: {
                attr41: null,
                attr42: 12,
                attr45: [1],
            },
            attr5: [],
            attr6: null,
        };


        console.log(this.interceptObjects(objSource, objInterface));
    }