Implementing Array.prototype.flat from scratch

flat flattens nested arrays up to a given depth. The default depth is 1, not Infinity. flat(Infinity) flattens completely.

What the interviewer checks

• Do you default depth to 1?
• Do you correctly decrement the depth counter through recursion?

Recursive implementation

Open in editorCopy
Array.prototype.myFlat = function (depth = 1) {
  const result = [];

  (function flatten(arr, currentDepth) {
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth > 0) {
        flatten(item, currentDepth - 1);
      } else {
        result.push(item);
      }
    }
  })(this, depth);

  return result;
};

Reduce-based one-liner (bonus)

Open in editorCopy
Array.prototype.myFlat = function (depth = 1) {
  return this.reduce((acc, item) => {
    if (Array.isArray(item) && depth > 0) {
      return acc.concat(item.myFlat(depth - 1));
    }
    return acc.concat(item);
  }, []);
};

The recursive IIFE version is clearer in interviews. Mention the reduce version as an alternative.

How depth works

Open in editorCopy
[1, [2, [3, 4]]].myFlat()        // depth 1 → [1, 2, [3, 4]]
[1, [2, [3, 4]]].myFlat(2)       // depth 2 → [1, 2, 3, 4]
[1, [2, [3, [4]]]].myFlat(Infinity) // fully → [1, 2, 3, 4]

Each level of recursion passes currentDepth - 1. When currentDepth reaches 0, nested arrays are pushed as-is.

Edge cases to mention

• Default depth is 1, not Infinity — this surprises people
• flat(0) returns a shallow copy with no flattening
• flat(Infinity) works because Infinity - 1 === Infinity, so the depth never reaches 0
• Does not skip holes: [1, , 3].myFlat() → [1, 3] (holes become absent in the result)