Comprende antes de memorizar

Un closure es una función junto con el acceso al entorno léxico donde fue creada. Conserva bindings, no copias mágicas de sus valores: si el binding cambia, las llamadas posteriores observan ese estado actualizado.

Este mecanismo permite encapsular estado y fabricar funciones configuradas. Amplía el alcance estudiado antes: la vida de un binding puede superar la ejecución que creó su entorno cuando una función todavía lo referencia.

La estructura léxica del código determina qué entorno exterior consulta un nombre. Durante la ejecución, los registros de entorno mantienen bindings para parámetros, declaraciones y bloques, y se enlazan con un entorno externo.

Una función busca nombres desde el lugar donde fue definida, no desde donde luego se invoca. Esto explica closures y sombreado sin imaginar objetos públicos que puedan inspeccionarse directamente.

En una función normal, el valor de this depende de cómo se realiza la llamada: como método, con new, mediante call/apply/bind o como llamada simple. La función no queda unida para siempre al objeto donde fue escrita.

Una arrow function no crea su propio this: captura el binding léxico del entorno. Por eso call, apply y bind pueden fijar this en funciones normales, pero no reemplazan el this capturado por una arrow.

call y apply invocan una función normal de inmediato con un this explícito; call recibe argumentos separados y apply recibe una colección de argumentos. bind crea otra función que conserva el this y, opcionalmente, argumentos iniciales.

Estas operaciones hacen explícito el receptor cuando una función debe reutilizarse o viajar como callback. Sobre una arrow no sustituyen el this léxico, aunque bind todavía puede prefijar argumentos.

Cuando una propiedad no es propia, JavaScript continúa la búsqueda por el prototipo del objeto y repite el proceso hasta encontrarla o llegar a null. Esa cadena delega comportamiento sin copiar cada método en cada instancia.

Object.getPrototypeOf permite observar el enlace; hasOwn distingue una propiedad propia de una heredada. La asignación normal suele crear o actualizar una propiedad propia y puede ocultar la heredada.

La herencia prototípica conecta objetos para delegar lecturas y métodos. Los constructores tradicionales exponen un objeto prototype que se convierte en prototipo de las instancias creadas con new.

Compartir métodos en el prototipo reduce duplicación, pero compartir allí estado mutable mezcla accidentalmente instancias. Cada instancia debe poseer los datos que cambian de manera independiente.

Una propiedad de datos tiene un valor y atributos writable, enumerable y configurable. Una propiedad accesora usa get y/o set en lugar de value y writable; Object.getOwnPropertyDescriptor permite inspeccionar ese contrato.

Object.defineProperty usa false como valor predeterminado para atributos omitidos. Los descriptores controlan operaciones del lenguaje, no validan por sí solos el significado del dato.

Un getter calcula una lectura con sintaxis de propiedad y un setter intercepta una asignación. Son accesores síncronos: conviene que su coste y efectos no sorprendan a quien usa el objeto.

El almacenamiento debe usar otro nombre o un campo privado. Escribir this.valor dentro del setter de valor volvería a invocar el mismo setter hasta desbordar la pila.

La sintaxis class organiza constructor, métodos, accesores y campos. Es una abstracción sobre el modelo de prototypes: los métodos de instancia se ubican en el prototype y las instancias delegan hacia él.

Las clases añaden reglas propias, como ejecución estricta y la obligación de usar new. La sintaxis resulta más declarativa, pero no convierte JavaScript en un sistema de clases desconectado de su cadena prototípica.

extends enlaza tanto la cadena de instancias como la relación estática entre clases. En un constructor derivado, super(...) debe ejecutar el constructor base antes de acceder a this.

super.metodo() permite extender una implementación base sin buscarla manualmente. La herencia expresa una relación de sustitución; para combinar capacidades independientes suele ser más claro componer objetos.

Los nombres #privados se declaran en el cuerpo de la clase y sólo pueden referenciarse con esa sintaxis dentro de la clase. Son elementos privados reales con comprobación de marca (brand check), no propiedades ocultas con claves de texto.

objeto['#saldo'] no accede al campo #saldo y Object.keys no lo enumera. Intentar usar un nombre privado no declarado es un error de sintaxis; aplicarlo a un objeto sin la marca correcta produce un error.

Cada Symbol() crea un valor primitivo único que puede usarse como clave de propiedad sin colisionar con claves de texto. Su descripción ayuda a depurar, pero dos símbolos con la misma descripción siguen siendo diferentes.

Los símbolos conocidos permiten participar en protocolos del lenguaje, como Symbol.iterator. Object.keys omite claves symbol; Reflect.ownKeys incluye claves string y symbol.

