Implementing Object.assign from scratch

Object.assign copies own enumerable properties from one or more source objects onto a target, mutates it, and returns it. Later sources overwrite earlier ones.

What the interviewer checks

• Do you skip null/undefined sources without throwing?
• Do you copy only own enumerable properties, not inherited ones?
• Do you copy symbol keys too? Most candidates miss this.

Implementation

Open in editorCopy
Object.myAssign = function (target, ...sources) {
  if (target === null || target === undefined) {
    throw new TypeError("Cannot convert undefined or null to object");
  }

  const to = Object(target);

  for (const source of sources) {
    if (source === null || source === undefined) continue;

    const from = Object(source);
    // Reflect.ownKeys gets string keys AND symbol keys
    for (const key of Reflect.ownKeys(from)) {
      const descriptor = Object.getOwnPropertyDescriptor(from, key);
      if (descriptor && descriptor.enumerable) {
        to[key] = from[key];
      }
    }
  }

  return to;
};

Why Reflect.ownKeys instead of Object.keys

Object.keys returns only own enumerable string keys.
Reflect.ownKeys returns own enumerable and non-enumerable string and symbol keys.

After getting all keys, we still check descriptor.enumerable to skip non-enumerable ones.

Open in editorCopy
const sym = Symbol("x");
const source = { a: 1, [sym]: 2 };

Object.keys(source);        // ["a"]        — sym is missing
Reflect.ownKeys(source);    // ["a", sym]   — both present

Shallow copy caveat

Nested objects are copied by reference, not cloned:

Open in editorCopy
const source = { nested: { x: 1 } };
const target = Object.myAssign({}, source);
target.nested === source.nested; // true — same reference
target.nested.x = 99;           // mutates source.nested too

Always mention this in an interview — it distinguishes assign from a deep clone.

Edge cases to mention

• target is null/undefined → throws TypeError
• Sources that are null/undefined → silently skipped
• Prototype-inherited properties are not copied
• Non-enumerable properties are not copied
• Symbol-keyed properties are copied (via Reflect.ownKeys)