Test for existence of nested JavaScript object key

Question

If I have a reference to an object   var test         that will potentially  but not immediately  have nested objects  something like    level1   level2   level3   level3        What is the best way to check for the existence of property in deeply nested objects   alert test level1   yields undefined  but alert test level1 level2 level3   fails   I   m currently doing something like this   if test level1  amp  amp  test level1 level2  amp  amp  test level1 level2 level3        alert test level1 level2 level3       but I was wondering if there   s a better way

User · Answer

I have used this function for access properties of the deeply nested object and it working for me...

this is the function

/**
 * get property of object
 * @param obj object
 * @param path e.g user.name
 */
getProperty(obj, path, defaultValue = '-') {
  const value = path.split('.').reduce((o, p) => o && o[p], obj);

  return value ? value : defaultValue;
}

this is how I access the deeply nested object property

{{ getProperty(object, 'passengerDetails.data.driverInfo.currentVehicle.vehicleType') }}

User · Answer

If you happen to be using AngularJs you can use the  parse service to check if a deep object property exists  like this   if   parse  model data items   vm          vm model data items push  whatever        to avoid statements like this   if vm model  amp  amp  vm model data  amp  amp  vm model data items                 don t forget to inject the  parse service into your controller  for more info  https   glebbahmutov com blog angularjs-parse-hacks

User · Answer

You can also use tc39 optional chaining proposal together with babel 7 - tc39-proposal-optional-chaining  Code would look like this     const test   test  level1  level2  level3    if  test  alert test

User · Answer

I wrote a library called l33teral to help test for nested properties  You can use it like this   var myObj              var hasNestedProperties   leet myObj  probe  prop1 prop2 prop3      I do like the ES5 6 solutions here  too

User · Answer

how about  try      alert test level1 level2 level3    catch e        whatever

User · Answer

var a   a         b            c   d            function isset  fn        var value      try           value   fn          catch  e            value   undefined        finally           return value     undefined               ES5 console log      isset function      return a b c          isset function      return a b c d e f          If you are coding in ES6 environment  or using 6to5  then you can take advantage of the arrow function syntax      ES6 using the arrow function console log      isset      gt  a b c       isset      gt  a b c d e f       Regarding the performance  there is no performance penalty for using try  catch block if the property is set  There is a performance impact if the property is unset   Consider simply using   has   var object      a      b      c   3           has object   a         true    has object   a b c         true    has object    a    b    c          true

User · Answer

I wrote my own function that takes the desired path  and has a good and bad callback function    function checkForPathInObject object  path  callbackGood  callbackBad       var pathParts   path split           var currentObjectPath   object          Test every step to see if it exists in object     for var i 0  i lt  pathParts length   i             var currentPathPart   pathParts i           if  currentObjectPath hasOwnProperty pathParts i                 if callbackBad                   callbackBad                              return false            else               currentObjectPath   currentObjectPath pathParts i                            call full path in callback     callbackGood        Usage   var testObject         level1           level2               level3                                      checkForPathInObject testObject   level1 level2 level3   function   alert  good      function   alert  bad          good  checkForPathInObject testObject   level1 level2 level3 levelNotThere   function   alert  good      function   alert  bad         bad

User · Answer

I was having the same issue and and wanted to see if I could come up with a my own solution  This accepts the path you want to check as a string   function checkPathForTruthy obj  path      if      a-zA-Z    test path         console log  Cannot resolve variables in property accessors        return false         path   path replace     g          path   path replace        g         path   path split          var steps   0    var lastRef   obj    var exists   path every key   gt        var currentItem   lastRef path steps        if  currentItem          lastRef   currentItem        steps          return true        else         return false                 return exists      Here is a snippet with some logging and test cases    x000D   x000D  console clear    x000D  var testCases     x000D      data Messages 0  Code   true   x000D      data Messages 1  Code   true   x000D      data Messages 0   Code     true   x000D      data Messages 0   Code     true   x000D      data Messages  0   Code     false   x000D      data  Messages   0   Code     true  x000D     x000D  var path    data Messages 0  Code   x000D  var obj     x000D    data    x000D      Messages     x000D        Code   0  x000D           x000D        Code   1  x000D         x000D      x000D    x000D   x000D  function checkPathForTruthy obj  path    x000D    if      a-zA-Z    test path     x000D      console log  Cannot resolve variables in property accessors    x000D      return false  x000D      x000D   x000D    path   path replace     g        x000D    path   path replace        g       x000D    path   path split       x000D   x000D    var steps   0  x000D    var lastRef   obj  x000D    var logOutput       x000D    var exists   path every key   gt    x000D      var currentItem   lastRef path steps    x000D      if  currentItem    x000D        logOutput push currentItem   x000D        lastRef   currentItem  x000D        steps    x000D        return true  x000D        else   x000D        return false  x000D        x000D        x000D    console log exists  logOutput   x000D    return exists  x000D    x000D   x000D  testCases forEach testCase   gt    x000D    if  checkPathForTruthy obj  testCase 0       testCase 1     x000D      console log  Passed      testCase 0    x000D      else   x000D      console log  Failed      testCase 0      expected     testCase 1    x000D      x000D      x000D   x000D   x000D

User · Answer

