Recursive Contains

recursive_contains.js

// solution to problem #6 in recursive exercises
function contains(object, searchValue) {
  // because `null` has a typof "object", we have to explicitly check
  // to prevent trying to access `null`'s values (which don't exist)
  if (typeof object !== "object" || object === null) {
    return object === searchValue;
  }

  for (const value of Object.values(object)) {
    // An important problem in the code quiz solution is that `return contains()` will only
    // search the first property of an object, as it will return whatever the result for it is.
    // If our value was nested within the second property, for example, it would never get checked
    // even if the first nested object did not contain it.
    if (contains(value, searchValue)) {
      return true;
    }
  }
  return false;
}

Came up with this function myself:

function contains(obj, targetVal) {
  for (const currentVal of Object.values(obj)) {
    if (typeof currentVal === "object") {
      return contains(currentVal, targetVal);
    }
    if (currentVal === targetVal) return true;
  }
  return false;
}

Felt quite good about it even though I knew that a null could very easily render it useless. But then I realised that I could just change the third line to: if (typeof currentVal === "object" && currentVal !== null) { to prevent that from happening.

I thought I needed to search for the keys and values:

function contains(obj, item) {
if (Object.values(obj).length === 0) return false;
else if (item in obj || Object.values(obj).includes(item)) return true;
else {
for (let value of Object.values(obj)) {
return contains(value, item);
}
}
}