Safely Access Nested Object Properties

In JavaScript, objects can have deeply nested structures. Accessing these nested properties often involves chained property lookups (e.g., obj.a.b.c). However, if any intermediate property is null or undefined, this will throw a TypeError, breaking your program. This challenge focuses on creating a robust function to safely retrieve values from nested objects using a string path.

Problem Description

You need to implement a JavaScript function getPropertyByPath that takes two arguments: an object and a string representing the path to the desired property. The function should return the value at the specified path. If the path is invalid (i.e., any part of the path leads to null or undefined), the function should gracefully return undefined without throwing an error.

Key Requirements:

• The function must accept an object and a string path.
• The path string will use dot notation (e.g., "user.address.street").
• The function should traverse the object based on the path segments.
• If at any point during traversal a segment is null or undefined, the function should immediately return undefined.
• If the path is empty or the input object is not a valid object, the behavior should be handled gracefully (returning undefined is a good default).

Expected Behavior:

• Successfully retrieve a nested property.
• Return undefined for invalid paths.
• Return undefined if the input object is null or undefined.
• Handle paths that resolve to null or undefined values.

Examples

Example 1:

const user = {
  name: "Alice",
  details: {
    age: 30,
    address: {
      street: "123 Main St",
      city: "Anytown"
    }
  }
};

const path = "details.address.street";
// Expected Output: "123 Main St"

Explanation: The function traverses user.details.address.street and returns the value "123 Main St".

Example 2:

const product = {
  id: 101,
  info: {
    price: 50.00,
    tags: ["electronics", "gadget"]
  }
};

const path = "info.tags";
// Expected Output: ["electronics", "gadget"]

Explanation: The function successfully retrieves the array associated with the path "info.tags".

Example 3:

const data = {
  user: {
    name: "Bob"
  }
};

const path = "user.profile.email";
// Expected Output: undefined

Explanation: The profile property within user is undefined. The function stops traversal and returns undefined.

Example 4:

const settings = {
  theme: "dark",
  preferences: null
};

const path = "preferences.fontSize";
// Expected Output: undefined

Explanation: The preferences property is null. Attempting to access fontSize on null would normally throw an error, but the function returns undefined.

Example 5:

const person = {
  firstName: "Charlie"
};

const path = ""; // Empty path
// Expected Output: undefined

Explanation: An empty path is considered invalid, and the function returns undefined.

Example 6:

const config = null;
const path = "server.port";
// Expected Output: undefined

Explanation: The input object itself is null. The function returns undefined.

Constraints

• The path string will consist of alphanumeric characters and dots (.) only.
• The path will not start or end with a dot.
• The path will not contain consecutive dots (e.g., ..).
• The input object can be any valid JavaScript object, including null or undefined.
• Performance: The solution should be efficient, especially for deeply nested objects.

Notes

Consider how to handle an empty path string. A good default would be to return undefined. You'll likely want to split the path string into individual property names and iterate through the object. Think about the various conditions under which you should stop traversing and return undefined.