Versión imprimible multipagina. Haga click aquí para imprimir.

Volver a la vista normal de esta página.

JavaScript y TypeScript

    1. Introducción
      1. Historia y Evolución de JavaScript y TypeScript
        1. Origen de JavaScript en el navegador (Brendan Eich, 1995)
        2. Estándar ECMAScript y rol de ECMA International
        3. Comité TC39 y proceso de propuestas
        4. Evolución de ECMAScript (ES3, ES5, ES2015+)
        5. Aparición de TypeScript como superconjunto tipado de JavaScript
        6. Filosofía de TypeScript: tipado estático opcional y verificación en tiempo de compilación
        7. Compatibilidad progresiva con JavaScript existente
        8. Influencia de C#, Java y lenguajes estáticos en el diseño de TypeScript
        9. Adopción en backend, frontend y full-stack
        10. Impacto de Node.js en el uso de JavaScript fuera del navegador
        11. Expansión del ecosistema: Deno, Bun y runtimes alternativos
        12. Evolución del tooling: bundlers, transpiladores, linters
        13. Uso de TypeScript en grandes bases de código y monorepos
        14. Transición de JavaScript clásico basado en funciones a clases, módulos y async/await
        15. “Any valid JavaScript is valid TypeScript” como principio de diseño
      2. Versiones y Compatibilidad
        1. Versionado semántico de TypeScript
        2. Versionado de Node.js y compatibilidad con ECMAScript
        3. target y lib en tsconfig.json
        4. Downleveling y transpilación (ESNext → ES5)
        5. Compatibilidad con navegadores y entornos legacy
        6. Polyfills y core-js
        7. Características propuestas (stage 0–4) y su adopción en TypeScript
        8. Estabilidad de sintaxis frente a features experimentales
        9. Tipos DOM según versión de @types/web
        10. Estrategias de upgrade mayor de TypeScript en proyectos grandes
        11. Compatibilidad entre módulos ES (import/export) y CommonJS (require/module.exports)
        12. Detección de versión en runtime (process.versions, navigator.userAgent)
        13. Dependencia en especificación del Event Loop del host (browser vs Node)
        14. Compatibilidad entre distintos bundlers y empaquetadores
        15. Compatibilidad entre ts-node, tsx, babel, esbuild
      3. Instalación del Entorno
        1. Instalación de Node.js (instalador oficial)
        2. Instalación con nvm / fnm / asdf
        3. Instalación de Deno
        4. Instalación de Bun
        5. npm como package manager por defecto
        6. yarn clásico y yarn modern
        7. pnpm y almacenamiento global basado en content-addressable store
        8. Instalación global de typescript (npm install -g typescript)
        9. Instalación local de typescript como dependencia de desarrollo
        10. Verificación de node, npm, tsc en PATH
        11. Configuración inicial de proyecto (npm init, pnpm init, yarn init)
        12. Inicialización de TypeScript (tsc --init)
        13. Estructura de carpetas recomendada (src, dist, test)
        14. Soporte multiplataforma (Windows, macOS, Linux)
        15. Contenedores y devcontainers (Dockerfile, devcontainer.json)
      4. Ejecución de Código y REPL
        1. Ejecución directa de JavaScript con node archivo.js
        2. REPL interactivo de Node.js
        3. Ejecución directa de TypeScript con ts-node
        4. Ejecución directa de TypeScript con tsx
        5. Ejecución TypeScript nativa en Deno
        6. Ejecución TypeScript nativa en Bun
        7. Compilación explícita con tsc y luego ejecución con Node.js
        8. Flags comunes de Node (--inspect, --require, --experimental-*)
        9. Flags comunes de ts-node / tsx
        10. Uso de importaciones ES en Node ("type": "module")
        11. Uso de la consola del navegador como entorno interactivo
        12. Ejecución en entornos sandbox (CodeSandbox, StackBlitz)
        13. I/O estándar (stdin, stdout, stderr) en Node
        14. Pipes y redirección de salida en CLI de Node
        15. Hot reload durante desarrollo con nodemon, ts-node-dev
      5. IDEs y Editores
        1. Visual Studio Code y el Language Service de TypeScript
        2. WebStorm / IntelliJ IDEA con soporte TypeScript integrado
        3. Neovim con LSP (typescript-language-server)
        4. Vim con coc.nvim y extensiones TS
        5. Emacs con lsp-mode y tide
        6. Autocompletado, IntelliSense y sugerencias de tipo
        7. Navegación de código (Go to Definition, Find References)
        8. Refactorizaciones automáticas (renombrar símbolos, extraer funciones)
        9. Soporte de linters (ESLint) integrado en el editor
        10. Formato automático con Prettier
        11. Integración de debuggers (Chrome DevTools, Node Inspector)
        12. Integración con Git y control de versiones
        13. Snippets y plantillas de código repetitivo
        14. Diagnóstico en tiempo real del compilador de TypeScript
        15. Entornos de notebooks JS/TS (Quokka, Jupyter con kernels JS)
      6. Entornos de Proyecto y Aislamiento
        1. node_modules como entorno aislado por proyecto
        2. package.json como descriptor de entorno
        3. package-lock.json, yarn.lock, pnpm-lock.yaml
        4. Resolución determinista de dependencias
        5. Workspaces (yarn workspaces, pnpm workspaces, npm workspaces)
        6. Monorepos y herramientas (turbo, nx, lage)
        7. Separación entre dependencias de runtime (dependencies) y de build (devDependencies)
        8. Scripts de proyecto (npm run, pnpm run)
        9. Estrategias de versionado interno en monorepos
        10. Aislamiento por versión de Node usando nvm dentro del proyecto
        11. Contenedores reproducibles para desarrollo (Docker Compose)
        12. Variables de entorno (.env, dotenv, process.env)
        13. Reproducibilidad de builds en CI
        14. Caché incremental de transpilación y bundling
        15. Estándares de estructura de carpetas (src, lib, dist, scripts)
      7. Gestión de Paquetes y Dependencias
        1. npm install, npm update, npm uninstall
        2. yarn add, yarn remove, yarn upgrade
        3. pnpm add, pnpm remove, pnpm update
        4. Versiones fijas vs rangos (^, ~, *)
        5. Dependencias opcionales y peer dependencies
        6. Resolución de conflictos de versiones
        7. Auditoría de dependencias (npm audit, pnpm audit)
        8. Firma y verificación de integridad (shasum)
        9. Repositorios privados (Artifactory, Verdaccio)
        10. Instalaciones link/workspace locales
        11. Publicación de paquetes internos
        12. Tipos externos (@types/*) para librerías JS puras
        13. Mantenimiento de typesVersions en librerías TypeScript
        14. Dependencias transpiladas vs dependencias puras ESM
        15. Gestión de binarios nativos precompilados
      8. Herramientas del Ecosistema Web
        1. Bundlers (webpack, esbuild, rollup, vite)
        2. Compilación incremental y HMR (Hot Module Replacement)
        3. Transformación con Babel
        4. Minificación y tree-shaking
        5. Code splitting y lazy loading
        6. Sourcemaps y depuración en el navegador
        7. Polyfills automáticos según destino
        8. Linter y formateador integrados en pipeline de build
        9. Pruebas unitarias integradas en bundlers (vitest)
        10. Empaquetado para navegadores antiguos
        11. Empaquetado para runtimes edge
        12. Bundles isomórficos (SSR + CSR)
        13. Configuración multi-target (web, node, worker)
        14. Generación de tipos .d.ts
        15. Publicación de librerías como ESM y CJS
    2. Fundamentos
      1. Tipos Básicos y el Sistema de Tipos de TypeScript
        1. Declaración de variables con let, const, var
        2. Inferencia de tipos
        3. Anotaciones de tipo explícitas
        4. Tipos primitivos (string, number, boolean)
        5. Tipos null, undefined, void
        6. Tipos bigint y symbol
        7. Tipos literales ("ok", 42, true)
        8. Tipos unión (|)
        9. Tipos intersección (&)
        10. Tipos any, unknown, never
        11. Alias de tipo (type)
        12. Interfaces (interface)
        13. Tuplas ([T, U])
        14. Enums (enum, const enum)
        15. Objetos con propiedades opcionales y readonly
      2. Operadores
        1. Operadores aritméticos (+, -, *, /, %, **)
        2. Operadores de asignación compuesta (+=, -=, *=, etc.)
        3. Operadores de comparación (===, !==, <, >, <=, >=)
        4. Operadores lógicos (&&, ||, !)
        5. Operador de fusión nula (??)
        6. Operador de encadenamiento opcional (?.)
        7. Operadores bitwise (&, |, ^, ~, <<, >>, >>>)
        8. Operador ternario (cond ? A : B)
        9. Operadores de propagación (...spread)
        10. Destructuración de arrays y objetos
        11. Precedencia y asociatividad de operadores
        12. Cortocircuito en ||, && y ??
        13. Coerción implícita con == vs comparación estricta ===
        14. delete para eliminar propiedades de objetos
        15. in y instanceof para verificación de pertenencia y tipo
      3. Control de Flujo
        1. if, else if, else
        2. switch y case
        3. for, for...of, for...in
        4. while y do...while
        5. break y continue
        6. Etiquetas de bucle (label:)
        7. Bloques con {} y alcance léxico
        8. Guard clauses y retornos tempranos
        9. throw para interrupción de flujo
        10. Narrowing de tipos dentro de condiciones
        11. Type guards personalizados con predicados (param is Tipo)
        12. Flujo de control basado en in, typeof, instanceof
        13. Exhaustividad en switch con never
        14. Assertions de no-nulo (!)
        15. Patrones de control de flujo funcional (array.filter, array.map)
      4. Funciones
        1. Declaraciones de función (function foo() {})
        2. Funciones flecha (const f = () => {})
        3. Parámetros tipados
        4. Parámetros opcionales (param?: T)
        5. Parámetros con valor por defecto
        6. Parámetros rest (...args: T[])
        7. Tipado de retorno explícito
        8. Funciones que retornan void
        9. Funciones que nunca retornan (never)
        10. Sobrecarga de funciones (signaturas múltiples)
        11. Funciones genéricas (<T>)
        12. Clausuras y entorno léxico
        13. this y binding explícito
        14. call, apply, bind
        15. Funciones async (async function)
      5. Errores y Excepciones
        1. try, catch, finally
        2. Lanzar errores (throw new Error())
        3. Tipado del valor capturado en catch
        4. Errores síncronos vs rechazos de Promesas
        5. Errores personalizados (class MiError extends Error)
        6. Rechazo de Promesas sin catch
        7. Manejo de errores en funciones async/await
        8. Promise.catch y try/catch async
        9. Errores de tipo (TypeError, RangeError, etc.)
        10. Assertions de tipo mal usadas y errores en runtime
        11. Enmascaramiento de errores con any
        12. Estrategias de logging de errores
        13. Errores fatales en Node (process.exit)
        14. Manejo centralizado de errores en aplicaciones web
        15. Errores recuperables vs no recuperables
      6. Entorno Global y Builtins
        1. Objeto global (globalThis)
        2. Objetos estándar (Object, Array, Map, Set)
        3. Math y operaciones numéricas
        4. Date y tiempo en milisegundos
        5. JSON (parse/stringify)
        6. console para salida estándar
        7. Promise como primitiva de async
        8. Symbol como clave única
        9. BigInt para enteros grandes
        10. RegExp para expresiones regulares
        11. Error y subclases integradas
        12. URL y URLSearchParams
        13. Intl e internacionalización
        14. TextEncoder / TextDecoder
        15. AbortController y cancelación
      7. Módulos e Imports
        1. Módulos ES (import, export)
        2. Importaciones por nombre y por defecto
        3. Reexportaciones (export * from)
        4. Import dinámico (import())
        5. Namespaces internos en TypeScript (namespace, legado)
        6. CommonJS (require, module.exports)
        7. Uso de "type": "module" en Node
        8. Resolución de rutas relativas y absolutas
        9. Alias de paths en tsconfig.json (paths, baseUrl)
        10. Barrel files (index.ts)
        11. Separación de tipos y valores en imports (import type)
        12. export type para exponer sólo tipos
        13. Árbol de dependencias y ciclos
        14. Side effects de módulos
        15. División lógica por capas (domain, infra, ui)
      8. Plataforma y Entorno de Ejecución
        1. DOM y APIs del navegador
        2. Node.js y APIs del sistema de archivos
        3. Web Workers y aislamiento de hilos en navegador
        4. Service Workers y ciclo offline
        5. APIs WebCrypto
        6. fetch y red HTTP
        7. Web Storage (localStorage, sessionStorage)
        8. IndexedDB
        9. Streams en navegador
        10. Streams en Node (fs.createReadStream)
        11. Timers (setTimeout, setInterval)
        12. Event Loop (cola de tareas y microtareas)
        13. APIs de proceso en Node (process, os)
        14. Variables de entorno y configuración
        15. Interoperabilidad entre frontend y backend con el mismo lenguaje
    3. Estructuras y Manipulación de Datos
      1. Estructuras de Datos Fundamentales
        1. Arrays dinámicos (Array<T>)
        2. Tuplas tipadas en TypeScript
        3. Objetos literales como mapas clave-valor
        4. Map y WeakMap
        5. Set y WeakSet
        6. Pilas (stack) basadas en arrays
        7. Colas (queue) basadas en arrays
        8. Colas dobles (deque) con estructuras circulares
        9. Árboles y tries implementados en objetos/Map
        10. Grafos representados con listas de adyacencia
        11. Tablas hash y colisiones (visión conceptual)
        12. Inmutabilidad estructural con readonly
        13. Clonado superficial vs profundo (structuredClone)
        14. Comparación por referencia vs comparación por valor
        15. Uso de Object.freeze
      2. Iteradores y Generadores
        1. Protocolo iterable ([Symbol.iterator])
        2. Protocolo async iterable ([Symbol.asyncIterator])
        3. for...of para recorrer iterables
        4. Generadores (function*)
        5. Generadores async (async function*)
        6. yield y comunicación bidireccional
        7. Iteradores personalizados en clases
        8. Consumo manual de iteradores (next())
        9. Generadores como reemplazo de estados internos complejos
        10. Streams de datos perezosos
        11. Composición de generadores
        12. Uso de generadores para testing y mocking
        13. Adaptación de callbacks a iterables async
        14. Backpressure conceptual en flujos iterables
        15. Comparación entre for...of y métodos de array
      3. Arrays y Métodos Funcionales
        1. push, pop, shift, unshift
        2. slice y splice
        3. map para transformación
        4. filter para selección
        5. reduce para acumulación
        6. some y every
        7. find y findIndex
        8. flat y flatMap
        9. Ordenamiento con sort
        10. Comparadores personalizados en sort
        11. Copia inmutable con el spread [...arr]
        12. Particionamiento y groupBy (patrones comunes)
        13. Deduplicación usando Set
        14. Zipping y combinaciones de arrays
        15. Arrays tipados (Uint8Array, Float32Array, etc.)
      4. Manipulación de Strings y Texto
        1. Literales de string simples y template strings
        2. Concatenación y +
        3. Substrings y slice
        4. Búsqueda (indexOf, includes, startsWith, endsWith)
        5. Reemplazo (replace, replaceAll)
        6. División (split)
        7. Unión (join) desde arrays
        8. Normalización Unicode (normalize)
        9. Interpolación con template literals
        10. Construcción incremental de strings (buffers de strings)
        11. Codificación y decodificación (TextEncoder, TextDecoder)
        12. Serialización y deserialización JSON (JSON.stringify, JSON.parse)
        13. Escapado seguro para HTML (patrones)
        14. Plantillas etiquetadas (tagged templates)
        15. Internacionalización de texto con Intl.MessageFormat (visión general)
      5. Expresiones Regulares
        1. Literales /patrón/flags
        2. Constructor new RegExp()
        3. Flags comunes (g, i, m, s, u, y)
        4. Grupos de captura
        5. Grupos con nombre ((?<name>...))
        6. Lookahead y lookbehind
        7. Cuantificadores (+, *, {m,n})
        8. Límites de palabra y línea (\b, ^, $)
        9. Métodos test, exec
        10. Métodos de string que aceptan regex (match, matchAll, replace, split)
        11. Rendimiento y backtracking excesivo
        12. Sanitización de entradas dinámicas en regex
        13. Comparación regex vs parseadores dedicados
        14. Construcción dinámica de patrones seguros
        15. Patrones comunes para validación de datos
      6. Archivos, Streams y Datos Binarios
        1. Sistema de archivos en Node (fs.readFile, fs.writeFile)
        2. Streams legibles y escribibles en Node (fs.createReadStream)
        3. Pipes (readable.pipe(writable))
        4. Buffers (Buffer)
        5. Lectura de binarios (Buffer, Uint8Array)
        6. Escritura incremental de logs y datos
        7. Manejo de archivos grandes sin cargar todo a memoria
        8. Blob y File en el navegador
        9. Descarga de archivos en navegador (creación de enlaces dinámicos)
        10. Subida de archivos con FormData
        11. fetch con ReadableStream
        12. Streams web (ReadableStream, WritableStream, TransformStream)
        13. Compresión y descompresión en Node (módulo zlib)
        14. Archivos temporales y directorios temporales
        15. Permisos y rutas en distintos sistemas operativos
      7. Datos Especializados y Formatos
        1. CSV (parseo manual y librerías)
        2. JSON estructurado
        3. YAML y TOML en configuración
        4. XML y DOMParser
        5. HTML como árbol DOM
        6. Markdown como formato de contenido
        7. Binary blobs (imágenes, audio)
        8. ArrayBuffer y DataView
        9. Estructuras binarias con offsets fijos
        10. WebSockets como canal binario o texto
        11. IndexedDB como base de datos del navegador
        12. LocalStorage / SessionStorage como key-value store
        13. Cache Storage en Service Workers
        14. Serialización estructurada (structuredClone)
        15. Mensajería entre hilos (postMessage)
      8. Tiempo y Fechas
        1. Objeto Date
        2. Timestamp en milisegundos desde Epoch
        3. Date.now() y mediciones rápidas
        4. Formateo manual de fechas
        5. Librerías de fechas (luxon, date-fns)
        6. Zonas horarias e Intl.DateTimeFormat
        7. Parseo de cadenas de fecha
        8. Medición de rendimiento con performance.now()
        9. setTimeout y temporizadores
        10. setInterval y loops periódicos
        11. Cancelación de temporizadores (clearTimeout, clearInterval)
        12. Animaciones ligadas a requestAnimationFrame
        13. Sincronización de relojes entre cliente y servidor
        14. Cuestiones de DST y horario de verano
        15. Desfase entre reloj del sistema y reloj del servidor
    4. Programación Estructurada y Modular
      1. Programación Orientada a Objetos (POO) en TypeScript/JavaScript
        1. Clases (class)
        2. Constructores (constructor)
        3. Propiedades de instancia
        4. Propiedades estáticas
        5. Métodos de instancia y estáticos
        6. Herencia con extends
        7. super y sobreescritura de métodos
        8. Modificadores de acceso (public, private, protected)
        9. Campos readonly
        10. Campos opcionales en clases
        11. Clases abstractas (abstract class)
        12. Métodos abstractos
        13. Interfaces como contratos de clases
        14. Implementación múltiple de interfaces
        15. Mixins y composición en lugar de herencia múltiple
      2. Decoradores y Metadatos
        1. Decoradores de clase
        2. Decoradores de método
        3. Decoradores de propiedad
        4. Decoradores de parámetro
        5. Metadata Reflection (reflect-metadata)
        6. Patrones de inyección de dependencias con decoradores
        7. Decoradores para validación
        8. Decoradores para logging y trazas
        9. Decoradores para binding automático de this
        10. Decoradores en frameworks (Angular, NestJS)
        11. Estado de estandarización de decoradores TC39
        12. Implicancias en tree-shaking y minificación
        13. Uso de decoradores en tests y mocks
        14. Decoradores y compatibilidad con emitDecoratorMetadata
        15. Consideraciones de rendimiento y orden de evaluación
      3. Módulos, Capas y Arquitectura
        1. Patrones de organización por dominio
        2. Patrones de organización por tipo (controllers, services, utils)
        3. Capas de infraestructura, dominio y aplicación
        4. Capas de UI, lógica y acceso a datos
        5. Módulos ES y carga estática
        6. Carga dinámica con import()
        7. CommonJS en entornos legacy
        8. Barrel modules (index.ts)
        9. Separación entre tipos y valores (import type)
        10. Evitar dependencias circulares
        11. Namespaces internos (histórico en TS)
        12. API pública vs detalles internos
        13. Versionado semántico de módulos internos
        14. Gestión de rutas absolutas con paths en tsconfig.json
        15. Monorepos con múltiples paquetes versionados
      4. Logging y Observabilidad
        1. console.log, console.warn, console.error
        2. Loggers estructurados (pino, winston)
        3. Niveles de log (debug, info, warn, error)
        4. Serialización segura de objetos en logs
        5. Formato JSON para logs machine-readable
        6. Logging en el navegador vs logging en Node
        7. Redacción de datos sensibles en logs
        8. Logs de rendimiento y tiempos de respuesta
        9. Integración con sistemas externos (APM)
        10. Trazas distribuidas (traceId, spanId)
        11. Métricas y contadores personalizados
        12. Alertas basadas en logs
        13. Integración con console.group y console.table
        14. Uso de debug namespaced en Node
        15. Logging condicional según NODE_ENV
      5. Documentación y Comentarios de Tipo
        1. Comentarios JSDoc
        2. Etiquetas @param, @returns, @deprecated
        3. Comentarios de tipo en JavaScript con // @ts-check
        4. Inferencia de tipos a partir de JSDoc
        5. TSDoc y convenciones para librerías públicas
        6. Generación automática de documentación de API
        7. Documentación en línea para funciones públicas
        8. Documentación para consumidores externos vs internos
        9. Comentarios de intención vs comentarios obvios
        10. Contratos de interfaz y documentación de invariantes
        11. Versionado de la documentación junto al código
        12. README técnicos por paquete
        13. Diagramas de arquitectura en monorepos
        14. Uso de /** @internal */ y visibilidad interna
        15. Control de documentación para clientes externos en SDKs
      6. Testing
        1. jest como framework de pruebas
        2. vitest y entornos ESM
        3. mocha + chai
        4. uvu, tape y frameworks minimalistas
        5. Pruebas unitarias
        6. Pruebas de integración
        7. Pruebas de extremo a extremo (E2E)
        8. Pruebas en navegador con Playwright
        9. Pruebas de API con Supertest / fetch mockeado
        10. Snapshots de UI
        11. Cobertura de código (coverage, istanbul, c8)
        12. Mocks y espías (jest.fn)
        13. Fixtures reutilizables
        14. Tests async/await y control de timers falsos
        15. Ejecución de tests en CI/CD
      7. Depuración
        1. Debugger en Chrome DevTools
        2. Debugger en VS Code (launch.json)
        3. node --inspect y el inspector de Node
        4. Breakpoints condicionales
        5. debugger; en el código
        6. Sourcemaps para mapear TypeScript → JavaScript
        7. Inspección de pila de llamadas (stack trace)
        8. Inspección de variables locales en tiempo real
        9. Watch expressions en el debugger
        10. Performance Profiler en navegador
        11. Heap snapshot para memoria
        12. Análisis de fugas de memoria en Node
        13. Depuración de Promesas rechazadas
        14. Seguimiento de eventos async en DevTools
        15. Depuración remota en contenedores y servidores
      8. Patrones de Diseño y Buenas Prácticas
        1. Programación funcional vs POO en JavaScript moderno
        2. Patrón módulo
        3. Patrón fábrica
        4. Patrón singleton
        5. Patrón estrategia
        6. Patrón adaptador
        7. Patrón fachada
        8. Patrón decorador (a nivel de objetos)
        9. Patrón observador (EventEmitter)
        10. Inyección de dependencias
        11. Patrón repositorio en capas de datos
        12. Patrón builder y objetos inmutables
        13. Patrón middleware (pipelines de funciones)
        14. Separación de concerns entre dominio y framework
        15. Diseño orientado a interfaces en TypeScript
    5. Estructuras Avanzadas y Programación Funcional
      1. Programación Funcional
        1. Funciones puras
        2. Inmutabilidad de datos
        3. Evitar efectos secundarios
        4. map, filter, reduce como patrones
        5. Composición de funciones
        6. Currificación y partial application
        7. Funciones de orden superior
        8. Aplicaciones point-free
        9. Inmutabilidad estructural con readonly
        10. Patrones de actualización inmutable con spread
        11. Librerías de FP (Ramda)
        12. Monads y Either / Result (patrones funcionales)
        13. Option / Maybe como alternativa a null
        14. Validación funcional de datos
        15. Manejo funcional de errores en Promesas
      2. Iterables Avanzados y Generadores
        1. Iteración lazy para eficiencia
        2. Pipelines de datos con generadores
        3. Transformaciones paso a paso sin arrays intermedios
        4. Generadores async para streams remotos
        5. Consumo incremental de APIs paginadas
        6. Backpressure conceptual en streams async
        7. Coordinación de multitarea con generadores
        8. Implementación de Symbol.iterator
        9. Implementación de Symbol.asyncIterator
        10. Reintentos y recolección gradual de datos
        11. Iteradores infinitos controlados
        12. Conversión entre generadores y arrays
        13. Iteración sobre estructuras personalizadas
        14. for await...of en flujo async
        15. Patrones de pausar y reanudar ejecución
      3. Buffers Binarios y Vistas de Memoria
        1. ArrayBuffer
        2. DataView
        3. Typed arrays (Uint8Array, Float64Array)
        4. Interpretación de datos binarios crudos
        5. Endianness y lectura multibyte
        6. Construcción de protocolos binarios personalizados
        7. Conversión entre Buffer (Node) y typed arrays
        8. Serialización eficiente para red
        9. WebSockets binarios
        10. WebRTC DataChannels binarios
        11. Transferencia de memoria entre hilos (postMessage con transfer)
        12. Uso en criptografía y hashing
        13. Parsing de archivos multimedia
        14. Procesamiento de audio en tiempo real
        15. Integración con WebAssembly (memoria compartida)
      4. Rendimiento y Profiling
        1. Micro-optimizaciones vs optimización algorítmica
        2. Complejidad temporal y espacial en JS/TS
        3. Perfilador de rendimiento del navegador
        4. Perfilador de CPU en Node
        5. Perfilador de heap y memory leaks
        6. performance.now() y medición precisa
        7. console.time y console.timeEnd
        8. Optimización de loops
        9. Evitar trabajo innecesario en renders UI
        10. Evitar bloqueos del Event Loop
        11. Web Workers para tareas pesadas
        12. División de código (code splitting)
        13. Carga diferida (lazy loading)
        14. Caché de resultados (memoización)
        15. Optimización de serialización/deserialización JSON
      5. Calidad de Código y Estándares
        1. ESLint
        2. Reglas de estilo y convenciones del equipo
        3. Prettier como formateador de código
        4. Reglas específicas de TypeScript (@typescript-eslint)
        5. Reglas de seguridad (no eval, no Function dinámica insegura)
        6. Reglas de complejidad ciclomática
        7. Reglas de longitud de archivo y función
        8. Detección de dead code
        9. Análisis estático del flujo de null/undefined
        10. Revisiones de código (pull requests)
        11. Hooks de pre-commit (lint-staged, husky)
        12. Convenciones de nombres (camelCase, PascalCase, UPPER_CASE)
        13. Convenciones de carpetas (utils, services, components)
        14. Convenciones para manejo de errores
        15. Documentación de decisiones arquitectónicas
      6. Seguridad y Criptografía
        1. Modelos de amenaza en aplicaciones web
        2. XSS (Cross-Site Scripting)
        3. CSRF (Cross-Site Request Forgery)
        4. Inyección de código en templates
        5. Validación y sanitización de input
        6. DOMPurify y sanitización HTML
        7. CORS y restricciones de origen
        8. Content Security Policy (CSP)
        9. Gestión de tokens y cookies seguras
        10. Almacenamiento seguro en localStorage vs cookies
        11. crypto.subtle y WebCrypto API
        12. Hashing y firma digital en el navegador
        13. Seguridad en Node (fugas de secretos en logs)
        14. Dependencias vulnerables y npm audit
        15. Gestión de secretos en variables de entorno
      7. Tipado Avanzado en TypeScript
        1. Tipos genéricos (<T>)
        2. Restricciones de genéricos (<T extends U>)
        3. Tipos condicionales (T extends U ? X : Y)
        4. Tipos inferidos en condicionales (infer)
        5. Tipos mapeados ({[K in Keys]: ...})
        6. keyof y manipulación de llaves
        7. Index signatures ([key: string]: T)
        8. readonly en tipos
        9. Remapeo de modificadores (-readonly, ?)
        10. Utility types estándar (Partial, Required, Pick, Omit)
        11. Record<K,V> y diccionarios tipados
        12. ReturnType, Parameters, ConstructorParameters
        13. ThisType y tipado contextual de this
        14. Inferencia contextual en funciones flecha
        15. Branding y nominal typing (patrón type ID = string & {__brand: "ID"})
      8. Validación de Datos y Esquemas
        1. Validación en runtime vs chequeo estático
        2. Zod y esquemas tipados
        3. io-ts y decodificación segura
        4. Validación de requests HTTP
        5. Validación de respuestas de APIs externas
        6. Aserciones de tipo (asserts value is Tipo)
        7. Narrowing manual con validadores
        8. Serialización segura para persistencia
        9. Sanitización de datos antes de guardarlos
        10. Transformaciones de entrada (DTOs)
        11. Contratos entre capas frontend y backend
        12. Tipos compartidos entre cliente y servidor
        13. Versionado de esquemas de datos
        14. Compatibilidad hacia atrás en APIs
        15. Migraciones de estructura de datos en el tiempo
    6. Concurrencia, Async y Bajo Nivel
      1. Async y Concurrencia en JavaScript
        1. Modelo single-threaded y Event Loop
        2. Promise como unidad básica de async
        3. async / await
        4. Estados de una Promesa (pending, fulfilled, rejected)
        5. Cadena de Promesas con .then
        6. Manejo de errores con .catch
        7. Ejecución paralela con Promise.all
        8. Ejecución competitiva con Promise.race
        9. Ejecución tolerante a fallas con Promise.allSettled
        10. Control de concurrencia con colas y semáforos userland
        11. Espera activa vs espera pasiva
        12. Bloqueos del Event Loop y CPU-bound
        13. Uso de Web Workers para CPU-bound en navegador
        14. Uso de worker_threads en Node
        15. Cancelación cooperativa con AbortController
      2. Networking y Comunicación
        1. fetch y solicitudes HTTP
        2. XMLHttpRequest (legado)
        3. WebSockets
        4. Server-Sent Events (SSE)
        5. gRPC-Web (patrones)
        6. Protocolos binarios sobre TCP en Node (net)
        7. HTTPS en Node (https)
        8. HTTP/2 y multiplexación
        9. Tiempo de espera y reintentos
        10. Política de mismo origen en navegador
        11. CORS y credenciales
        12. Serialización y deserialización JSON
        13. Streaming de respuesta con ReadableStream
        14. Subida de archivos en trozos (chunked upload)
        15. APIs en tiempo real y suscripción de eventos
      3. Multithreading, Workers y Paralelismo
        1. Web Workers en navegador
        2. Dedicated Workers vs Shared Workers
        3. Transferencia de buffers entre hilos
        4. SharedArrayBuffer
        5. Atomics y sincronización de memoria compartida
        6. worker_threads en Node
        7. Clustering de procesos en Node (cluster)
        8. Balanceo de carga en múltiples workers
        9. Comunicación entre workers con postMessage
        10. Aislamiento de estado y side effects
        11. Pools de workers
        12. Limitaciones de acceso al DOM en Web Workers
        13. Aceleración de tareas pesadas (compresión, hashing)
        14. Streams entre threads
        15. Diseño de pipelines paralelos
      4. Metaprogramación y Reflexión
        1. Proxy para interceptar acceso a objetos
        2. Reflect para operaciones de bajo nivel
        3. Definición de propiedades con Object.defineProperty
        4. Descriptores de propiedad (get, set, enumerable, configurable)
        5. Object.getPrototypeOf y Object.setPrototypeOf
        6. Object.freeze y Object.seal
        7. Patrón de interceptores y validación dinámica
        8. Generación dinámica de clases y funciones
        9. Evaluación dinámica de código (riesgos de eval)
        10. Serialización y reconstrucción dinámica de objetos
        11. Decoradores (propuesta TC39) como metaprogramación declarativa
        12. Metadatos de tipos en runtime (emulación con reflect-metadata)
        13. Inspección de stack trace y Error.captureStackTrace
        14. Patrones AOP (aspect-oriented programming) con Proxies
        15. Instrumentación dinámica para profiling
      5. Gestión de Recursos y Ciclo de Vida
        1. try/finally para liberar recursos
        2. Cancelación con AbortController
        3. Control manual de conexiones abiertas
        4. Streams y close/destroy
        5. Suscripciones a eventos y removeEventListener
        6. Limpieza de setInterval y setTimeout
        7. Manejadores de cierre de proceso en Node (process.on("exit"))
        8. Gestión de sockets abiertos
        9. Liberación de handles en tests
        10. Patrones de “destructor” manual en JS
        11. Patrones using y Symbol.dispose (propuesta)
        12. Control explícito de sesiones y tokens
        13. Recursos del DOM (observadores, listeners)
        14. Evitar fugas de listeners en SPAs
        15. Limpieza de workers inactivos
      6. Monitoreo, Métricas y Telemetría
        1. console.time y console.count
        2. Performance API en navegador
        3. Node perf_hooks para medición
        4. Recolección de métricas de latencia
        5. Recolección de métricas de throughput
        6. Métricas de uso de memoria
        7. Métricas de GC y pausas
        8. Logs estructurados con IDs de correlación
        9. Trazas distribuidas con headers de tracing
        10. Exportación de métricas a sistemas externos
        11. Alertas automáticas en producción
        12. Health checks y endpoints /health
        13. Rate limiting y mecanismos antiabuso
        14. Auditoría de acciones del usuario
        15. Observabilidad en entornos serverless / edge
      7. Recolección de Basura y Memoria
        1. Modelo de memoria administrada en JS
        2. Recolección de basura generacional
        3. Referencias fuertes vs débiles
        4. WeakMap y WeakSet
        5. WeakRef y FinalizationRegistry
        6. Fugas de memoria por referencias colgantes
        7. Fugas de memoria en closures
        8. Fugas de memoria en listeners no removidos
        9. Fragmentación de heap
        10. Trazas de heap en DevTools
        11. Monitoreo de uso de memoria en Node
        12. Límites de memoria en entornos serverless
        13. Impacto de objetos gigantes y arrays densos
        14. Uso de estructuras inmutables para evitar duplicados grandes
        15. Pausas de GC y rendimiento en tiempo real
      8. Interoperabilidad con Bajo Nivel y WebAssembly
        1. WebAssembly en el navegador
        2. Cargar módulos WebAssembly desde JavaScript
        3. Tipos numéricos de bajo nivel en WebAssembly
        4. Compartir memoria entre WebAssembly y JS
        5. Llamar funciones WebAssembly desde JS
        6. Llamar funciones JS desde WebAssembly
        7. Uso de WebAssembly para cómputo intensivo
        8. Integración con librerías compiladas (C/C++/Rust)
        9. WebAssembly en Node
        10. Conversión de buffers binarios para FFI
        11. Overhead de cruce de frontera JS ↔ WASM
        12. Control de tiempo real y latencia baja
        13. Seguridad y sandboxing de WebAssembly
        14. Reutilización de lógica en cliente y servidor vía WASM
        15. Limitaciones de WebAssembly frente a JS puro
    7. Implementación y Distribución
      1. Herramientas de Entorno y Configuración
        1. tsconfig.json y opciones del compilador
        2. target y nivel de ECMAScript emitido
        3. module y formato de salida (ESNext, CommonJS)
        4. moduleResolution y resolución de paths
        5. strict y modo estricto
        6. noImplicitAny
        7. strictNullChecks
        8. esModuleInterop y compatibilidad con CommonJS
        9. skipLibCheck y rendimiento de compilación
        10. declaration y generación de .d.ts
        11. sourceMap para depuración
        12. outDir y rootDir
        13. Configuración por proyecto y references
        14. Proyectos incrementales (composite)
        15. paths y alias internos de importación
      2. Motores e Implementaciones de JavaScript
        1. V8 (Chrome, Node)
        2. SpiderMonkey (Firefox)
        3. JavaScriptCore (Safari)
        4. Chakra (histórico)
        5. Node.js como runtime en servidor
        6. Deno como runtime seguro y TS-first
        7. Bun como runtime y bundler integrado
        8. Cloudflare Workers / runtimes edge
        9. Service Workers y ejecución offline en navegador
        10. Motores en entornos embebidos (Electron)
        11. JS en entornos móviles híbridos
        12. Diferencias de API entre runtimes
        13. globalThis como abstracción común
        14. Límite de memoria y CPU en entornos edge/serverless
        15. Compatibilidad con módulos ES nativos
      3. Empaquetado, Build y Publicación
        1. webpack y empaquetado tradicional
        2. rollup para librerías
        3. esbuild y builds ultrarrápidos
        4. vite y desarrollo con HMR
        5. Transpilación con tsc
        6. Transpilación con Babel
        7. Tree-shaking y eliminación de código muerto
        8. Code splitting dinámico
        9. Generación de bundles múltiples (cjs, esm, iife)
        10. Minificación y ofuscación
        11. Generación de tipos .d.ts para consumidores TS
        12. Publicación en npm (npm publish)
        13. Versionado semántico (major.minor.patch)
        14. Changelogs y releases automatizados
        15. Publicación de paquetes privados internos
      4. Aplicaciones de Línea de Comando (CLI)
        1. Scripts ejecutables con Node (#!/usr/bin/env node)
        2. Commander.js para parseo de argumentos
        3. yargs para CLI declarativas
        4. process.argv y parseo manual
        5. Colores y formato en consola (chalk)
        6. Spinners y progreso visual en CLI
        7. Entrada interactiva (inquirer)
        8. Salida estructurada en JSON
        9. Logs y niveles verbosos (-v, --debug)
        10. Errores amigables en CLI
        11. Empaquetado de CLI en un solo archivo
        12. Distribución como paquete npm global
        13. Versionado y flags --version
        14. Comandos compuestos y subcomandos
        15. Autocompletado de shell (bash/zsh/fish)
      5. Aplicaciones Web y UI
        1. DOM y manipulación directa
        2. React y componentes funcionales
        3. JSX y TSX
        4. Hooks y estado local
        5. Estado global (Redux, Zustand)
        6. Context API
        7. Next.js y renderizado del lado del servidor (SSR)
        8. Vue con composición y tipado
        9. Svelte y bindings reactivos
        10. Web Components y customElements.define
        11. Shadow DOM y encapsulación de estilos
        12. CSS Modules / CSS-in-JS
        13. Accesibilidad (a11y)
        14. Persistencia de estado en localStorage
        15. Comunicación con APIs desde la UI
      6. Aplicaciones Móviles, Escritorio y Juegos
        1. React Native
        2. Expo y flujo móvil con TypeScript
        3. Capacitor / Ionic para apps híbridas
        4. Electron para escritorio
        5. Tauri y runtimes ligeros
        6. PWAs (Progressive Web Apps)
        7. Service Workers y caché offline
        8. Notificaciones push
        9. Acceso a hardware (sensores, cámara, micrófono)
        10. APIs de archivos locales en escritorio
        11. Motores gráficos 2D/3D (Pixi.js, Three.js)
        12. Animaciones con requestAnimationFrame
        13. Optimización de render en canvas/WebGL
        14. Sincronización de estado en tiempo real multijugador
        15. Distribución en tiendas (App Store / Play Store) vía wrappers
      7. Internacionalización (i18n) y Localización (l10n)
        1. API Intl
        2. Formato de números y monedas
        3. Formato de fechas y horarios
        4. Pluralización de mensajes
        5. Detección de locale del usuario
        6. Carga dinámica de mensajes traducidos
        7. Separación de traducciones por módulo
        8. Herramientas como i18next
        9. ICU MessageFormat
        10. Manejo de RTL (right-to-left)
        11. Zoned time y horario local
        12. Sensibilidad cultural en contenido
        13. Selección dinámica de fuentes y tipografías
        14. Traducción en build vs runtime
        15. Estrategias de fallback de idioma
      8. DevOps, Entrega y Despliegue
        1. Scripts de build en package.json
        2. Pipelines CI/CD
        3. Pruebas automáticas en cada commit
        4. Lint y type-check en CI
        5. Empaquetado para producción
        6. Despliegue en servidores Node tradicionales
        7. Despliegue serverless (AWS Lambda, Vercel Functions)
        8. Despliegue edge (Cloudflare Workers)
        9. Contenedores Docker para Node
        10. Health checks y monitoreo post-deploy
        11. Rollbacks y despliegues azules/verdes
        12. Feature flags y rollout gradual
        13. Versionado de APIs públicas
        14. Documentación de endpoints y contratos
        15. Observabilidad continua en producción
    8. Internos
      1. Compilador de TypeScript y Proceso de Transpilación
        1. Análisis léxico y parser
        2. Creación del AST (árbol de sintaxis abstracta)
        3. Chequeo de tipos estático
        4. Inferencia de tipos
        5. Ampliación y reducción de uniones
        6. Emisión (emit) de JavaScript
        7. Generación de d.ts para tipos públicos
        8. Sourcemaps para depuración
        9. Proyectos incrementales y tsbuildinfo
        10. Referencias a proyectos (project references)
        11. Diferencias entre tsc y Babel para TS
        12. Limitaciones del chequeo de tipos en tiempo de compilación
        13. Eliminación de tipos y anotaciones en el JS emitido
        14. Transformaciones personalizadas del compilador
        15. Integración del Language Service en el editor
      2. Modelo de Ejecución de JavaScript
        1. Call stack
        2. Contextos de ejecución
        3. Ámbito léxico y closures
        4. Hoisting de variables y funciones
        5. Resolución de this
        6. Strict mode ("use strict")
        7. Event Loop y cola de tareas
        8. Microtareas (Promise.then)
        9. Macrotareas (setTimeout, I/O)
        10. Repaint / reflow del navegador
        11. Prioridades de tareas en el navegador
        12. Bloqueo del main thread
        13. Interacción entre JS y render de la UI
        14. Rechazos no manejados de Promesas
        15. Módulos ES y carga dinámica en runtime
      3. Modelo de Datos y Prototipos
        1. Objetos y prototipos
        2. [[Prototype]] y __proto__
        3. Cadena de prototipos
        4. Herencia basada en prototipos
        5. Clases como azúcar sintáctico sobre prototipos
        6. Descriptores de propiedad
        7. Enumerabilidad e iteración de llaves
        8. Object.keys, Object.values, Object.entries
        9. Object.assign y mezcla de objetos
        10. Sellado y congelamiento de objetos
        11. Inmutabilidad superficial vs profunda
        12. Comparación de objetos por referencia
        13. Serialización con JSON.stringify
        14. Limitaciones de JSON.stringify (funciones, undefined, Symbol)
        15. Clonación estructurada (structuredClone)
      4. Optimizaciones del Motor JavaScript
        1. JIT (Just-In-Time compilation)
        2. Inline caching
        3. Hidden classes
        4. Escape analysis
        5. Optimización de funciones calientes
        6. Deoptimización cuando cambian los tipos
        7. Representación interna de números (double, SMI)
        8. Recolección generacional de basura
        9. Inlining de funciones
        10. Eliminación de bounds checks en arrays
        11. Optimización de bucles apretados
        12. Penalización por megamorphic call sites
        13. Estructuras densas vs dispersas en arrays
        14. Impacto de delete en arrays
        15. Costo de capturar closures con muchas variables
      5. Interoperabilidad Nativa y FFI
        1. Addons nativos en Node (N-API)
        2. Interfaz C/C++ para módulos de alto rendimiento
        3. Compilación de addons para múltiples plataformas
        4. Gestión de memoria manual en addons
        5. Paso de buffers binarios entre JS y C++
        6. Seguridad y aislamiento al ejecutar código nativo
        7. Puentes con Rust (Neon, napi-rs)
        8. Puentes con Go (gobridge)
        9. Llamadas a librerías del sistema desde Node
        10. Consideraciones de portabilidad en binarios precompilados
        11. Versionado de ABI y compatibilidad
        12. Costos de cruce entre JS y nativo
        13. Exponer bindings tipados a TypeScript
        14. Depuración de código nativo integrado
        15. Distribución de módulos con binarios preconstruidos
      6. WebAssembly y Runtimes Aislados
        1. Compilación de código C/C++/Rust a WebAssembly
        2. Carga de módulos WASM en navegador
        3. Carga de módulos WASM en Node
        4. Memoria lineal compartida con WASM
        5. Paso de strings y arrays entre JS y WASM
        6. Ejecución de lógica crítica en WASM
        7. Aceleración de cómputo matemático
        8. WASM y sandboxing de seguridad
        9. Límites de llamadas frecuentes JS↔WASM
        10. Uso de WASI (interfaz de sistema para WASM)
        11. Ejecución en entornos serverless edge
        12. Reutilización de librerías nativas vía WASM
        13. Perfilado de rendimiento en WASM
        14. Integración con Web Workers para aislamiento
        15. Futuro de WASM en aplicaciones web complejas
      7. Estándares, Propuestas y Futuro del Lenguaje
        1. Proceso de propuesta TC39 (stages 0–4)
        2. Nuevas sintaxis del lenguaje
        3. Nuevas APIs estándar del runtime
        4. Decoradores estandarizados
        5. Records y Tuples inmutables (propuestas)
        6. Patrones de coincidencia estructural (pattern matching)
        7. Tipos sellados y exhaustividad
        8. Registros inmutables para datos seguros
        9. Tipos para excepciones y unknown seguro
        10. Campos privados # en clases
        11. Módulos nativos en el navegador sin bundler
        12. Evolución de import dinámico y lazy
        13. Nuevos primitivos de sincronización
        14. APIs criptográficas más ricas en WebCrypto
        15. Estandarización de APIs de streaming y backpressure
      8. Límites y Buenas Prácticas de Arquitectura
        1. Separación entre lógica de dominio y capas de infraestructura
        2. Evitar acoplamiento a frameworks
        3. Diseñar para testabilidad
        4. Manejo centralizado de configuración
        5. Manejo centralizado de errores
        6. Límite claro entre cliente y servidor
        7. Reutilización de tipos entre frontend y backend
        8. Versionado de contratos de API
        9. Estrategias de backward compatibility
        10. Limpieza de código muerto y flags experimentales
        11. Migraciones de datos controladas
        12. Monitoreo desde el inicio del proyecto
        13. Hardening de seguridad como requisito base
        14. Automatización de calidad en CI/CD
        15. Cultura de documentación viva y mantenible