Expresiones vs sentencias

Antes de escribir funciones, condiciones o bucles, necesitas entender el ladrillo básico del lenguaje: la sentencia.

Y para comprender una sentencia, necesitas entender qué es una expresión.

Este fundamental te muestra la diferencia entre ambas y cómo se construyen las instrucciones en JavaScript.

Qué es una sentencia

Una sentencia (statement) es una instrucción completa que el motor de JavaScript puede ejecutar.

Ejemplos de sentencias:

let x = 5;

console.log(x);

if (x > 3) {
  console.log('x is greater than 3');
}

En otras palabras, una sentencia realiza una acción (hace algo): declara, asigna, evalúa, llama, compara...

La mayoría de los programas están compuestos de muchas sentencias, ejecutadas en orden.

Qué es una expresión

Una expresión (expression) es cualquier fragmento de código que produce un valor.

Ejemplos de expresiones:

42
x + 3
'Hello'.length
true && false

Todas estas devuelven un valor. Eso es lo que las define como expresiones.

Y una expresión puede estar dentro de una sentencia:

let result = x + 3;

Aquí x + 3 es una expresión. Toda la línea es una sentencia.

Diferencia clave

Una expresión produce un valor.

Una sentencia produce un efecto.

3 + 4         // expression (evaluates to 7)
let y = 3 + 4 // statement (performs an assignment)

JavaScript permite usar expresiones dentro de sentencias, porque las sentencias pueden contener valores evaluados como parte de su lógica.

let total = price * tax;       // statement that contains an expression
console.log(user.name);        // statement that uses an expression
if (points > 100) { ... }      // statement with a conditional expression

Pero no puedes usar una sentencia dentro de una expresión, porque las sentencias no devuelven un valor que pueda ser usado.

Esto no es válido:

let x = let y = 5;   // ❌ SyntaxError

Ni esto:

true ? let y = 2 : let y = 3;  // ❌ SyntaxError

Las expresiones producen un valor. Las sentencias no.

Esa es la razón por la que puedes colocar expresiones dentro de sentencias, pero no sentencias dentro de expresiones.

Un paralelismo con el lenguaje humano

Una expresión es como una palabra o una frase que tiene un significado.

Una sentencia es como una oración completa que afirma algo y tiene un efecto.

Ejemplo:

• "5 dollars" → expresión: tiene valor, pero no comunica una acción completa.
• "plus tax" → también una expresión parcial.
• "I will pay 5 dollars plus tax." → sentencia: tiene un sujeto, una acción, un efecto completo.

En JavaScript:

price * tax               // expression (evaluates to a value)
let total = price * tax   // statement (declares a variable and performs an action)

La expresión es parte de la sentencia, pero no son equivalentes.

Entender esta diferencia te da claridad cuando lees o escribes código real.

Tipos comunes de expresiones

JavaScript tiene muchos tipos de expresiones. Algunos ejemplos:

Expresión literal

'text'
true
99

Expresión aritmética

a * b
x + 1

Expresión lógica

isActive && isAdmin

Expresión de llamada

console.log('message')
getResult()

Expresión de asignación

total = subtotal + tax

Expresión condicional (ternaria)

score >= 100 ? 'Passed' : 'Try again'

Todo eso son expresiones porque devuelven un valor.

¿Por qué a veces aparece ; y a veces no?

JavaScript permite omitir el punto y coma (;) al final de una sentencia. Pero no siempre es buena idea.

El motor de JS hace algo llamado "inserción automática de punto y coma" (ASI - Automatic Semicolon Insertion).

Esto puede llevar a errores sutiles si no entiendes cómo funciona.

Ejemplo peligroso:

return
  {
    name: 'Alice'
  }

Parece que devuelve un objeto, pero en realidad devuelve undefined, porque JS inserta un ; justo después de return.

Lo correcto sería:

return {
  name: 'Alice'
}

Por eso se recomienda:

• Usar ; al final de cada sentencia si estás empezando
• Entender cómo funciona ASI si decides prescindir de ellos

¿Y los dos puntos :?

Los dos puntos aparecen en:

1. Objetos literales

const user = {
  name: 'Bob',
  age: 30
}

Aquí name: 'Bob' significa que la clave name tiene el valor 'Bob'.

2. Operador ternario

const status = age >= 18 ? 'Adult' : 'Minor';

En este caso, el : separa las dos ramas del operador ternario (condition ? if true : if false).

Cuándo una línea es una sentencia

En general, cualquier línea que no devuelva un valor por sí sola y que produzca un efecto en el programa es una sentencia.

Ejemplos:

let count = 10;

count++;

if (count > 5) { } // boolean expression inside

while (true) { }

En cambio, si puedes envolverlo en paréntesis y evaluarlo, es una expresión:

(count + 3)

(getUserName())

(true && false)

Algunas sentencias, como if, while o return, contienen expresiones que controlan su ejecución, pero la estructura completa sigue siendo una sentencia, porque produce un efecto en el flujo del programa.

Cómo saber si lo has entendido

Lee el siguiente fragmento e intenta separar qué es expresión y qué es sentencia:

let total = price * quantity;
if (total > 100) {
  applyDiscount(); // expression call used as sentence
}

Importante: todas las llamadas a función son expresiones, porque devuelven un valor. Cuando las usas solas en una línea, se evalúan como sentencia de expresión. Aunque no devuelvas nada, JavaScript retorna undefined por defecto.

Respuestas:

• price * quantity → expresión.
• let total = ... → sentencia.
• total > 100 → expresión.
• if (...) { ... } → sentencia.
• applyDiscoun() → expresión de llamada.

Enlaces útiles

• Statements and declarations (MDN)
• Automatic Semicolon Insertion (MDN)
• JavaScript expressions and operators (MDN)