Deep Clone — JavaScript Challenge

Implement deepClone(value), a function that makes an independent deep copy of a JSON-compatible value. Objects and arrays can contain other objects and arrays at any depth. The copied data must have the same values, but changing any copied container must not affect the original. Build the clone by traversing the data yourself rather than using a serialization or cloning shortcut.

Requirements

Export a function named deepClone that accepts one JSON-compatible value: null, a boolean, a finite number, a string, a dense array of these values, or a plain object containing these values. Return a copy with the same structure and values.

Return primitives unchanged, including empty strings, false, zero, and negative zero. Create a fresh array or ordinary object for every container at every depth.

For objects, copy only own enumerable string-keyed properties. Preserve their names, including empty strings and reserved names such as "__proto__" and "constructor". Ignore non-enumerable and symbol-keyed properties.

For arrays, clone indexed elements in order and preserve the length. Sparse arrays and custom array properties are outside the scope.

Do not change the input. Frozen input must work, and all cloned containers must be independently mutable. Mutating either the original or its clone must not change the other.

Inputs may reuse the same object or array in several places but do not contain cycles. Clone each occurrence separately: deepClone({ a: shared, b: shared }) must produce independent a and b copies.

Use your own traversal. Do not use JSON.parse, JSON.stringify, structuredClone, or a cloning library. Recursion is recommended, but an iterative traversal is also acceptable.

This exercise copies JSON data, not arbitrary JavaScript objects. undefined, functions, symbols as values, BigInt, NaN, Infinity, Date, Map, Set, class instances, custom prototypes, accessors, and circular references are excluded. Input validation, preserving property descriptors, and handling unbounded depth are not required.

Examples

Example 1

Input: deepClone({ user: { name: "Ada" }, tags: ["js", "ts"] })
Output: { user: { name: "Ada" }, tags: ["js", "ts"] } — a new root, user object, and tags array

Example 2

Input: deepClone([1, [2, { active: false }], null])
Output: [1, [2, { active: false }], null] — every array and object is new

Example 3

Input: deepClone(null)
Output: null

Example 4

Input: const input = { settings: { theme: "light" } };
const copy = deepClone(input);
copy.settings.theme = "dark";
input.settings.theme;
Output: "light" — changing the clone leaves the input unchanged

Example 5

Input: const shared = { count: 1 };
const copy = deepClone({ a: shared, b: shared });
copy.a === copy.b;
Output: false — repeated references become separate copies

deepClone(value) returns the same primitive value or a new recursively copied container. The TypeScript signature deepClone<T extends JsonValue>(value: T): T retains the input data shape and accepts readonly JSON containers. Types do not preserve object identities: every array and object occurrence is copied independently. Cloned properties are ordinary writable data properties at runtime.