I am using a function in the following fashion   var a       a b       a b c       a b c d    abcdabcd    function isDefined objectChainString        try           var properties   objectChainString split               var currentLevel   properties 0           if  currentLevel in window                var consolidatedLevel   window currentLevel               for  var i in properties                    if  i    0                        continue                    else                       consolidatedLevel   consolidatedLevel properties i                                                if  typeof consolidatedLevel     undefined                     return true                else                   return false                          else               return false                  catch  e            return false              defined console log checkUndefined  a b x d       undefined console log checkUndefined  a b c x     console log checkUndefined  a b x d     console log checkUndefined  x b c d

User · Answer

Just in case is not supported or not included by your framework                                                       Array prototype some   function fn  thisObj      var scope   thisObj    window    for   var i 0  j this length  i  lt  j    i         if   fn call scope  this i   i  this            return true              return false                                                             function isSet  object  string      if   object  return false    var childs   string split         if  childs length  gt  0         return  childs some function  item          if  item in object            object   object item            return false          else return true              else if  string in object         return true      else return false     var object       data        item          sub item            bla              here                 iam  true                                             console log isSet object  data item        true console log isSet object  x        false console log isSet object  data sub item        false console log isSet object  data item        true console log isSet object  data item sub item bla here iam        true

User · Answer

This works with all objects and arrays     ex    if  obj  has   something   deep    under   1  0  item              do something     this is my improved version of Brian s answer   I used  has as the property name because it can conflict with existing has property  ex  maps   Object defineProperty  Object prototype    has     value  function  needle     var obj   this  var needles   needle split         var needles full     var needles square  for  var i   0  i lt needles length  i           needles square   needles i  split             if needles square length gt 1           for  var j   0  j lt needles square length  j                   if needles square j  length                   needles full push needles square j                                 else          needles full push needles i            for  var i   0  i lt needles full length  i           var res   needles full i  match      d                            if  res    null            for  var j   0  j  lt  res length  j                  if  res j     undefined                    needles full i    res j                                      if  typeof obj needles full i     undefined             return false            obj   obj needles full i      return true         Here s the fiddle

User · Answer

Update  Looks like lodash has added   get for all your nested property getting needs     get countries   greece sparta playwright     https   lodash com docs get    Previous answer  lodash users may enjoy lodash contrib which has a couple methods that mitigate this problem   getPath  Signature    getPath obj Object  ks String Array   Gets the value at any depth in a nested object based on the path described by the keys given  Keys may be given as an array or as a dot-separated string  Returns undefined if the path cannot be reached   var countries             greece                athens                    playwright    Sophocles                                      getPath countries   greece athens playwright         gt   Sophocles     getPath countries   greece sparta playwright         gt  undefined    getPath countries    greece    athens    playwright          gt   Sophocles     getPath countries    greece    sparta    playwright          gt  undefined

User · Answer

Quite a lot of answers but still  why not simpler   An es5 version of getting the value would be   function value obj  keys        if  obj     undefined  return obj      if  keys length     1  amp  amp  obj hasOwnProperty keys 0    return obj keys 0        return value obj keys shift     keys      if  value test    level1    level2    level3            do something     you could also use it with value config    applet   i   height       42  Credits to CMS for his ES6 solution that gave me this idea

User · Answer

And yet another one which is very compact   function ifSet object  path      return path split      reduce  obj  part    gt  obj  amp  amp  obj part   object      called   let a    b  c  d  e  found       ifSet a   b c d e       found   ifSet a   a a a a a a      undefined   It won t perform great since it s splitting a string  but increases readability of the call  and iterates over everything even if it s already obvious that nothing will be found  but increases readability of the function itself    at least is faster than   get http   jsben ch aAtmc

User · Answer

ES6 answer  thoroughly tested     const propExists    obj  path    gt        return   path split      reduce  obj  prop    gt            return obj  amp  amp  obj prop    obj prop    undefined         obj       see Codepen with full test coverage

User · Answer

I think this is a slight improvement  becomes a 1-liner       alert  test level1  amp  amp  test level1 level2  amp  amp  test level1 level2 level3     This works because the  amp  amp  operator returns the final operand it evaluated  and it short-circuits

User · Answer

There s a little pattern for this  but can get overwhelming at some times  I suggest you use it for two or three nested at a time   if    foo bar        weep  return     Return if there isn t a  foo bar  or  foo bar weep     As I maybe forgot to mention  you could also extend this further  Below example shows a check for nested foo bar weep woop or it would return if none are available   if     foo bar        weep        woop  return     So  return if there isn t a  foo bar    foo bar weep   or  foo bar weep woop      More than this would be overwhelming

User · Answer

My solution that I use since long time  using string unfortunaly  couldn t find better   function get if exist str       try return eval str       catch e  return undefined        way to use if get if exist  test level1 level2 level3          alert test level1 level2 level3         or simply  alert get if exist  test level1 level2 level3       edit  this work only if object  test  have global scope range  else you have to do something like        i think it s the most beautiful code I have ever write  p function get if exist obj       return arguments length  1     obj arguments 1    amp  amp  get if exist apply this  obj arguments 1    concat    slice call arguments 2         alert get if exist test  level1   level2   level3       edit final version to allow 2 method of call    function get if exist obj       var a arguments  b a callee     replace a callee by the function name you choose because callee is depreceate  in this case   get if exist        version 1 calling the version 2     if a 1   amp  amp   a 1  indexOf                return b apply this  obj  concat a 1  split                version 2     return a length  1   a 0     obj a 1    amp  amp  b apply this  obj a 1    concat    slice call a 2            method 1 get if exist test  level1 level2 level3         method 2 get if exist test  level1   level2   level3

