JavaScript
Integra lenguaje, runtime, memoria, asincronía, módulos y Web APIs en un modelo mental para razonar sobre el comportamiento completo de JavaScript.
JavaScript se entiende mejor como un conjunto de capas conectadas, no como una lista de sintaxis aislada.
valores y bindings
↓
expresiones y control
↓
scopes y contextos
↓
funciones y closures
↓
objetos y prototipos
↓
colecciones e iteración
↓
errores y contratos
↓
Event Loop y promesas
↓
módulos y dependencias
↓
APIs del host
↓
memoria, rendimiento y seguridadconst product = {
id: "p1",
price: 100,
};const crea un binding.const impide reasignar el binding, no modificar el objeto.let value = 10;
value = "ten";Los valores tienen tipos; una variable no queda ligada para siempre a uno.
La flexibilidad exige contratos claros y validación en fronteras.
const total = price * quantity;Las sentencias controlan ejecución:
if (total > limit) {
throw new RangeError("Limit exceeded");
}const tax = 0.19;
function calculate(price) {
return price + price * tax;
}La función resuelve tax según el lugar donde fue definida, no desde donde se llama.
scope actual
↓
scope exterior
↓
global o módulocalculate(100);Se crea un contexto con parámetros, variables y referencias léxicas. El Call Stack organiza llamadas activas.
Al retornar, el frame sale del stack; los datos capturados por closures pueden continuar alcanzables.
function createValidator(limit) {
return (value) => value <= limit;
}Pueden:
Una callback no es asíncrona por definición; depende de quien la invoque.
const user = Object.create(baseUser);Si una propiedad no existe en user, JavaScript recorre su cadena de prototipos.
Las clases organizan este modelo; no lo reemplazan.
class User {
greet() {}
}greet vive normalmente en User.prototype.
object.method();El receptor determina this en una función normal.
const method = object.method;
method();Extraerla pierde ese receptor. Las arrow functions capturan this léxicamente.
Array → orden y posición
Map → clave-valor dinámica
Set → valores únicos
WeakMap → metadatos ligados a una clave vivaElegir la estructura adecuada simplifica algoritmos y comunica intención.
for (const value of iterable) {}Un iterable sabe crear un recorrido. Un iterador entrega valores. Un generator facilita producir secuencias pausables.
La iteración asíncrona añade espera entre pasos.
function requireProduct(id) {
const product = findProduct(id);
if (!product) {
throw new ProductNotFoundError(id);
}
return product;
}No todo resultado negativo es una excepción. El contrato decide si la ausencia es normal o impide continuar.
Capturar no significa resolver; una capa maneja solo aquello que comprende.
motor
+ Call Stack
+ Event Loop
+ APIs del hostEl lenguaje no incluye DOM, fetch o localStorage.
El host ejecuta operaciones externas y encola continuaciones.
Una callback actual termina antes de que otra task empiece en el mismo agente.
console.log("A");
setTimeout(() => console.log("B"), 0);
console.log("C");A
C
BPromise.resolve().then(() => {
console.log("microtask");
});Promesas y continuaciones de await utilizan jobs procesados como microtasks en el host.
Una cadena infinita de microtasks también puede bloquear renderizado.
const promise = loadProduct();Puede terminar fulfilled o rejected. Cada then crea otra Promise y adopta el retorno de la callback.
loadUser()
.then((user) => loadOrders(user.id))
.catch(handleError);Olvidar return rompe la cadena.
const data = await loadData();No bloquea todo el runtime ni crea otro hilo. La función devuelve control y continúa después.
Durante la espera, el estado externo puede cambiar. Por eso existen cancelación, IDs de versión y control de race conditions.
await Promise.all(items.map(processItem));Inicia todo. Puede saturar recursos.
Un pool controla cuántas operaciones están activas. Reintentos necesitan clasificación e idempotencia.
import { createOrder } from "./orders.js";Imports son live bindings de solo lectura local. Las dependencias se enlazan antes de evaluar y los ciclos pueden observar bindings no inicializados.
Los módulos deben exponer APIs pequeñas y efectos explícitos.
document;
fetch;
localStorage;
indexedDB;
Worker;Cada API tiene:
Datos de estas APIs continúan siendo no confiables.
Un valor vive mientras exista una ruta desde las raíces.
const cache = new Map();Una cache, listener o closure puede conservar datos. Garbage collection no cierra recursos externos; utiliza cleanup explícito.
Antes de optimizar:
métrica → perfil → hipótesis → cambio → mediciónAlgoritmos, red, DOM, bundle, memoria y capacidad de respuesta forman parte del costo.
El motor observa rutas y tipos, compila código caliente y deoptimiza cuando cambian supuestos.
Hidden classes y JIT son detalles de implementación. El contrato portable sigue siendo ECMAScript.
element.textContent = userInput;Un string válido puede ser peligroso si se interpreta como HTML, URL, SQL o código.
expect(calculateTotal(items)).toBe(30);Prueba resultados, errores, límites, efectos y asincronía. Coverage no reemplaza assertions útiles.
===?this?new?forEach no espera callbacks async?Notas de nivel Esencial en orden.
Notas Aplicado, escribiendo ejemplos propios.
Notas Avanzado, conectándolas con debugging y casos reales.
No necesitas recordar cada método de cada API.
Sí necesitas saber:
Cuando una característica parezca extraña, vuelve a estas preguntas:
¿Qué valor existe?
¿Qué binding lo referencia?
¿En qué scope se busca?
¿Qué llamada se está ejecutando?
¿Qué objeto recibe this?
¿Qué operación se encoló?
¿Qué Promise representa el resultado?
¿Qué módulo o host ofrece la API?
¿Qué referencia mantiene vivo el dato?
¿Qué contrato debería comprobarse?Responderlas convierte muchos comportamientos de JavaScript en consecuencias previsibles, no en reglas aisladas para memorizar.