Curso de JavaScript

Recorre cómo se ejecuta JavaScript tanto en el navegador como en Node.js, el orden de aprendizaje de las 4 categorías de este curso, y cómo leer un mensaje de error.

Cubre elegir entre const y let, el TypeError al reasignar un const y el SyntaxError al redeclararlo, y las reglas de nombrado camelCase.

Cubre cómo enteros y decimales comparten el mismo tipo Number, los operadores de resto y exponente, el redondeo con Math, alinear cifras con toFixed, y evitar el error de coma flotante.

Cubre elegir entre 3 tipos de comillas, incrustar valores con template literals, formatear con trim y slice, split y join, y replaceAll y padStart.

Cubre la diferencia entre === (comprueba tipo y valor) y == (convierte el tipo antes de comparar), operadores de comparación y lógicos, los 6 valores falsy que if trata como falso, y fijar un valor por defecto con ||.

Cubre comprobar el tipo con typeof, la conversión explícita con Number / String / Boolean, la conversión implícita donde solo + se vuelve concatenación de cadenas, parseInt y parseFloat, y detectar conversiones fallidas con Number.isNaN.

Cubre obtener elementos con index y length, añadir y eliminar con push / pop / shift / unshift, comprobar con includes e indexOf, y elegir entre slice y splice.

Cubre construir un objeto que agrupa datos como pares clave-valor, elegir entre notación de punto y de corchetes, delete e in, y Object.keys / values / entries.

Cubre la diferencia entre null y undefined para representar "sin valor", leer a través de una ruta anidada sin detenerse usando ?., y aplicar un valor por defecto con ?? que deja intactos el 0 y la cadena vacía.

Cubre el destructuring, que saca de una vez solo los valores que necesitas en variables, según los nombres de clave de un objeto o las posiciones de un array — con valores por defecto, renombrado y rest.

Cubre spread syntax, que despliega el contenido de un array u objeto en su lugar, para copiar y combinar sin cambiar el original, y aplicar solo los cambios de un usuario sobre una configuración por defecto.

Cubre eliminar duplicados con Set, que guarda solo 1 de cada valor, set / get de Map para pares clave-valor en orden de registro, y elegir entre Map y Object según el tipo de clave y el orden.

Cubre cómo asignar un array u objeto solo pasa una referencia, cómo === compara referencias, la copia superficial de spread syntax frente a la copia profunda de structuredClone, y Object.freeze.

Cubre JSON.stringify para convertir un objeto en una cadena y JSON.parse para convertirla de vuelta, sangrar con un 3.er argumento, el SyntaxError que lanza una cadena rota, y los valores que se pierden en el viaje de ida y vuelta.

Resume la división entre los 7 primitivos y Object, qué devuelve typeof, por qué null y los arrays vuelven ambos como object más Array.isArray, y cómo comprobar si algo se puede tratar como número.

Trata las cadenas de else if que evalúan de arriba abajo y el orden en que conviene poner las condiciones, el operador ternario que devuelve directamente un valor, y cómo switch y break comparan un valor con varios candidatos.

Trata el bucle for, que cuenta con tres expresiones (inicialización, condición y actualización); for...of y entries para obtener los elementos directamente; for...in para recorrer claves, y cómo armar bucles anidados.

Trata while, que repite solo mientras se cumple una condición; do...while, que ejecuta primero el cuerpo; cómo evitar los bucles infinitos, y la diferencia entre continue, que se salta una vuelta, y break, que sale del bucle.

Trata las declaraciones function, que le ponen nombre a un bloque de código; cómo se asignan los argumentos por posición y qué devuelve return; las expresiones de función, que guardan una función en una variable, y el undefined que aparece si olvidas return.

Trata la forma básica de las funciones flecha, que crean funciones con =>; las formas abreviadas que omiten los paréntesis del parámetro y las llaves del cuerpo; los paréntesis necesarios para devolver un objeto, y los cuerpos de bloque de varias líneas con return.

Trata los parámetros por defecto, que se usan cuando se omite un argumento; por qué el resultado cambia entre undefined y null; los parámetros rest, que reúnen los argumentos restantes en un array, y el patrón options, que pasa la configuración como un objeto.

Trata el ámbito de bloque y de función, el shadowing en el que una declaración interna oculta a una externa, el hoisting de las declaraciones function, la TDZ de let y por qué no usar var.

Trata los closures, funciones que recuerdan variables de un ámbito externo: contadores que conservan su valor entre llamadas, fábricas de funciones que devuelven funciones con un valor de configuración ya fijado y funciones creadas en bucles.

Trata las funciones de orden superior, que reciben funciones como argumentos, y los callbacks que se les pasan: procesar elementos uno por uno con forEach, un filter hecho a mano que recibe una condición y llamadas en dos pasos a funciones que devuelven funciones.

Aprende map, que transforma cada elemento de un array, y filter, que conserva solo los que cumplen una condición. Verás por qué el array original no cambia, cómo encadenar filter con map y cómo usar el argumento index para obtener la posición.

Aprende reduce, que combina un array en un solo valor. Verás cómo se pasan el acumulador y el valor inicial, cómo calcular totales, máximos y conteos por categoría, y el TypeError que aparece con un array vacío.

Aprende sort, cuyo orden depende de lo que devuelve la función de comparación; toSorted, que conserva el array original; find y findIndex, que devuelven un solo elemento que coincide; y some y every, que devuelven booleanos.

Captura excepciones con try y catch, usa finally para el código que se ejecuta siempre, relanza a quien llama con throw la excepción capturada y separa los casos por tipo con instanceof.

Lanza una excepción con throw new Error donde detectes un valor incorrecto, define tus propios tipos con extends Error, escribe instanceof en el orden correcto y conserva la excepción original con cause.

