How to return an object whose nested objects match a list of search strings?

I'm trying to return an object that is a collection of objects that match a given list of search strings.

Testing Data Structure

var data = {
  "tabs-1": {
    "test 1": {
      "test 2": {
        "test 3a": {
          "tab1graph1": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3b": {
          "tab1graph2": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3c": {
          "tab1graph3": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        }
      }
    }
  }
};

Input

var searchList = ["apple", "orange", "test 3b", "test 3a"];

Current code that only returns one match, and not both expected matches:

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;
}

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

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

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;
}

var data = {
  "tabs-1": {
    "test 1": {
      "test 2": {
        "test 3a": {
          "tab1graph1": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3b": {
          "tab1graph2": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3c": {
          "tab1graph3": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        }
      }
    }
  }
};

var searchList = ["apple", "testx3", "test 3b", "test 3a"];

var result = searchObjectForValues(data, searchList);
console.log(result);

<!-- end snippet -->

How can I modify this function to return just the

"tab1graph1": {
    "String a": "value a",
    "String b": "value b",
    "String c": "value c"
}

part and not the "test 3a" above it?

simple composition

Performing a search for many values is a matter of calling search1 on each value -

function *search(data, values) {
  for (const value of values)
    yield *search1(data, value)
}

Writing search1 is now easier -

function *search1(data, value) {
  if (Object(data) === data) {
    for (const key of Object.keys(data)) {
      if (key === value)
        yield data[key]
      else
        yield *search1(data[key], value)
    }
  }
}

Now we call search with our data and search list -

var searchList = ["apple", "testx3", "test 3b", "test 3a"]

for (const result of search(data, searchList))
  console.log(result)

Each result is logged. Alternatively use Array.from to collect all results in an array -

{
  "tab1graph2": {
    "String a": "value a",
    "String b": "value b",
    "String c": "value c"
  }
}
{
  "tab1graph1": {
    "String a": "value a",
    "String b": "value b",
    "String c": "value c"
  }
}

demo

Verify the results in your own browser below -

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

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

const data = {
  "tabs-1": {
    "test 1": {
      "test 2": {
        "test 3a": {
          "tab1graph1": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3b": {
          "tab1graph2": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        },
        "test 3c": {
          "tab1graph3": {
            "String a": "value a",
            "String b": "value b",
            "String c": "value c"
          }
        }
      }
    }
  }
};

function *search1(data, value) {
  if (Object(data) === data) {
    for (const key of Object.keys(data)) {
      if (key === value)
        yield data[key]
      else
        yield *search1(data[key], value)
    }
  }
}

function *search(data, values) {
  for (const value of values)
    yield *search1(data, value)
}

var searchList = ["apple", "testx3", "test 3b", "test 3a"];

for (const result of search(data, searchList))
  console.log(result)

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

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

<!-- end snippet -->

higher-order function with predicate

Per @Scott's comment, the solution above can be adapted to use a predicate function -

function *search(data, predicate) {
  if (Object(data) === data) {
    for (const entry of Object.entries(data)) {
      if (predicate(entry))
        yield entry[1]
      else
        yield *search(entry[1], predicate)
    }
  }
}

Array.from(
  search(
    data,
    ([key, value]) => searchList.includes(key)
  )
)

sequential search

In a comment you seek the possibility to find sequential keys, for example key1->key2. To support this, we will change the single value field to path, which represents an array of strings.

function *search1(data, path) {
  if (key.length === 0)
    yield data
  else if (Object(data) === data) {
    for (const key of Object.keys(data)) {
      if (data[key] === path[0])
        yield *search1(data[key], path.slice(1))
      else
        yield *search1(data[key], path)
    }
  }
}

search stays the same but now you call it with an array of paths -

for (const result of search(data, [
  ["test 1", "test 3a"], // test 1 -> test 3a
  ["test 2", "String a"] // test 2 -> String a
]) {
  console.log(result)
}

{                               //
  "tab1graph1": {               //
    "String a": "value a",      // matches for:
    "String b": "value b",      // test 1 -> test 3a
    "String c": "value c"       //
  }                             //
}                               //
value a               // matches for:
value a               // test 2 -> String a
value a               // 

One approach is to write a fairly generic deepFilter function which includes in its output array all nodes -- at whatever depth -- that match the predicate function supplied. Then we can configure it with a predicate function that matches against your list of search keys, and call it with your data:

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

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

const deepFilter = (pred) => (o) => 
  Object(o) === o
    ? Object.entries(o).flatMap(([k, v]) => [
        ...(pred(v, k) ? [v] : []),
        ...deepFilter(pred) (v)
      ])
    : []

const deepFindKeys = (keys) =>
  deepFilter((_, k) => keys.includes(k))

const data = {"tabs-1": {"test 1": {"test 2": {"test 3a": {tab1graph1: {"String a": "value a", "String b": "value b", "String c": "value c"}}, "test 3b": {tab1graph2: {"String a": "value a", "String b": "value b", "String c": "value c"}}, "test 3c": {tab1graph3: {"String a": "value a", "String b": "value b", "String c": "value c"}}}}}}

console.log(deepFindKeys(["apple", "testx3", "test 3b", "test 3a"])(data))

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

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

<!-- end snippet -->

Our function deepFindKeys takes the keys and returns the function returned when we pass a simple key-matching predicate to deepFilter. deepFilter has the real substance. If the input is not an object, we return an empty array. If it is, we flatmap its entries, for each one, including the value if the predicate matches and recurring on the value.

Most commonly when we want to search to match a predicate, we want to test the value, not the key, so the predicate is supplied the value first; it can ignore the key if it wants. Here we actually want to test the key and ignore the value, so we pass (_, k) where the _ calls attention to the fact that we just want to skip the first value.

A Comparison

The answer from Mulan is quite different from this one. They introduce different sorts of flexibility. In deepFilter, the main function here, we use a generic approach to how we wish to match our objects. It makes this reusable across a wide swath of search functions. But it will always traverse the entire tree. There's no way to stop after, say, the first five hits.

Mulan's search and search1 are generator functions. While the solution is less general than mine, focusing on this specific problem, it offers another very useful feature: it returns a iterator letting us pull and process the entries individually, which can be very powerful. And because you can simply turn the results back into an array if you don't want the iteration, it's at least as powerful

The thing to note is that Mulan's solution could easily be enhanced to handle the same sort of flexibility mine has. The reverse is not true. To try to make this version into a generator function would be an entire rewrite.

I'm not trying to say that Mulan's approach is universally better. If you only ever want an array result, this version is simpler (and probably more time-efficient). But Mulan's can be made to offer some flexibility this one simply cannot.