JavaScript
Diferencia las expresiones que producen valores de las sentencias que controlan acciones, incluyendo bloques, asignaciones y punto y coma.
JavaScript está formado por piezas que producen valores y piezas que indican acciones.
2 + 3; // Expresión: produce 5.
const total = 2 + 3; // Sentencia que declara una variable.Una expresión es cualquier fragmento de código que JavaScript puede evaluar para obtener un valor.
42;
"JavaScript";
true;Los literales anteriores ya son expresiones porque cada uno representa un valor.
También son expresiones:
10 + 5;
age >= 18;
user.name;
calculateTotal();
condition ? "Sí" : "No";Cada una produce un resultado:
10 + 5; // 15
age >= 18; // true o false
user.name; // El valor de name.
calculateTotal(); // El valor retornado.
condition ? "Sí" : "No"; // Uno de los dos strings.Una expresión grande suele estar formada por expresiones más pequeñas.
const total = price * quantity + shipping;Dentro aparecen:
price;
quantity;
price * quantity;
shipping;
price * quantity + shipping;JavaScript evalúa las piezas necesarias hasta obtener el valor final.
Una sentencia es una instrucción completa que controla o modifica la ejecución del programa.
const name = "Nicolás";Esta sentencia declara una variable.
Otros ejemplos:
if (isAuthenticated) {
showDashboard();
}
for (const product of products) {
console.log(product.name);
}
return total;Estas sentencias permiten declarar, decidir, repetir, retornar o interrumpir el flujo.
Crean variables, funciones o clases.
const tax = 0.19;
let count = 0;
function calculateTotal() {}
class Product {}Deciden qué se ejecuta o cuántas veces.
if (stock > 0) {
enablePurchase();
}while (hasPendingTasks) {
processNextTask();
}Cambian el recorrido normal del programa.
return result;
break;
continue;
throw new Error("Invalid data");Cada una tiene un contexto válido. Por ejemplo, return solo puede usarse dentro de una función.
Una expresión puede utilizarse como una sentencia completa.
sendEmail();
count++;
user.name = "Nico";Las tres líneas contienen expresiones, pero se escriben como instrucciones independientes porque interesa su efecto:
El valor producido existe, aunque normalmente se ignore.
const result = (count++);Esta línea sí conserva el valor que produjo la expresión.
Un bloque agrupa cero o más sentencias entre llaves.
{
const subtotal = price * quantity;
const total = subtotal + shipping;
console.log(total);
}Los bloques aparecen en condicionales, bucles, funciones y otras estructuras.
if (hasPermission) {
openSettings();
trackAccess();
}Además de agrupar instrucciones, un bloque crea un scope para variables declaradas con let y const.
Una expresión puede colocarse donde JavaScript necesita un valor.
const total = price * quantity;La parte derecha de = debe producir un valor.
showMessage(isAdmin ? "Administrador" : "Usuario");El argumento de la función también debe ser una expresión.
const settings = {
theme: preferredTheme ?? "system",
};El valor de una propiedad también es una expresión.
No puedes colocar una sentencia como if directamente donde se espera un valor:
// No es sintaxis válida.
const message = if (isAdmin) {
"Administrador";
} else {
"Usuario";
};Para escoger un valor puede usarse un ternario o una función:
const message = isAdmin ? "Administrador" : "Usuario";function getRoleLabel(isAdmin) {
if (isAdmin) {
return "Administrador";
}
return "Usuario";
}La asignación es una expresión.
const result = (score = 10);
console.log(result); // 10Esto permite encadenar asignaciones:
let first;
let second;
first = second = 0;Primero second recibe 0; después first recibe el resultado de esa asignación.
Aunque es válido, puede ser menos claro que escribir dos líneas:
first = 0;
second = 0;La claridad debe pesar más que reducir caracteres.
El punto y coma marca el final de muchas sentencias.
const name = "Nicolás";
console.log(name);JavaScript tiene Automatic Semicolon Insertion, un conjunto de reglas que inserta puntos y coma en ciertos lugares cuando no se escriben.
Por eso este código suele funcionar:
const name = "Nicolás"
console.log(name)Sin embargo, no significa que JavaScript coloque un punto y coma al final de cada línea. Algunas combinaciones pueden interpretarse de una forma inesperada.
const value = getValue()
[1, 2, 3].forEach(console.log)Sin una configuración y un formato consistentes, JavaScript podría intentar interpretar la segunda línea como continuación de la primera.
La decisión práctica es simple:
const subtotal = items.reduce(
(total, item) => total + item.price * item.quantity,
0,
);
const hasFreeShipping = subtotal >= 100;
const shipping = hasFreeShipping ? 0 : 10;
const total = subtotal + shipping;
if (total > balance) {
showInsufficientBalance();
} else {
confirmOrder(total);
}En este código:
const son sentencias.if es una sentencia que controla la ejecución.if, for o return donde se espera un valor.Clasifica cada fragmento como expresión, sentencia o ambos según su uso:
10 * 2;
const total = 10 * 2;
user.name;
updateUser();
if (isReady) {
start();
}
count += 1;10 * 2 es una expresión utilizada como sentencia.const total = 10 * 2 es una sentencia de declaración que contiene una expresión.user.name es una expresión utilizada como sentencia.updateUser() es una expresión de llamada utilizada como sentencia.if (...) { ... } es una sentencia de control.count += 1 es una expresión de asignación utilizada como sentencia.Condicionales explica cómo ejecutar diferentes bloques según el resultado de una condición.