User · Answer

I have created a little function to get nested object properties safely   function getValue object  path  fallback  fallbackOnFalsy        if   object     path            return fallback                Reduces object properties to the deepest property in the path argument      return path split      reduce  object  property    gt           if  object  amp  amp  typeof object      string   amp  amp  object hasOwnProperty property                    The property is found but it may be falsy                 If fallback is active for falsy values  the fallback is returned  otherwise the property value              return  object property   amp  amp  fallbackOnFalsy   fallback   object property             else                  Returns the fallback if current chain link does not exist or it does not contain the property              return fallback                   object       Or a simpler but slightly unreadable version   function getValue o  path  fb  fbFalsy       if  o     path  return fb     return path split      reduce  o  p    gt  o  amp  amp  typeof o      string   amp  amp  o hasOwnProperty p     o p   amp  amp  fbFalsy   fb   o p    fb  o       Or even shorter but without fallback on falsy flag   function getValue o  path  fb       if  o     path  return fb     return path split      reduce  o  p    gt  o  amp  amp  typeof o      string   amp  amp  o hasOwnProperty p    o p    fb  o       I have test with   const obj         c            a  2          b                c   1  2  3   a  15  b  10   15                     c  undefined          d  null            d         And here are some tests      null console log getValue obj   c d    fallback         array console log getValue obj   c b c    fallback         array index 2 console log getValue obj   c b c 2    fallback         no index   gt  fallback console log getValue obj   c b c 10    fallback       To see all the code with documentation and the tests I ve tried you can check my github gist  https   gist github com vsambor 3df9ad75ff3de489bbcb7b8c60beebf4 file-javascriptgetnestedvalues-js

User · Answer

Another option  close to this answer     function resolve root  path       try           return  new Function               root    return root     path                  root         catch  e        var tree     level1     key   value        resolve tree   level1 0  key        value  resolve tree   level1 1  key       undefined   More on this   https   stackoverflow com a 18381564 1636522

User · Answer

I was looking for the value to be returned if the property exists  so I modified the answer by CMS above  Here s what I came up with    x000D   x000D  function getNestedProperty obj  key    x000D       Get property array from key string x000D    var properties   key split       x000D   x000D       Iterate through properties  returning undefined if object is null or property doesn t exist x000D    for  var i   0  i  lt  properties length  i      x000D      if   obj     obj hasOwnProperty properties i      x000D        return  x000D        x000D      obj   obj properties i    x000D      x000D   x000D       Nested property found  so return the value x000D    return obj  x000D    x000D   x000D   x000D  Usage  x000D   x000D  getNestedProperty test   level1 level2 level3       level3  x000D  getNestedProperty test   level1 level2 foo      undefined x000D   x000D   x000D

User · Answer

getValue  o  key1  key2  key3  key4  key5        try         return o key1  key2  key3  key4  key5        catch  e          return null

User · Answer

I automated the process  if isset object   prop1   prop2         YES      function isset object  props       var dump      try           for var x in props               if x    0                    dump   object props x                    return                            dump   dump props x                    catch e            return false             return true

User · Answer

The answer given by CMS works fine with the following modification for null checks as well  function checkNested obj     level1  level2      levelN                          var args   Array prototype slice call arguments                obj   args shift                 for  var i   0  i  lt  args length  i                                   if  obj    null     obj hasOwnProperty args i                                            return false                                    obj   obj args i                              return true

User · Answer

Here s a little helper function I use that  to me  is pretty simple and straightforward  Hopefully it s helpful to some      static issetFromIndices param  indices  throwException   false        var temp   param       try           if   param                throw  Parameter is null                       if  Array isArray indices                 throw  Indices parameter must be an array                       for  var i   0  i  lt  indices length  i                  var index   indices i               if  typeof temp index       undefined                     throw       index      index is undefined                                temp   temp index                   catch  e            if  throwException                throw new Error e             else               return false                       return temp     var person         hobbies            guitar                type   electric                      var indices     hobbies    guitar    type    var throwException   true   try       var hobbyGuitarType   issetFromIndices person  indices  throwException       console log  Yay  found index      hobbyGuitarType     catch e        console log e

User · Answer

