Sintaxis básica de JavaScript: sentencias, llaves y punto y coma

Publicado: 26/11/2025 Por: Juan Felipe Orozco Cortés
📚 Contenido de la guía ⌃

Antes de hablar de frameworks, promesas o APIs modernas, hay tres piezas de la sintaxis de JavaScript que mandan sobre todo lo demás: las sentencias, las llaves { } y el punto y coma ;. Entender cómo piensa el motor sobre estos tres elementos evita bugs raros, código confuso y horas de depuración.

En esta guía vamos a construir un mapa mental de la sintaxis básica: qué es realmente una sentencia, cómo agrupan código las llaves, cuándo es obligatorio el punto y coma y qué problemas produce la “inserción automática de punto y coma” (ASI). La idea no es aprender reglas de memoria, sino entender cómo lee el motor tu código para que puedas escribir JavaScript más claro y predecible.

El mapa mental de la sintaxis: sentencias, bloques y terminadores ✍️

Cuando escribes JavaScript, el motor ve tu archivo como una secuencia de piezas que se organizan más o menos así:

  • Expresiones: cosas que producen un valor (2 + 2, user.name, sum(1, 2)).
  • Sentencias (statements): instrucciones completas que el motor ejecuta (let x = 1;, if (...) { ... }, return 42;).
  • Bloques { }: grupos de sentencias que se ejecutan juntos (cuerpos de funciones, de if, de bucles).
  • Terminadores: el famoso ;, que indica dónde termina una sentencia… y donde empiezan muchos malentendidos.

Si tienes claro qué es una sentencia, qué hace un bloque y cuándo el punto y coma es necesario, el resto de la sintaxis se vuelve mucho más predecible.

Cómo piensa el motor de JavaScript

1. Expresiones Producen valores: números, strings, objetos, llamadas a funciones.
2. Sentencias Usan esas expresiones para hacer algo: declarar variables, decidir, devolver valores.
3. Bloques y punto y coma Las llaves agrupan sentencias; el punto y coma indica dónde termina cada una.
Figura 1: pensar en expresiones, sentencias y bloques hace que la sintaxis deje de ser un misterio.

Qué es una sentencia en JavaScript (y qué no lo es)

Una sentencia es una instrucción completa que el motor puede ejecutar por sí sola. Termina en un punto y coma ; (explícito o implícito) y responde a la idea de “haz esto”:

// Ejemplos de sentencias
let edad = 32;
const nombre = "Ana";

saludar(nombre);

if (edad >= 18) {
  console.log("Es mayor de edad");
}

return edad;

Cada una de esas líneas (o bloques) es una sentencia: el motor las ejecuta en orden, de arriba a abajo, dentro del bloque actual.

Expresión vs sentencia: la diferencia que aclara todo

Una expresión es algo que produce un valor, pero por sí sola no “hace” nada hasta que la usamos dentro de una sentencia:

// Expresión:
2 + 2

// Sentencia:
let resultado = 2 + 2;

La expresión 2 + 2 produce el valor 4. La sentencia let resultado = 2 + 2; declara una variable y le asigna ese valor. Entender esta diferencia ayuda a leer mejor if, while, for y muchos errores de sintaxis.

Tipo Ejemplo Comentario
Expresión user.age >= 18 Produce true o false.
Sentencia if (user.age >= 18) { ... } Usa la expresión para decidir qué bloque ejecutar.
Expresión sum(1, 2) Produce el resultado de la función.
Sentencia const total = sum(1, 2); Guarda el resultado en una variable.

Punto y coma: por qué JavaScript “aguanta” sin él (y cuándo deja de hacerlo)

En muchos ejemplos verás código sin punto y coma al final de cada línea. Eso es posible porque JavaScript tiene una característica llamada ASI (Automatic Semicolon Insertion): cuando el motor detecta el final de una sentencia, puede insertar un punto y coma por ti.

Por ejemplo, estos dos fragmentos se comportan igual:

// Con punto y coma explícito
let x = 1;
let y = 2;
console.log(x + y);

// Con ASI (el motor inserta los ;)
let x = 1
let y = 2
console.log(x + y)

Hasta aquí, todo bien. El problema es que no siempre coincide tu intuición con las reglas reales de ASI, y ahí nacen bugs muy sutiles.

Regla práctica: en proyectos serios, usa siempre punto y coma explícito. Reduce sorpresas con ASI, hace los diffs más claros y evita varios bugs históricos.

Tres casos en los que ASI puede romper tu código

Veamos ejemplos reales donde faltar un punto y coma cambia el significado del programa.

1) return en su propia línea

function obtenerUsuario() {
  return
  {
    nombre: "Ana"
  }
}

A primera vista parece que la función devuelve un objeto. Pero el motor ve esto así:

function obtenerUsuario() {
  return; // ← aquí inserta el punto y coma
  {
    nombre: "Ana"
  }
}

Resultado: la función devuelve undefined y el objeto nunca se usa. Por eso es buena práctica no dejar el valor de return en la siguiente línea o, al menos, usar siempre punto y coma consistente.

2) Líneas que empiezan con (, [ o /

Si una línea termina sin punto y coma y la siguiente empieza con ( o [, el motor puede interpretarlo como una llamada o acceso al resultado anterior:

const fn = () => {}
[1, 2, 3].forEach(n => console.log(n))

El motor puede leerlo así:

const fn = () => {};
[1, 2, 3].forEach(...)

Lo que es algo completamente distinto a lo que querías. Un simple ; al final de la primera línea lo evita:

const fn = () => {};
[1, 2, 3].forEach(n => console.log(n));

3) Funciones autoejecutadas (IIFE)

const x = 1
(function () {
  console.log("Hola");
})();

Estás viendo solo el 60% del contenido. ¡Únete a la Membresía Premium! para acceder al contenido completo.

← Volver a Guías

Comentarios y Valoraciones

No hay comentarios aún. ¡Sé el primero en opinar!

Por favor espere...