Return object that matches specific branch traversal

This question started here

The conversation exceeded the original scope, so asking the expanded question here.

Given this data:

{
"tabs-3": {
    "Collection A": {
        "Level 2": {
            "Data A": {
                "tab3graph25": {
                    "30/04": 21750,
                    "31/03": 19428,
                    "29/05": 20955
                }
            }
        }
    }
    "Collection B": {
        "Level 2": {
            "Data A": {
                "tab3graph33": {
                    "30/04": 56863,
                    "31/03": 62298,
                    "29/05": 56044
                }
            }
        }
    }
    "Collection C": {
        "Level 2": {
            "Data A": {
                "tab3graph40": {
                    "30/04": 56044,
                    "31/03": 62298,
                    "29/05": 56863
                }
            }
        }
    }
}

}

What would a function look like that would take as it's input the holding object to search, in this case, "tabs-3", and a key set to look for, e.g., var searchList = [Collection B, Level 2, Data A] and then return "tab3graph33:{...values...}

The original starting function I have is here for reference ,

function searchObjectForValues(obj, searchList) {
  var matchingObjects = {};

  function recursiveSearch(currentObj, path) {
    if (typeof currentObj === 'object' && currentObj !== null) {
      for (var key in currentObj) {
        if (currentObj.hasOwnProperty(key)) {
          var value = currentObj[key];
          var currentPath = path.concat(key);

          if (searchList.includes(key)) {
            matchingObjects[key] = currentObj[key];
          }

          recursiveSearch(value, currentPath);
        }
      }
    }
  }

  recursiveSearch(obj, []);

  return matchingObjects;
}

Although the answers in the original question are much more elegant than mine.

We can write a fairly simple recursive function for this. Utility libraries usually include one, too, if you're already using something like Underscore or Ramda.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const getPath = (
) => (o) =>
  p == undefined ? o : getPath(ps) (o && o
)

const data = {"tabs-3": {"Collection A": {"Level 2": {"Data A": {tab3graph25: {"30/04": 21750, "31/03": 19428, "29/05": 20955}}}}, "Collection B": {"Level 2": {"Data A": {tab3graph33: {"30/04": 56863, "31/03": 62298, "29/05": 56044}}}}, "Collection C": {"Level 2": {"Data A": {tab3graph40: {"30/04": 56044, "31/03": 62298, "29/05": 56863}}}}}}


const tabs3 = data['tabs-3']
console .log ('Partial path:', getPath (['Collection B', 'Level 2', 'Data A'])(tabs3))

// or
console .log ('Full-path:', getPath (['tabs-3', 'Collection B', 'Level 2', 'Data A'])(data))

<!-- language: lang-css -->

.as-console-wrapper {max-height: 100% !important; top: 0}

<!-- end snippet -->

The first console.log shows how you would use this the way you seem to want, with a reference to the object in the 'tabs-3' property of your data. The second one shows my preferred way, using 'tabs-3' as one more property in the list.

Here's a fun get function which accepts * and ** wildcards. Given this data -

const data = {
  a: {
    b: {
      x: {y:1, z:2},
      y: {z:3},
    },
    c: {
      x: {y:4},
      y: {z:5},
    },
    d: {x:6},
  },
  b: {c: {z:7}}
}

We can write get as a recursive generator -

function *get(t, path) {
  function *loop(t, path, match, wild) {
    if (path.length === 0)
      yield [match, t]
    else if (path[0] === "**")
      yield *loop(t, path.slice(1), match, true)
    else if (Object(t) === t)
      for (const k of Object.keys(t))
        if (path[0] === "*" || path[0] === k)
          yield *loop(t[k], path.slice(1), [...match, k], false)
        else if (wild)
          yield *loop(t[k], path, [...match, k], true)
  }
  yield *loop(t, path, [], false)
}

Search for a path starting with a, followed by one wildcard, followed by x -

for (const [path, value] of get(data, ["a","*","x"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

["a","b","x"] {"y":1,"z":2}
["a","c","x"] {"y":4}
["a","d","x"] 6

Search for any path ending in z -

for (const [path, value] of get(data, ["**","z"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

["a","b","x","z"] 2
["a","b","y","z"] 3
["a","c","y","z"] 5
["b","c","z"] 7

Get full path a, c, x, y -

for (const [path, value] of get(data, ["a","c","x","y"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

["a","c","x","y"] 4

Make complex patterns -

for (const [path, value] of get(data, ["*","b","**","y"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

["a","b","x","y"] 1
["a","b","y"] {"z":3}

Get non-existent path -

for (const [path, value] of get(data, ["x","y","z"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

// <empty result>

Verify the results below in your own browser -

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

function *get(t, path) {
  function *loop(t, path, match, wild) {
    if (path.length === 0)
      yield [match, t]
    else if (path[0] === "**")
      yield *loop(t, path.slice(1), match, true)
    else if (Object(t) === t)
      for (const k of Object.keys(t))
        if (path[0] === "*" || path[0] === k)
          yield *loop(t[k], path.slice(1), [...match, k], false)
        else if (wild)
          yield *loop(t[k], path, [...match, k], true)
  }
  yield *loop(t, path, [], false)
}

const data = {
  a: {
    b: {
      x: {y:1, z:2},
      y: {z:3},
    },
    c: {
      x: {y:4},
      y: {z:5},
    },
    d: {x:6},
  },
  b: {c: {z:7}}
}

for (const [path, value] of get(data, ["a","*","x"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )
  
for (const [path, value] of get(data, ["**","z"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )
  
for (const [path, value] of get(data, ["a","c","x","y"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )
  
for (const [path, value] of get(data, ["x","y","z"]))
  console.log(
    JSON.stringify(path),
    JSON.stringify(value)
  )

<!-- language: lang-css -->

.as-console-wrapper { min-height: 100%; top: 0; }

<!-- end snippet -->

sans generators

Here's the same solution without using generators. The interface is identical however it always returns an array instead of an iterator -

function get(t, path) {
  const loop = (t, path, match, wild) =>
    path.length === 0
      ? [[match, t]]
  : path[0] === "**"
      ? loop(t, path.slice (1), match, true)
  : Object(t) === t
      ? Object.keys(t).flatMap(k =>
          path[0] === "*" || path[0] === k
            ? loop(t[k], path.slice (1), [...match, k], false)
        : wild
            ? loop(t[k], path, [...match, k], true)
        : []
        )
  : []
  return loop(t, path, [], false)
}