Well there are no really good answer for one-liners to use in html templates  so i made one using ES6 Proxies   You just pass an object or value to the  traverse  function and do as much nested calls as you want closing them with function call which will return value or fallback value  Using    x000D   x000D  const testObject      x000D    deep     x000D      nested     x000D        obj     x000D          closure       gt    return  closure     x000D          number  9  x000D          boolean  true  x000D          array   1  2    foo    bar  true      x000D           x000D        x000D      x000D    x000D   x000D  traverse testObject  deep    x000D      nested         x000D   x000D  traverse testObject  non existent    x000D     undefined x000D   x000D  traverse testObject  deep nested obj closure      x000D     closure x000D   x000D  traverse testObject  deep nested obj array 5   fallback   x000D     fallback x000D   x000D  traverse testObject  deep nested obj array 2    x000D      foo         x000D   x000D  traverse testObject  deep nested obj array 2  foo bar   x000D     true x000D   x000D  traverse testObject  deep nested obj array 2  foo bar 4   fallback   x000D     fallback x000D   x000D  traverse testObject  completely wrong 3  call   WILL THROW   x000D     Uncaught TypeError  Cannot read property  WILL THROW  of undefined x000D   x000D   x000D    Function itself    x000D   x000D  const traverse    input    gt    x000D         unique empty object x000D      const unset   new Object    x000D         we need wrapper to ensure we have access to the same unique empty object x000D      const closure    input    gt    x000D             wrap each input into this x000D          const handler   new Function    x000D          handler input   input      x000D             return wrappers proxy  x000D          return new Proxy handler    x000D                 keep traversing x000D              get   target  name    gt    x000D                     if undefined supplied as initial input x000D                  if   target input    x000D                      return closure unset   x000D                    x000D                     otherwise x000D                  if  target input name      undefined    x000D                         input has that property x000D                      return closure target input name    x000D                    else   x000D                      return closure unset   x000D                    x000D                 x000D                 result with fallback x000D              apply   target  context  args    gt    x000D                  return handler input     unset    x000D                      args 0    handler input  x000D                x000D             x000D        x000D      return closure input       x000D    x000D   x000D   x000D

User · Answer

The very best and simplest answer is   var isDefinedPath   function  path         var items   path split             if   items    items length  lt  1      items 0  in window     return false         var buffer    items 0        for  var i   1  e   items length  i  lt  e  i               buffer push  items i            if  eval   typeof     buffer join                undefined                   return false                       return true       test   isDefinedPath   level1 level2 level3     first level cannot be array  others can

User · Answer

I didn t see any example of someone using Proxies  So I came up with my own  The great thing about it is that you don t have to interpolate strings  You can actually return a chain-able object function and do some magical things with it  You can even call functions and get array indexes to check for deep objects   x000D   x000D  function resolve target    x000D    var noop        gt        We us a noop function so we can call methods also x000D    return new Proxy noop    x000D      get noop  key    x000D           return end result if key is  result x000D        return key       result   x000D            target  x000D            resolve     resolve with target value or undefined x000D              target     undefined   undefined   target key  x000D              x000D         x000D   x000D         if we want to test a function then we can do so alos thanks to using noop x000D         instead of using target in our proxy x000D      apply noop  that  args    x000D        return resolve typeof target      function    target apply that  args    undefined  x000D         x000D       x000D    x000D   x000D     some modified examples from the accepted answer x000D  var test    level1   level2      gt    level3  level3      x000D  var test1    key1   key2    item0     x000D   x000D     You need to get  result in the end to get the final result x000D   x000D  console log resolve test  level1 level2   level3  result  x000D  console log resolve test  level1 level2   level3 level4 level5  result  x000D  console log resolve test1  key1 key2 0   result  x000D  console log resolve test1  0  key  result     don t exist x000D   x000D   x000D    The above code works fine for synchronous stuff  But how would you test something that is asynchronous like this ajax call  How do you test that  what if the response isn t json when it returns a 500 http error   window fetch  https   httpbin org get    then function response      return response json       then function json      console log json headers  User-Agent         sure you could use async await to get rid of some callbacks  But what if you could do it even more magically  something that looks like this   fetch  https   httpbin org get   json   headers  User-Agent     You probably wonder where all the promise  amp   then chains are    this could be blocking for all that you know    but using the same Proxy technique with promise you can actually test deeply nested complex path for it existence without ever writing a single function   x000D   x000D  function resolve target     x000D    return new Proxy      gt        x000D      get noop  key    x000D        return key      then    target then bind target    resolve  x000D          Promise resolve target  then target   gt    x000D            if  typeof target key       function   return target key  bind target  x000D            return target key  x000D             x000D          x000D         x000D   x000D      apply noop  that  args    x000D        return resolve target then result   gt    x000D          return result apply that  args  x000D            x000D         x000D       x000D    x000D   x000D     this feels very much synchronous but are still non blocking    x000D  resolve window     this will chain a noop function until you call then   x000D     fetch  https   httpbin org get   x000D     json   x000D     headers  User-Agent   x000D     then console log  console warn     you get a warning if it doesn t exist x000D     x000D     You could use this method also for the first test object x000D     also  but it would have to call  then   in the end x000D   x000D   x000D   x000D     Another example x000D  resolve window  x000D     fetch  https   httpbin org get items 4 amp items 2   x000D     json   x000D     args x000D     items x000D       nice that you can map an array item without even having it ready x000D     map n   gt    n   4   x000D     then console log  console warn     you get a warning if it doesn t exist x000D   x000D   x000D

User · Answer

Following options were elaborated starting from this answer  Same tree for both     var o     a    b    c  1            Stop searching when undefined  var u   undefined  o a   o a b   o a b c   u   u    1 o x   o x y   o x y z   u   u    undefined  o   o a     o   o b    o c   u   u    1     Ensure each level one by one  var     function  empty        return function  node            return node    empty                     o a  b  c    1     o x  y  z    undefined

