Object names

As Alex Wayne explains: Objects will only have names "as part of your data model."

Or in other words: An object's name is what you associate it with.

That association may come from within or from outside. Example:

// Name by self-definition
const someObject = { name: "self-named" };

// Name by association
const nameToObject = { "associated-name": {} };

Looking up by name

To avoid adding unnecessary properties to your objects, I'll use the "name by association" approach:

const objects = { object1, object2 };

Sidenote: In this shorthand object initialization, the identifiers are used as property names and their references as the properties' values.

With this, an implementation is straightforward:

const object1 = new class Object1 {
  get property1() { return "foo"; }
  get property2() { return "bar"; }
};
const object2 = new class Object1 {
  get different1() { return "asdf"; }
  get different2() { return "ghjk"; }
};

const objects = { object1, object2 };

// The implementation
function getPropertyValue(objectName, propertyName) {
  return objects[objectName][propertyName];
}

const value = getPropertyValue("object1", "property2");
console.log(value);

Adding Typescript

To add proper typing, we need to think about how the output depends on the inputs. But also, how the inputs depend on each other.

A naive implementation may look like this:

function getPropertyValue(
  objectName: "object1" | "object2",
  propertyName: "property1" | "property2" | "different1" | "different2"
): any;

But this doesn't fully use what Typescript is capable of. Only a subset of propertyName's original types can be used depending on objectName's value: propertyName depends on objectName.

Since there is one dependency between function parameters, we need a generic parameter to link them.

We already know which value of objectName corresponds to which type, thanks to our dictionary. We only need to restrict propertyName to that type's keys:

type Objects = typeof objects;

function getPropertyValue<
  K extends keyof Objects
>(
  objectName: K,
  propertyName: keyof Objects[K]
);

When calling this function, K will be inferred from objectName by default, and automatically restrict our options for propertyName according to our typing.

Addendum

Name by identifier?

While (especially const declared) variables can reference objects, their identifier –that is the variable name– is usually not considered their referenced object's name. For good reason!

You cannot easily look up objects through an identifier. To do so requires either new Function or eval(), which are known for having security issues.

Therefore, please see the following as a demonstration, not recommendation:

const object1 = { name: "Object-1" };
const object2 = { name: "Object-2" };

const o = getObjectByName("object1");
console.log(o);

function getObjectByName(name) {
  // You should avoid new Function!
  return new Function(`return ${name};`)();
}

for...in, for...of, what for?

There are multiple for loops:

• The regular (or simple) for-loop with an initialization, condition and incrementation block.
• The for...of-loop to iterate through an iterable object.
• The for...in-loop to loop over enumerable properties.

Make sure you familiarize yourself with these!

Tip: In many cases you can use Object.keys() or .entries() instead of a for...in-loop, which avoids confusion with for...of-loops.

Namespace pollution!

We don't want to instantiate objects for every function call, which means it needs to be outside that function.

But naively moving it outside pollutes the namespace.

Instead, we can make use of a closure to instantiate it only once, but keep it hidden from the global scope:

// Mock imports
const object1 = { property1: "foo", property2: "bar" };
const object2 = { different1: "asdf", different2: "ghjk" };

const getPropertyValue = (() => {
  const objects = { object1, object2 };
  
  return function(objectName, propertyName) {
    return objects[objectName][propertyName];
  };
})();

const value = getPropertyValue("object1", "property2");
console.log(value);
console.log(objects);