Whats the easiest way to check if keys match between two objects?

Question

assuming you have two objects that have a decent amount of nesting...

const objA = {
  one: {
    a: 10,
    b: 'string1',
    c: {
      d: 10
    }
  },
  two : 'string1'
}

const objB = {
  one: {
    a: 20,
    b: 'string2',
    c: {
      d: 20
    }
  },
  two : 'string2'
}

Is there an easy way to check that all the keys match between them?

*Match: both object have the same keys in the same nested location, there are no extra keys, so objA and objB Match

you can think like comparing Object.keys() recursively for both the object. — Guru1988, Feb 25 '19 at 17:34

Nina Scholz · Accepted Answer · 2019-02-25T18:29:33.943

5

In plain Javascript, you could get the keys, compare the length and iterate the keys and check if the values are objects.

function compareKeys(a, b) {
    var keysA = Object.keys(a),
        keysB = Object.keys(b);
    return keysA.length === keysB.length
        && keysA.every(k => b.hasOwnProperty(k) && (
            a[k] && typeof a[k] === 'object' ||
            b[k] && typeof b[k] === 'object'
                ? compareKeys(a[k], b[k])
                : true));
}

const
    objA = { one: { a: 10, b: 'string1', c: { d: 10 } }, two : 'string1' },
    objB = { one: { a: 20, b: 'string2', c: { d: 20 } }, two : 'string2' },
    objC = { one: { a: 20, b: 'string2', c: { d: 20, e: false } }, two : 'string2' };

console.log(compareKeys(objA, objB));
console.log(compareKeys(objA, objC));
console.log(compareKeys({ a: {} }, { a: "test" }));
console.log(compareKeys({ a: "test" }, { a: {} }));
console.log(compareKeys({ a: { b: "new str" } }, { a: "test" }));

edited Feb 25 '19 at 18:29

answered Feb 25 '19 at 17:37

Nina Scholz

376,160
25
347
392

Yup, I knew this was an option,.. recursive with multiple conditionals, was hoping there was an easier way – lonewarrior556 Feb 25 '19 at 17:57
i don't think you're going to find anything easier. This is the essential algorithm, I believe. It can be written different ways -- my answer is slightly different -- but it's hard to avoid the recursion with a recursive data structure. – Scott Sauyet Feb 25 '19 at 18:00
2

this will fail for `obj1 = {a: {}} and obj2 = {a: "test"}` – Gaurav Saraswat Feb 25 '19 at 18:05
@GauravSaraswat, it returns `false`. what do you expect, and why? – Nina Scholz Feb 25 '19 at 18:08
1

i would expect `true` in this case. as keys are again same in this case – Gaurav Saraswat Feb 25 '19 at 18:08
i changed the check for both objects. – Nina Scholz Feb 25 '19 at 18:13
on serious NOTE: It will again fail for `obj1 = {a: {b: "new str"}} and obj2 = {a: "test"}` . if you like my soln. please upvote that too :P – Gaurav Saraswat Feb 25 '19 at 18:27
it think, it's still an edge case, the result should be `false` for different values. – Nina Scholz Feb 25 '19 at 18:31
i see `false`, above. – Nina Scholz Feb 25 '19 at 20:56
@NinaScholz the code still doesn't handle when `arg1 is obj is object and arg2 is string` . basically what I want to just say is, doing `Object.keys` on string the code just accidently works fine as `Object.keys('string')` doesnt give error but returns array from `0, 1, 2, 3, 4, ... till string length` – Gaurav Saraswat Feb 25 '19 at 22:26

Gaurav Saraswat · Answer 2 · 2019-02-25T18:44:44.717

I think below code should extensively cover all type of objects for solution.

const doAllKeysMatch = (obj1, obj2) => {

  if (typeof obj1 != 'object' && typeof obj1 != 'object') {
    return true;
  }

  if (typeof obj1 == 'object' && typeof obj1 == 'object') {
    // if both are object types compare all keys
    let obj1Keys = Object.keys(obj1);
    let obj2Keys = Object.keys(obj2);

    return (obj1Keys.length == obj2Keys.length) && obj1Keys.every(key => obj2Keys.includes(key) && doAllKeysMatch(obj1[key], obj2[key]))

  }

  /*
    if only one is of object type check if it doesnt have any keys.
    if empty object is there then return true which means "abc" and {} have same keys
  */

  if ((typeof obj1 == 'object') && (Object.keys(obj1).length < 1)) {
      return true
  }

  return Object.keys(obj2).length < 1;
}

console.log(doAllKeysMatch("abc", "dfg")) // true
console.log(doAllKeysMatch("abc", {})) // true
console.log(doAllKeysMatch({a: "test"}, {a: {}})) // true
console.log(
  doAllKeysMatch(
    { 
      a: 10, 
      b: 'string1', 
      c: { d: 10 }, 
      two : 'string1' 
    }, 
    {
      a: 10, 
      b: 'string1', 
      c: { d: false },
      two : 'string2'
    }
  )) // true

score 1 · Answer 3 · answered Feb 25 '19 at 17:54

This is fairly similar to the answer from Nina Scholz, with just enough differences in thoughts to make it an interesting alternative:

const matchingStructure = (a, b, ak = Object.keys(a), bk = Object.keys(b)) => 
  !(typeof a == 'object' && typeof b == 'object') ||
  ( ak.length === bk.length &&
    ak.every(k => k in b) &&
    ak.every(k => matchingStructure(a[k], b[k]))
  )


const objA = {one: {a: 10, b: "string1", c: {d: 10}}, two: "string1"}
const objB = {one: {a: 20, b: "string2", c: {d: 20}}, two: "string2"}
const objC = {one: {a: 30, b: "string3", c: {d: 30}, e: true}, two: "string3"}

console.log(matchingStructure(objA, objB))
console.log(matchingStructure(objA, objC))

It could well fail on cyclic structures. I haven't thought that through.

score 0 · Answer 4 · answered Feb 25 '19 at 17:46

0

I recommend to look at the implementation of isEqual from lodash, https://lodash.com/docs/4.17.11#isEqual

answered Feb 25 '19 at 17:46

George.S

149
8

That's not just about the keys but also the values. – Scott Sauyet Feb 25 '19 at 17:46

Whats the easiest way to check if keys match between two objects?

4 Answers4