User · Answer

You can do this by using the recursive function  This will work even if you don t know all nested Object keys name   function FetchKeys obj        let objKeys           let keyValues   Object entries obj       for  let i in keyValues            objKeys push keyValues i  0            if  typeof keyValues i  1      object                 var keys   FetchKeys keyValues i  1               objKeys   objKeys concat keys                       return objKeys     let test     level1    level2    level3   level3         let keyToCheck    level2   let keys   FetchKeys test     Will return an array of Keys  if  keys indexOf keyToCheck     -1          Key Exists logic    else         Key Not Found logic

User · Answer

Another way to work this out is for example  having the following object    var x         a            b  3            then  what I did was add the following function to this object    x getKey   function k           var r           try               r   eval  typeof this   k        undefined              catch e               r   false                    if r     false               return eval  this   k            else              console error  Missing key      k                    return                        then you can test    x getKey  a b      If it s undefined the function returns     empty string  else it returns the existing value   Please also consider this other more complex solution checking the link   JS object has property deep check  Object prototype hasOwnNestedProperty   function propertyPath       if  propertyPath          return false       var properties   propertyPath split           var obj   this       for  var i   0  i  lt  properties length  i              var prop   properties i            if  obj     obj hasOwnProperty prop                return false            else               obj   obj prop                        return true         Usage   var obj        innerObject          deepObject              value  Here am I                   obj hasOwnNestedProperty  innerObject deepObject value      P S   There is also a recursive version

User · Answer

Based on this answer  I came up with this generic function using ES2015 which would solve the problem  function validChain  object     keys         return keys reduce    a  b     gt    a           b    object       undefined     var test       first        second            third   This is not the key your are looking for               if   validChain  test   first    second    third            console log  test first second third

User · Answer

You can read an object property at any depth  if you handle the name like a string   t level1 level2 level3    window t  level1  level2  level3   level3       function deeptest s       s  s split          var obj  window s shift         while obj  amp  amp  s length  obj  obj s shift         return obj     alert deeptest  t level1 level2 level3       Undefined      It returns undefined if any of the segments is undefined

User · Answer

Now we can also use reduce to loop through nested keys     x000D   x000D      params o lt object gt  x000D      params path lt string gt  expects  obj prop1 prop2 prop3  x000D     returns  obj path  value or  false  if prop doesn t exist x000D   x000D  const objPropIfExists   o   gt  path   gt    x000D    const levels   path split       x000D    const res    levels length  gt  0   x000D        levels reduce  a  c    gt  a c     0  o  x000D        o path   x000D    return    res    res   false x000D    x000D   x000D  const obj     x000D    name   Name   x000D    sys    country   AU     x000D    main    temp   34   temp min   13     x000D    visibility   35   x000D    x000D   x000D  const exists   objPropIfExists obj   main temp   x000D  const doesntExist   objPropIfExists obj   main temp foo bar baz   x000D   x000D  console log exists  doesntExist  x000D   x000D   x000D

User · Answer

I thought I d add another one that I came up with today  The reason I am proud of this solution is that it avoids nested brackets that are used in many solutions such as Object Wrap  by Oliver Steele     in this example I use an underscore as a placeholder variable  but any variable name will work    x000D   x000D    the  test  object x000D  var test    level1   level2   level3   level3      x000D   x000D  let     test  x000D   x000D  if       level1   amp  amp       level2   amp  amp       level3     x000D   x000D    let level3      x000D      do stuff with level3 x000D   x000D    x000D   x000D   x000D     x000D   x000D    you could also use  stacked  if statements  This helps if your object goes very deep   x000D     formatted without nesting or curly braces except the last one  x000D   x000D  let     test  x000D   x000D  if      level1  x000D  if      level2  x000D  if      level3    x000D   x000D     let level3      x000D       do stuff with level3 x000D    x000D   x000D   x000D    or you can indent  x000D  if      level1  x000D    if      level2  x000D      if      level3    x000D   x000D        let level3      x000D          do stuff with level3 x000D    x000D   x000D   x000D

User · Answer

CMS solution works great but usage syntax can be more convenient  I suggest following  var checkNested   function obj  structure       var args   structure split          for  var i   0  i  lt  args length  i          if   obj     obj hasOwnProperty args i            return false            obj   obj args i          return true       You can simply use object notation using dot instead of supplying multiple arguments  var test    level1  level2  level3  level3        checkNested test   level1 level2 level3       true checkNested test   level1 level2 foo       false

User · Answer

Yet another version   function nestedPropertyExists obj  props        var prop   props shift        return prop     undefined           true           obj hasOwnProperty prop    nestedPropertyExists obj prop   props    false     nestedPropertyExists  a  b  c 1       a   b   c        returns true nestedPropertyExists  a  b  c 1       a   b   c   d        returns false

User · Answer

create a global function and use in whole project   try this   x000D   x000D  function isExist arg   x000D     try  x000D        return arg    x000D      catch e   x000D        return false  x000D       x000D    x000D   x000D  let obj  a 5 b  c 5    x000D   x000D  console log isExist     gt obj b c   x000D  console log isExist     gt obj b foo   x000D  console log isExist     gt obj test foo   x000D   x000D   x000D    if condition  if isExist     gt obj test foo

