DEV Community

Karen Molina
Karen Molina

Posted on Edited on

Prepárate para tu entrevista frontend: variables, tipos de dato, scope y hoisting en JavaScript

Actualizado en 2026. Escribí la primera versión de este post en 2021, cuando estaba aprendiendo y preparándome para entrevistas. Lo reescribí con lo que sé hoy como ingeniera frontend: explicaciones más claras, errores corregidos y respuestas modelo para entrevistas.

¡Hola de nuevo! :3

Variables, tipos de dato, scope y hoisting salen en casi todas las entrevistas de JavaScript. No porque sean difíciles, sino porque muestran si entiendes cómo funciona el lenguaje o solo cómo hacer que corra.

Y es que casi todo lo que hacemos es trabajar con datos: los que vienen de nuestros servicios o los que nos da el usuario. No hay forma de escaparles, así que vale la pena entenderlos bien.

Vamos uno por uno, y cada sección termina con cómo responderlo en una entrevista.

Tipos de dato

En JavaScript hay dos familias: los primitivos y los objetos.

Primitivos

Son valores simples e inmutables: no puedes cambiar un primitivo, solo reemplazarlo por otro. Hay siete:

Tipo Qué representa Ejemplo
string Texto "Hola olla"
number Enteros y decimales (punto flotante de 64 bits) 42, 3.14
bigint Enteros más grandes de lo que number puede representar con precisión 9007199254740993n
boolean Verdadero o falso true, false
undefined Una variable declarada sin valor asignado let x;
null La ausencia intencional de valor let usuario = null;
symbol Un identificador único, útil como llave de objetos Symbol("id")

Dos detalles que a los entrevistadores les encantan:

0.1 + 0.2                 // 0.30000000000000004 (punto flotante)
Number.MAX_SAFE_INTEGER   // 9007199254740991, o sea 2^53 - 1
2n ** 64n                 // 18446744073709551616n (bigint sí puede)

typeof null               // "object" (un error histórico: null es primitivo)
Enter fullscreen mode Exit fullscreen mode

Objetos

Todo lo que no es primitivo es un objeto: objetos, arreglos, funciones, fechas, Map, Set. Los objetos son mutables y se manejan por referencia (lo vemos al final).

Respuesta para la entrevista: "JavaScript tiene siete tipos primitivos (string, number, bigint, boolean, undefined, null y symbol), que son inmutables y se copian por valor. Todo lo demás es un objeto, mutable y compartido por referencia. Un detalle clásico es que typeof null regresa 'object'."

Variables: var, let y const

var let const
Scope Función Bloque { } Bloque { }
¿Se puede reasignar? Sí Sí No
¿Se puede redeclarar en el mismo scope? Sí No No
Si la usas antes de declararla undefined ReferenceError ReferenceError

var

La forma original, antes de ES6 (2015). En la primera versión de este post dije que su problema era la reasignación, pero let también se puede reasignar. Los problemas reales de var son que:

  • se puede redeclarar sin que nadie te avise,
  • ignora los bloques { } y solo respeta el scope de función,
  • existe antes de su declaración, con valor undefined.
var saludo = "Hola olla";
var saludo = "Hi!"; // sin error: lo pisaste sin darte cuenta

if (true) {
  var secreto = "se escapa";
}
console.log(secreto); // "se escapa"
Enter fullscreen mode Exit fullscreen mode

let

Llegó con ES6. Se puede reasignar, pero no redeclarar, y solo existe dentro del bloque donde la declaras.

let saludo = "Hola olla";
saludo = "Hi!";        // ✅ reasignar está bien

if (true) {
  let secreto = "se queda aquí";
}
console.log(secreto);  // ❌ ReferenceError: secreto is not defined
Enter fullscreen mode Exit fullscreen mode

Si la redeclaras en el mismo scope, es un SyntaxError: el archivo completo no se ejecuta, no solo esa línea.

const

No se puede reasignar ni redeclarar. Pero aquí está la trampa que buscan los entrevistadores: const no hace inmutable un valor. Solo impide que la variable apunte a otro valor.

const gato = { name: "Simón" };

gato = { name: "Tito" }; // ❌ TypeError: Assignment to constant variable.
gato.name = "Tito";      // ✅ funciona: mismo objeto, otra propiedad

const frutas = ["Manzana", "Pera"];
frutas.push("Melón");    // ✅ también funciona
Enter fullscreen mode Exit fullscreen mode

Si necesitas un objeto que de verdad no cambie, usa Object.freeze().

Respuesta para la entrevista: "var tiene scope de función, se puede redeclarar y al hacer hoisting se inicializa como undefined. let y const tienen scope de bloque y no se pueden redeclarar. const no se puede reasignar, pero si guarda un objeto, el objeto sí se puede modificar. En la práctica uso const por defecto, let cuando necesito reasignar y evito var."