Aprende los estados pending, fulfilled y rejected de una Promise, una función delay que envuelve setTimeout, cómo recibir resultados con then / catch / finally, el encadenamiento de then y la ejecución simultánea con Promise.all.

Trata las funciones async, que devuelven una Promise al llamarlas, y la espera con await; cómo capturar un rejected con try / catch; la diferencia entre esperar en serie y en paralelo con Promise.all; y el error de olvidar await y quedarte con una Promise en la variable.

Trata los generadores, que devuelven valores y se pausan en cada yield, y cómo los hace avanzar next(); el protocolo de iteración en el que se basa for...of; cómo expandir los valores en un array y qué queda después; y la evaluación perezosa para tomar solo lo necesario de una secuencia infinita.

Un resumen de referencia rápida: cómo elegir métodos de arrays según lo que devuelven, cuándo puedes seguir encadenando, tres formas de esperar (callbacks, then y await) y dónde se capturan un throw síncrono y una Promise que falla.

Verás class, que sirve para crear muchos datos con la misma forma: cómo crear instancias con constructor y new, métodos que leen sus propios valores con this y cuándo usar un objeto literal.

Verás el constructor y los campos de clase, que fijan los valores iniciales de una instancia: cómo recibir argumentos, en qué orden se agregan los campos, valores por defecto para argumentos omitidos y cómo impedir valores inválidos al crearla.

Verás static, que pone valores y métodos en la propia clase en lugar de en sus instancias: campos static que cuentan cuántas se crearon, métodos de fábrica que crean desde JSON, constantes compartidas y cuándo usar miembros de instancia.

Trata los getters y setters, que ejecutan código al leer o asignar una propiedad: propiedades calculadas que se recalculan en cada lectura, validación de los valores asignados, pasar por el setter desde el constructor y propiedades de solo lectura.

Trata los campos y métodos privados, que llevan un # al principio del nombre para impedir leerlos y escribirlos desde fuera de la clase: el SyntaxError que aparece antes de ejecutar si los usas desde afuera y la diferencia con la convención _.

Trata la herencia, que crea una clase nueva a partir de otra existente: cómo escribir extends, la llamada a super() en el constructor de la clase hija, la sobrescritura y super.nombreDelMétodo() para llamar al método del padre.

Trata el polimorfismo: cada clase tiene un método con el mismo nombre y quien llama usa una sola forma. Verás cómo llamar a todos los elementos de un array mixto a la vez, cuándo separar con instanceof y el duck typing para valores que no heredan.

Trata cómo se decide this cuando guardas un método en una variable o lo pasas como callback: el TypeError que aparece al sacarlo, cómo fijarlo con bind, los campos con función flecha y qué tener en cuenta al pasar métodos a setTimeout.

Trata prototype, donde se guardan los métodos de una clase, y la cadena de prototipos, el orden en que se buscan los nombres. Verás Object.getPrototypeOf, la diferencia entre hasOwnProperty e in y cómo agregar funciones.

Trata toString, toJSON y Symbol.iterator, que JavaScript llama en situaciones concretas: cómo decidir el formato con que se muestra un objeto, cómo elegir los valores que van al JSON y cómo recorrer una clase con for...of.

Trata export, que hace públicos los valores de un archivo, e import, que los carga: la diferencia entre exports con nombre y por defecto, type="module" en el navegador y cómo distinguir ESM de CommonJS en Node.js.

Trata la composición, que divide las funcionalidades en piezas y las combina en un solo objeto: agregarlas después con Object.assign, funciones que devuelven piezas con la sintaxis spread, funciones mixin que apilan funcionalidades sobre una clase y cuándo conviene la herencia.

Tablas de referencia rápida que ordenan la sintaxis de clases según dónde vive cada miembro, cómo rastrear qué definición se ejecuta con extends y super, this según la forma de llamar, hasta dónde llegan las funcionalidades con herencia, prototype y composición, y cuándo se detiene tu código por un error.

Cómo el navegador arma el DOM a partir del HTML, en qué orden procesa link y script, el atributo defer que espera a que el DOM esté completo, la consola de DevTools y cómo revisar resultados como texto en la consola de los ejercicios.

querySelector y querySelectorAll para obtener elementos del árbol DOM. Aprende a buscar por class, id y atributos data, a convertir un NodeList en array y a usar ?. cuando no se encuentra nada.

createElement y append para agregar elementos, remove para quitarlos, classList y dataset para cambiar class y atributos, y la diferencia entre textContent e innerHTML para mostrar la entrada del usuario como texto.

addEventListener para llamar a una función al hacer clic, event.target para saber qué elemento se pulsó, delegación de eventos con el bubbling hacia los padres, stopPropagation, y cómo quitar listeners con once y removeEventListener.

value y checked para leer los campos, los eventos input y change que se disparan al escribir, submit y preventDefault para cancelar un envío, y FormData para reunir todos los campos de una vez.

Usa fetch para pedir datos a una URL y json() para convertir el cuerpo en un valor; verás response.ok para saber si salió bien, cómo escribir URL relativas y Promise.all para leer dos JSON a la vez.

Distingue los errores HTTP, con los que fetch no lanza excepciones, de los errores de red, en los que falla el propio fetch; verás cómo cancelar por tiempo con AbortController y setTimeout, y cómo reintentar una sola vez.

setItem, getItem y removeItem de localStorage para guardar valores en el navegador, arrays guardados como JSON porque los valores se convierten en cadenas, el null de las claves que no existen y el límite de espacio.

setTimeout y setInterval y cómo detenerlos, los meses de Date que empiezan en 0, Intl.DateTimeFormat y los días entre dos fechas.