User · Answer

Simply use https   www npmjs com package js-aid package for checking for the nested object

User · Answer

I think the following script gives more readable representation   declare a function   var o   function obj    return obj            then use it like this   if  o o o o test  level1  level2  level3         I call it  sad clown technique  because it is using sign o     EDIT   here is a version for TypeScript   it gives type checks at compile time  as well as the intellisense if you use a tool like Visual Studio   export function o lt T gt  someObject  T  defaultValue  T      as T    T       if  typeof someObject      undefined     someObject     null          return defaultValue      else         return someObject      the usage is the same   o o o o test  level1  level2  level3   but this time intellisense works    plus  you can set a default value   o o o o o test  level1  level2  level3   none

User · Answer

One simple way is this   try       alert test level1 level2 level3     catch e        alert  undefined          this is optional to put any output here     The try catch catches the cases for when any of the higher level objects such as test  test level1  test level1 level2 are not defined

User · Answer

A shorter  ES5 version of  CMS s excellent answer      Check the obj has the keys in the order mentioned  Used for checking JSON results    var checkObjHasKeys   function obj  keys      var success   true    keys forEach  function key        if     obj hasOwnProperty key           success   false            obj   obj key          return success      With a similar test   var test     level1  level2  level3  result      utils checkObjHasKeys test    level1    level2    level3        true utils checkObjHasKeys test    level1    level2    foo        false

User · Answer

Based on  Stephane LaFl  che s answer  I came up with my alternative version of the script   Demo on JSFiddle  var obj     a    b    c   Hello World     resTest   potato   success   This path exists    checkForPathInObject   function object path value            var pathParts     path split                   result        false             Check if required parameters are set  if not  return false         if  object    typeof object     undefined      path    typeof path     string               return false             Loop through object keys to find a way to the path or check for value            If the property does not exist  set result to false            If the property is an object  update  object            Otherwise  update result            for var i 0 i lt pathParts length i                 var currentPathPart   pathParts i               if  object hasOwnProperty  currentPathPart                      result   false                else if  object  currentPathPart    amp  amp  path    pathParts i                     result   pathParts i                   break                else if typeof object  currentPathPart       object                     object   object  currentPathPart                  else                   result   object  currentPathPart                                                  if typeof value     undefined   amp  amp  value    result              return true          return result        Uncomment the lines below to test the script    alert  checkForPathInObject obj  a b c         Results  Hello World     alert  checkForPathInObject obj  a success         Returns false    alert  checkForPathInObject obj  resTest    potato         Returns true

User · Answer

Here is a pattern I picked up from Oliver Steele   var level3      test        level1        level2        level3  alert  level3      In fact that whole article is a discussion of how you can do this in javascript  He settles on using the above syntax  which isn t that hard to read once you get used to it  as an idiom

User · Answer

Just wrote this function today which does a deep search for a property in a nested object and returns the value at the property if found          Performs a deep search looking for the existence of a property in a     nested object  Supports namespaced search  Passing a string with    a parent sub-object where the property key may exist speeds up    search  for instance  Say you have a nested object and you know for     certain the property literal you re looking for is within a certain    sub-object  you can speed the search up by passing  level2Obj targetProp      param  object  obj Object to search     param  object  key Key to search for     return     Returns the value  if any  located at the key     var getPropByKey   function  obj  key         var ret   false  ns   key split               args   arguments          alen   args length          Search starting with provided namespace     if   ns length  gt  1             obj    libName  getPropByKey  obj  ns 0             key   ns 1                 Look for a property in the object     if   key in obj             return obj key         else           for   var o in obj                 if    libName  isPlainObject  obj o                        ret    libName  getPropByKey  obj o   key                    if   ret     0    ret     undefined    ret                         return ret                                                       return false

User · Answer

Slight edit to this answer to allow nested arrays in the path   x000D   x000D  var has   function  obj  key    x000D      return key split      every function  x    x000D          if  typeof obj     object     obj     null     x in obj  x000D              return false  x000D          if  obj constructor     Array   x000D              obj   obj 0   x000D          obj   obj x   x000D          return true  x000D          x000D    x000D   x000D   x000D    Check linked answer for usages

User · Answer

function propsExists arg      try       const result   arg          if  typeof result      undefined           return true            return false     catch  e        return false         This function will also test for 0  null  If they are present it will also return true  Example   x000D   x000D  function propsExists arg      try       const result   arg          if  typeof result      undefined           return true            return false     catch  e        return false         let obj       test        a  null      b  0      c  undefined      d  4      e   Hey       f       gt          g  5 4      h  false      i  true      j          k          l            a  1                 console log  obj test a   propsExists      gt  obj test a   console log  obj test b   propsExists      gt  obj test b   console log  obj test c   propsExists      gt  obj test c   console log  obj test d   propsExists      gt  obj test d   console log  obj test e   propsExists      gt  obj test e   console log  obj test f   propsExists      gt  obj test f   console log  obj test g   propsExists      gt  obj test g   console log  obj test h   propsExists      gt  obj test h   console log  obj test i   propsExists      gt  obj test i   console log  obj test j   propsExists      gt  obj test j   console log  obj test k   propsExists      gt  obj test k   console log  obj test l   propsExists      gt  obj test l   x000D   x000D   x000D