Un iterable implementa [Symbol.iterator]() y devuelve un iterador. Cada llamada a next() del iterador produce un objeto con value y done; for...of y spread consumen ese protocolo.

Separar el iterable del iterador permite crear recorridos nuevos y, si se desea, varios iteradores independientes. Un iterador agotado debe continuar indicando done: true.

Una función generadora se declara con function* y devuelve un generador que implementa los protocolos de iterador e iterable. Cada yield suspende su ejecución y conserva su estado hasta el siguiente next().

El valor pasado a next(valor) se convierte en el resultado del yield suspendido, salvo en la primera llamada. return finaliza la secuencia y su valor no aparece normalmente en for...of.

Map asocia claves de cualquier tipo con valores y conserva orden de inserción para iteración. Set mantiene valores únicos con el mismo criterio de igualdad usado por estas colecciones.

Frente a un objeto, Map evita convertir las claves en cadenas de texto y expone size e iteración directa. Set elimina duplicados por identidad para objetos: dos literales equivalentes siguen siendo valores distintos.

WeakMap mantiene asociaciones cuyas claves deben ser objetos o símbolos no registrados; WeakSet mantiene referencias débiles admitidas por su contrato. No impiden por sí solos que una clave recolectable sea liberada.

No son enumerables y no exponen size porque observar sus miembros haría depender el programa de decisiones de recolección de basura. Las pruebas deben verificar el comportamiento de has/get/delete, nunca afirmar que ocurrió GC.

Promise.all cumple con todos los valores en orden y rechaza al primer rechazo observado. allSettled siempre cumple cuando todas se asentaron y describe cada fulfillment o rejection.

Promise.race se asienta como la primera entrada que se asiente; Promise.any cumple con el primer fulfillment y sólo rechaza con AggregateError si todas rechazan. Settlement incluye cumplimiento o rechazo, no sólo finalización exitosa.

El stack ejecuta un job a la vez. Operaciones del host pueden registrar trabajo y, cuando corresponde, colocar callbacks en colas; el event loop del host elige la siguiente task cuando el stack queda libre.

ECMAScript especifica jobs, como reacciones de Promise, mientras navegador y Node definen tasks, timers y fases. Por eso conviene razonar stack → host → queues → event loop y separar garantías del lenguaje de detalles específicos del host.

Las reacciones de Promise y queueMicrotask se encolan como microtasks del host. Al terminar la ejecución actual, el host drena la cola de microtasks antes de avanzar a la siguiente task, incluido un callback de timer.

Una microtask puede encolar otras microtasks, de modo que una cadena sin límite puede retrasar tasks. El nombre macrotask es informal; la terminología de plataforma suele hablar simplemente de tasks.

Cada llamada async devuelve una Promise. await obtiene un fulfillment o lanza el motivo de rechazo dentro de la función, y la continuación posterior se programa como un job en lugar de bloquear el hilo.

Esperar operaciones independientes una por una puede serializarlas innecesariamente. Iniciarlas primero y coordinarlas con Promise.all conserva concurrencia; hacerlo sólo es correcto cuando no existe dependencia entre resultados.

Un throw dentro de async rechaza la Promise devuelta. Un rechazo esperado por await vuelve a lanzarse en esa función; si no se captura, continúa por la cadena hasta un manejador de rechazo.

Capturar sólo para registrar y devolver undefined puede ocultar el contrato fallido. Es preferible recuperar con un valor válido, añadir contexto mediante cause o propagar el error para que una capa responsable decida.

Los módulos tienen su propio ámbito, dependencias declaradas y bindings importados vivos: una importación observa actualizaciones del binding exportado, aunque no permite reasignarlo desde el importador. La resolución y carga pertenecen al host.

Este playground bloquea import y export porque ejecuta fragmentos confinados sin cargar módulos, archivos o red. La lección es exclusivamente teórica: no se habilitan módulos ni se evade esa frontera para practicar la sintaxis.

Object.freeze impide reconfigurar propiedades propias y vuelve no escribibles las propiedades de datos del objeto. Es superficial: un objeto o array anidado conserva su mutabilidad salvo que también se congele.

Actualizar mediante copias puede facilitar razonamiento y detección de cambios, pero spread también es superficial. La inmutabilidad profunda requiere recorrer la estructura o adoptar contratos que eviten exponer referencias mutables.

La composición construye una operación conectando funciones pequeñas, con salidas compatibles con las entradas siguientes. Reduce jerarquías cuando el comportamiento puede combinarse sin una relación de herencia.

La memoización guarda resultados por entrada para evitar trabajo repetido, pero introduce compromisos: coste de la caché, semántica de identidad para objetos, invalidación y retención de memoria. Sólo conviene para funciones compatibles con reutilizar el resultado y cargas donde la caché aporta valor.