Scope

El scope define desde dónde se puede acceder a una variable.

  • Global: declarada fuera de cualquier función, bloque o módulo. Se ve desde todos lados. Úsalo lo menos posible.
  • De función: lo que declaras dentro de una función solo existe ahí. A veces se le llama scope local.
  • De bloque: con let y const, lo que declaras dentro de { } (un if, un for) solo existe ahí.
  • De módulo: en un módulo de ES, las variables de nivel superior no son globales. Solo existen en ese archivo, y otros archivos solo pueden usar lo que exportes explícitamente.
const global = "me ven todos";

function saludar() {
  const deFuncion = "solo dentro de saludar";

  if (true) {
    const deBloque = "solo dentro del if";
    console.log(global, deFuncion, deBloque); // ✅ todo visible
  }

  console.log(deBloque); // ❌ ReferenceError
}
Enter fullscreen mode Exit fullscreen mode

La regla clave: un scope interno puede ver hacia afuera, pero uno externo no puede ver hacia adentro. A esa cadena de búsqueda se le llama scope chain, y es la base de los closures.

Respuesta para la entrevista: "El scope determina dónde se puede acceder a una variable. JavaScript tiene scope global, de función, de bloque y de módulo. Cuando se usa una variable, el motor la busca en el scope actual y luego hacia afuera por la scope chain. Un scope interno puede acceder a variables externas, nunca al revés."

Hoisting

Hoisting es de las cosas más raras de JS, y en parte por cómo se suele explicar.

Seguro has escuchado que "las declaraciones se mueven hasta arriba". El código no se mueve. Lo que pasa es que, antes de ejecutar tu código, el motor hace una fase de creación donde registra en memoria todas las declaraciones de cada scope. Por eso algunas cosas se pueden usar antes de la línea donde están escritas. (En la versión original de este post ya lo intuía: "ese elevamiento no es literal". Ahora vamos al detalle.)

Cada tipo de declaración se comporta distinto:

console.log(a);       // undefined
var a = 1;

console.log(b);       // ❌ ReferenceError: Cannot access 'b' before initialization
let b = 2;

console.log(saludo()); // "hola"
function saludo() { return "hola"; }

despedida();          // ❌ TypeError: despedida is not a function
var despedida = function () { return "adiós"; };
Enter fullscreen mode Exit fullscreen mode
Declaración ¿Hace hoisting? Antes de su línea
var Sí undefined
let / const Sí, pero sin inicializar ReferenceError
Declaración de función Sí, completa Se puede llamar
Expresión de función con var Solo la variable undefined, llamarla da TypeError
class Sí, pero sin inicializar ReferenceError

La temporal dead zone

let, const y class sí hacen hoisting, pero no se inicializan. El tiempo entre el inicio del scope y la línea donde se declaran se llama temporal dead zone (TDZ). Si tocas la variable en esa zona, obtienes un ReferenceError.

La TDZ no es un bug, es una ayuda: atrapa los errores de "usar antes de definir" que var convierte en un undefined silencioso.

Respuesta para la entrevista: "Hoisting significa que las declaraciones se registran en memoria antes de ejecutar el código, así que existen desde el inicio de su scope. var se inicializa como undefined, las declaraciones de función están disponibles completas, y let, const y las clases hacen hoisting pero quedan sin inicializar en la temporal dead zone hasta su declaración, por eso usarlas antes lanza un ReferenceError. El código en sí no se mueve."

Extra: valor vs. referencia

Esta causa bugs reales, sobre todo en React.

// Los primitivos se copian por valor
let a = 1;
let b = a;
a = 2;
console.log(b); // 1

// Los objetos comparten la referencia
const fruta = { name: "Fresa" };
const mismaFruta = fruta;
fruta.name = "Manzana";
console.log(mismaFruta.name); // "Manzana" 😱

// Si necesitas una copia independiente
const copia = { ...fruta };
const copiaProfunda = structuredClone(fruta);
Enter fullscreen mode Exit fullscreen mode

Por eso en React no se muta el estado directamente: si cambias el mismo objeto, la referencia no cambia y React puede no volver a renderizar.

Checklist antes de tu entrevista

  • [ ] ¿Puedes nombrar los siete primitivos?
  • [ ] ¿Sabes por qué typeof null es "object"?
  • [ ] ¿Puedes explicar var, let y const en una frase cada una?
  • [ ] ¿Puedes demostrar que un objeto en const sí puede cambiar?
  • [ ] ¿Puedes describir la scope chain?
  • [ ] ¿Puedes explicar hoisting sin decir "el código se mueve hasta arriba"?
  • [ ] ¿Sabes qué es la temporal dead zone?

Gracias por leer, y como siempre, con gusto espero feedback :D

¿Qué concepto de JS te costó más trabajo entender al principio? Cuéntame en los comentarios 👇

Top comments (0)