User · Answer

I tried a recursive approach   function objHasKeys obj  keys      var next   keys shift      return obj next   amp  amp     keys length    objHasKeys obj next   keys        The   keys length    kicks out of the recursion so it doesn t run the function with no keys left to test   Tests   obj       path        to          the            goodKey   hello                       console log objHasKeys obj    path    to    the    goodKey         true console log objHasKeys obj    path    to    the    badKey          undefined   I am using it to print a friendly html view of a bunch of objects with unknown key values  e g    var biosName   objHasKeys myObj   MachineInfo BiosInfo Name  split                      myObj MachineInfo BiosInfo Name                 unknown

User · Answer

you can path object and path seprated with       x000D   x000D  function checkPathExist obj  path    x000D    var pathArray  path split      x000D    for  var i of pathArray    x000D      if  Reflect get obj  i     x000D        obj   obj i   x000D     x000D       else  x000D    return false  x000D        x000D      x000D   return true  x000D    x000D   x000D  var test    level1  level2  level3  level3       x000D   x000D  console log  level1 level2 level3   gt    checkPathExist test   level1 level2 level3        true x000D  console log   level1 level2 foo   gt    checkPathExist test   level1 level2 foo        false x000D   x000D   x000D

User · Answer

Another way          This API will return particular object value from JSON Object hierarchy         param jsonData   json type   JSON data from which we want to get particular object     param objHierarchy   string type   Hierarchical representation of object we want to get                           For example   jsonData Envelope Body  quot return quot   patient  OR  jsonData Envelope return patient                           Minimal Requirements    X Y  required      returns evaluated value of objHierarchy from jsonData passed      function evalJSONData jsonData  objHierarchy            if  jsonData     objHierarchy           return null                 if objHierarchy indexOf    quot return quot         -1           objHierarchy   objHierarchy replace    quot return quot      return                   let objArray   objHierarchy split  quot   quot        if objArray length     2           return jsonData objArray 1              return evalJSONData jsonData objArray 1    objHierarchy substring objHierarchy indexOf  quot   quot   1

User · Answer

I have done performance tests  thank you cdMinix for adding lodash  on some of the suggestions proposed to this question with the results listed below   Disclaimer  1 Turning strings into references is unnecessary meta-programming and probably best avoided  Don t lose track of your references to begin with  Read more from this answer to a similar question  Disclaimer  2 We are talking about millions of operations per millisecond here  It is very unlikely any of these would make much difference in most use cases  Choose whichever makes the most sense knowing the limitations of each  For me I would go with something like reduce out of convenience   Object Wrap  by Oliver Steele      34       fastest var r1      test        level1        level2        level3  var r2      test        level1        level2        foo   Original solution  suggested in question      45  var r1   test level1  amp  amp  test level1 level2  amp  amp  test level1 level2 level3  var r2   test level1  amp  amp  test level1 level2  amp  amp  test level1 level2 foo   checkNested     50  function checkNested obj      for  var i   1  i  lt  arguments length  i          if   obj hasOwnProperty arguments i            return false            obj   obj arguments i          return true     get if exist     52  function get if exist str        try   return eval str        catch e    return undefined      validChain     54  function validChain  object     keys         return keys reduce    a  b     gt    a           b    object       undefined     objHasKeys     63  function objHasKeys obj  keys      var next   keys shift      return obj next   amp  amp     keys length    objHasKeys obj next   keys       nestedPropertyExists     69  function nestedPropertyExists obj  props        var prop   props shift        return prop     undefined   true   obj hasOwnProperty prop    nestedPropertyExists obj prop   props    false       get     72  deeptest     86  function deeptest target  s       s  s split          var obj  target s shift         while obj  amp  amp  s length  obj  obj s shift         return obj     sad clowns     100      slowest var o   function obj    return obj           var r1   o o o o test  level1  level2  level3   var r2   o o o o test  level1  level2  foo

User · Answer

theres a function here on thecodeabode  safeRead  which will do this in a safe manner    i e   safeRead test   level1    level2    level3      if any property is null or undefined  an empty string is returned

User · Answer

function isIn string  object       var arr   string split           var notFound   true      var length   arr length      for  var i   0  i  lt  length  i             var key   arr i           if   object hasOwnProperty key                notFound   false              break                    if   i   length   lt   length               object   object key                       return notFound    var musicCollection         hasslehoff            greatestHits   true          console log isIn  hasslehoff greatestHits   musicCollection    console log isIn  hasslehoff worseHits   musicCollection      here my String based delimiter version

User · Answer

In typeScript you can do something like this    if  object prop1  amp  amp  object prop1 prop2  amp  amp  object prop1 prop2 prop3        const items   object prop1 prop2 prop3     console log items

User · Answer

Another ES5 solution   function hasProperties object  properties        return  properties some function property           if   object hasOwnProperty property                 return true                    object   object property           return false

User · Answer

