Most efficient Javascript way to check if an object within an unknown object exists [duplicate]

Answer 1

An alternative approach is:

((acquaintances.types || {}).friends || {}).others

which is shorter than other solutions, but may or may not thrill you.

You can also build a little helper to make the same idea a tiny bit more palatable:

function maybe(o) { return o || {}; }

Now you can do

maybe(maybe(acquaintances.types).friends).others

If you don't mind writing property names as strings, you could make a little helper:

function maybe(obj) {
  return Object.defineProperty(
    obj || {}, 
    'get', 
    { value: function(prop) { return maybe(obj[prop]); }
  );
}

Now you can write

maybe(acquaintances.types').get('friends').others

In ES6, you can do this, albeit clumsily, using destructuring assignment with defaults:

var { types: { friends: { others } = {} } = {} } = acquaintances;

If you want to use this in an expression context, instead of assigning to a variable, in theory you could use argument destructuring:

(({ types: { friends: { others } = {} } = {} }) => others)(acquaintances)

After all is said and done, the standard approach remains

acquaintances.types && 
  acquaintances.types.friends && 
  acquaintances.types.friends.others

This is why there is an active (?) discussion in the ES6 design groups about a CoffeeScript-like existential operator, but it does not seem to be converging very rapidly.

Answer 2

Instead of this:

if(acquaintances.types){
  if(aquaintances.types.friends){
    if(acquaintances.types.friends.others){
       // do stuff with the "others" array here
    } 
  }
}

Try this:

   if(acquaintances &&
      acquaintances.types &&
      acquaintances.types.friends &&
      acquaintances.types.friends.others) {
    }

Or

acquaintances &&
acquaintances.types &&
acquaintances.types.friends &&
acquaintances.types.friends.others ?
doSomething() : doSomethingElse()

Answer 3

The and operator is sequential so you can do this without nesting if statements.

if(acquaintances.types && aquaintances.types.friends && acquaintances.types.friends.others){
    //acquaintances.types.friends.others exists!
}

Answer 4

It's not nice in JavaScript.

You could add them to one big condition...

if (obj.prop && obj.prop.someOtherProp) { }

...or write a helper function where you pass an object and a string...

var isPropSet = function(object, propPath) {
    return !! propPath.split('.')
           .reduce(function(object, prop) { return object[prop] || {}; }, object);
};

isPropSet(obj, 'prop.someOtherProp);

...or you could use CoffeeScript and its ? operator...

obj.prop?.someOtherProp

You could also wrap the lookup in a try/catch, but I wouldn't recommend it.