Preguntas de entrevista de JavaScript — 50 con código y respuestas

Es un bug histórico del lenguaje que nunca se corrigió por retrocompatibilidad. En la implementación original de JavaScript (1995), los valores se representaban con un tag de tipo en los primeros bits. El tag para objetos era 000, y null era representado como un puntero nulo (todos ceros), por lo que el tipo se leía como 'object'. Para detectar null correctamente usá `val === null`.

`call` invoca la función de inmediato con `this` y argumentos separados por coma: `fn.call(ctx, arg1, arg2)`. `apply` hace lo mismo pero los argumentos van en un array: `fn.apply(ctx, [arg1, arg2])`. `bind` no invoca la función — devuelve una nueva función con `this` fijado: `const fn2 = fn.bind(ctx)`. Usá `bind` cuando necesitás pasar una función como callback manteniendo el contexto.

`Promise.all` rechaza tan pronto como cualquiera de las promesas falla (fail-fast). Usalo cuando necesitás todos los resultados y una falla invalida todo. `Promise.allSettled` espera que todas terminen (éxito o error) y devuelve un array con el status de cada una. Usalo cuando necesitás procesar cada resultado por separado sin que una falla cancele las demás.

Es el período entre el inicio del scope y la línea de declaración de una variable `let` o `const`. Durante ese período, la variable existe en el scope (fue izada) pero no se puede acceder — cualquier acceso tira `ReferenceError`. Esto es distinto a `var`, que se inicializa como `undefined` durante el hoisting. El TDZ existe para detectar errores de uso antes de declaración.

`async/await` es más legible para flujos secuenciales con manejo de errores con try/catch. Promesas encadenadas con `.then()` son más idiomáticas cuando estás transformando datos en pipeline o cuando necesitás fan-out (Promise.all, Promise.race). En la práctica: usá `async/await` para la mayoría de los casos y `Promise.all` dentro de funciones async cuando necesitás paralelismo.

El operador `+` con objetos los convierte a primitivos usando `toString()`. `[].toString()` devuelve `""` (array vacío a string es string vacío), por eso `[] + []` es `"" + ""` = `""`. `{}.toString()` devuelve `"[object Object]"`, por eso `[] + {}` es `"" + "[object Object]"` = `"[object Object]"`. El caso `{} + []` es especial: si `{}` está al inicio de una línea, JavaScript lo parsea como un bloque vacío, no un objeto, y el resultado es `+[]` = `0`.

Una copia superficial (shallow) duplica el primer nivel del objeto, pero los valores anidados siguen siendo referencias compartidas. Si modificás un objeto anidado en la copia, se modifica en el original también. El spread `{...obj}` y `Object.assign` hacen copias superficiales. Una copia profunda (deep) duplica todos los niveles. Usá `structuredClone(obj)` para deep copy nativa y moderna, o `JSON.parse(JSON.stringify(obj))` para objetos simples sin funciones, dates o undefined.

Las arrow functions no tienen su propio `this` — lo heredan del scope léxico donde se definen. El operador `new` necesita crear un objeto nuevo y asignárselo a `this` de la función constructora. Como las arrows no tienen `this` propio, `new ArrowFn()` tira `TypeError: ArrowFn is not a constructor`. Además, las arrows no tienen `prototype`, que es el objeto del que heredarían las instancias creadas con `new`.