I know this question is old  but I wanted to offer an extension by adding this to all objects  I know people tend to frown on using the Object prototype for extended object functionality  but I don t find anything easier than doing this  Plus  it s now allowed for with the Object defineProperty method   Object defineProperty  Object prototype   has     value  function  needle         var obj   this      var needles   needle split             for  var i   0  i lt needles length  i               if   obj hasOwnProperty needles i                  return false                    obj   obj needles i              return true         Now  in order to test for any property in any object you can simply do   if  obj has  some deep nested object somewhere       Here s a jsfiddle to test it out  and in particular it includes some jQuery that breaks if you modify the Object prototype directly because of the property becoming enumerable  This should work fine with 3rd party libraries

User · Answer

method getValue     description simplifies checking for existance and getting a deeply nested value within a ceratin context     argument  string  s       string representation of the full path to the requested property      argument  object  context optional - the context to check defaults to window     returns the value if valid and set  returns undefined if invalid   not available etc      var getValue   function  s  context        var fn   function            try              return eval s            catch e               return undefined                      return fn call context  window s       and usage    if  getValue  a 0  b 0  b 0  d      2      true

User · Answer

Here s my take on it - most of these solutions ignore the case of a nested array as in       obj              l1   something            l2    k 0   k 1             l3                 subL   hello                    I may want to check for obj l2 0  k  With the function below  you can do deeptest  l2 0  k  obj   The function will return true if the object exists  false otherwise   x000D   x000D  function deeptest keyPath  testObj    x000D      var obj  x000D   x000D      keyPath   keyPath split      x000D      var cKey   keyPath shift    x000D   x000D      function get pObj  pKey    x000D          var bracketStart  bracketEnd  o  x000D   x000D          bracketStart   pKey indexOf       x000D          if  bracketStart  gt  -1      check for nested arrays x000D              bracketEnd   pKey indexOf       x000D              var arrIndex   pKey substr bracketStart   1  bracketEnd - bracketStart - 1   x000D              pKey   pKey substr 0  bracketStart   x000D     var n   pObj pKey   x000D              o   n  n arrIndex    undefined  x000D   x000D            else   x000D              o   pObj pKey   x000D            x000D          return o  x000D        x000D   x000D      obj   get testObj  cKey   x000D      while  obj  amp  amp  keyPath length    x000D          obj   get obj  keyPath shift     x000D        x000D      return typeof obj       undefined   x000D    x000D   x000D  var obj     x000D       l1   level1   x000D       arr1    x000D            k  0   x000D            k  1   x000D            k  2  x000D         x000D       sub     x000D           a   letter A   x000D           b   letter B  x000D        x000D     x000D  console log  l1      deeptest  l1  obj    x000D  console log  arr1 0       deeptest  arr1 0   obj    x000D  console log  arr1 1  k      deeptest  arr1 1  k  obj    x000D  console log  arr1 1  j      deeptest  arr1 1  j  obj    x000D  console log  arr1 3       deeptest  arr1 3   obj    x000D  console log  arr2      deeptest  arr2  obj    x000D   x000D   x000D

User · Answer

You have to do it step by step if you don t want a TypeError because if one of the members is null or undefined  and you try to access a member  an exception will be thrown   You can either simply catch the exception  or make a function to test the existence of multiple levels  something like this   function checkNested obj     level1  level2      levelN        var args   Array prototype slice call arguments  1      for  var i   0  i  lt  args length  i          if   obj     obj hasOwnProperty args i            return false            obj   obj args i          return true     var test    level1  level2  level3  level3        checkNested test   level1    level2    level3       true checkNested test   level1    level2    foo       false   ES6 UPDATE   Here is a shorter version of the original function  using ES6 features and recursion  it s also in proper tail call form    function checkNested obj  level      rest      if  obj     undefined  return false   if  rest length    0  amp  amp  obj hasOwnProperty level   return true   return checkNested obj level      rest      However  if you want to get the value of a nested property and not only check its existence  here is a simple one-line function    x000D   x000D  function getNested obj     args    x000D    return args reduce  obj  level    gt  obj  amp  amp  obj level   obj  x000D    x000D   x000D  const test     level1   level2   level3  level3        x000D  console log getNested test   level1    level2    level3         level3  x000D  console log getNested test   level1    level2    level3    length        6 x000D  console log getNested test   level1    level2    foo        undefined x000D  console log getNested test   a    b        undefined x000D   x000D   x000D    The above function allows you to get the value of nested properties  otherwise will return undefined   UPDATE 2019-10-17   The optional chaining proposal reached Stage 3 on the ECMAScript committee process  this will allow you to safely access deeply nested properties  by using the token     the new optional chaining operator   const value   obj  level1  level2  level3    If any of the levels accessed is null or undefined the expression will resolve to undefined by itself   The proposal also allows you to handle method calls safely   obj  level1  method      The above expression will produce undefined if obj  obj level1  or obj level1 method are null or undefined  otherwise it will call the function   You can start playing with this feature with Babel using the optional chaining plugin   Since Babel 7 8 0  ES2020 is supported by default  Check this example on the Babel REPL   UPDATE  December 2019   The optional chaining proposal finally reached Stage 4 in the December 2019 meeting of the TC39 committee  This means this feature will be part of the ECMAScript 2020 Standard

User · Answer

Based on a previous comment  here is another version where the main object could not be defined either      Supposing that our property is at first second third property  var property      typeof first      undefined    first       second        third        property

[javascript] Test for existence of nested JavaScript object key

Examples related to javascript

Examples related to object

Examples related to properties

Examples related to nested