Saltar al contenido
Temas
  • 1 Introducción
    1.1

    Tu primer programa

    Un programa es una lista de instrucciones para la computadora. En JavaScript, cada instrucción es una declaración, y la computadora ejecuta las declaraciones de arriba hacia abajo.

    console.log(...) imprime un valor en la consola, el área de texto debajo del código:

    console.log("Hello, world!");
    console.log(7 * 6);   // 42
    
    • El texto va entre comillas: "Hello" o 'Hello'. Los números no.
    • Termina cada declaración con punto y coma ;. JavaScript a menudo puede adivinar dónde falta, pero escribirlo es más claro.
    • JavaScript distingue entre mayúsculas y minúsculas: console.log funciona, Console.Log no.

    console.log puede imprimir varios valores a la vez. Coloca un espacio entre ellos:

    console.log("Total:", 3 + 4);   // Total: 7
    console.log(1, 2, 3);           // 1 2 3
    
    1.2

    Comentarios y estilo del código

    Un comentario es una nota para las personas. JavaScript lo ignora cuando el programa se ejecuta.

    // A one-line comment starts with two slashes.
    console.log("This line runs");   // a comment can follow code
    
    /* A block comment
       can cover several lines. */
    console.log("So does this one");
    

    Un buen estilo hace que el código sea fácil de leer:

    • Indenta las líneas dentro de { } con dos o cuatro espacios, y hazlo siempre de la misma manera.
    • Da a las variables nombres que indiquen qué contienen: total, no t.
    • Los nombres de JavaScript usan camelCase: firstName, scoreTotal.
    // Work out the area of a rectangle
    const width = 4;
    const height = 3;
    console.log(width * height);   // 12
    

    Errores comunes

    • El texto necesita comillas coincidentes: "Hi' es un error.
    • console.log significa todo en minúsculas: Console.log y console.Log son errores.
    • Todo lo que aparece después de // en una línea se ignora, por lo que // console.log(x) no imprime nada.
  • 2 Valores, variables y tipos
    2.1

    let y const

    Una variable es una caja nombrada que contiene un valor. Crea una con let o const, luego usa su nombre:

    let score = 10;
    score = score + 5;      // let: the value can change
    console.log(score);     // 15
    
    const name = "Mei";     // const: the name cannot be reassigned
    console.log(name);      // Mei
    
    • = significa asignar: calcular el lado derecho, luego almacenarlo en la caja del lado izquierdo.
    • Usa const por defecto. Usa let solo cuando el valor deba cambiar más tarde.
    • Reasignar un const es un error: no se permite name = "Tom". Un objeto o array const aún puede tener su contenido modificado.
    2.2

    Números y matemáticas

    Estos ejemplos usan el tipo number para valores enteros y decimales. BigInt es un tipo entero separado. Los operadores aritméticos son:

    Operador Significado Ejemplo Resultado
    + - sumar, restar 7 - 2 5
    * / multiplicar, dividir 7 / 2 3.5
    % residuo 7 % 2 1
    ** potencia 2 ** 3 8
    console.log(7 / 2);              // 3.5
    console.log(Math.floor(7 / 2));  // 3   (whole-number division)
    console.log(7 % 2);              // 1   (odd numbers leave 1)
    console.log(2 + 3 * 4);          // 14  (* before +)
    console.log((2 + 3) * 4);        // 20
    

    Math contiene funciones útiles:

    console.log(Math.round(2.5));    // 3
    console.log(Math.max(4, 9, 2));  // 9
    console.log(Math.sqrt(49));      // 7
    
    • Math.random() devuelve un número aleatorio desde 0 hasta (sin incluir) 1. Math.floor(Math.random() * 6) + 1 simula el lanzamiento de un dado entre 1 y 6.
    • Los decimales se almacenan en binario, por lo que 0.1 + 0.2 imprime 0.30000000000000004. Redondea un resultado antes de mostrarlo: (0.1 + 0.2).toFixed(2) es ≈"0.30".
    2.3

    Tipos y conversión

    Cada valor tiene un tipo. typeof te indica cuál:

    console.log(typeof 42);         // number
    console.log(typeof "42");       // string
    console.log(typeof true);       // boolean
    console.log(typeof undefined);  // undefined
    
    • Una variable creada con let x; y sin valor es undefined.
    • null significa "sin valor", asignado intencionalmente.

    + con una cadena concatena en lugar de sumar, así que convierte el texto a número primero:

    console.log("5" + 1);           // 51  (joined)
    console.log(Number("5") + 1);   // 6   (added)
    console.log(parseInt("12px"));  // 12  (reads the number at the start)
    console.log(String(9) + "!");   // 9!
    
    • Un texto que no sea un número produce NaN ("not a number"): Number("abc") es NaN.
    • -, * y / convierten texto a número automáticamente ("6" * 2 es ≈12), pero no confíes en ello: realiza la conversión de forma intencional.

    Errores comunes

    • = asigna; no compara. Para comparar usa === (tema 4).
    • "5" + 1 es ≈"51". Convierte la entrada con Number(...) antes de realizar operaciones matemáticas con ella.
    • Math.round(2.5) es ≈3, pero Math.round(-2.5) es ≈-2: redondea los medios hacia arriba, en dirección al número mayor.
  • 3 Cadenas
    3.1

    Caracteres y longitud

    Una cadena es texto entre comillas. Con letras simples, cada carácter tiene una posición, su índice; el primer índice es 0. JavaScript cuenta unidades de código UTF-16: un emoji puede ocupar dos posiciones.

    const word = "Script";
    console.log(word.length);     // 6
    console.log(word[0]);         // S
    console.log(word[2]);         // r
    console.log(word.at(-1));     // t  (counts back from the end)
    console.log(word[word.length - 1]);   // t
    
    • El último índice es length - 1. word[6] es undefined, no un error.
    • Las cadenas son inmutables: word[0] = "s" no puede modificar la cadena y lanza un TypeError en modo estricto. Construye una nueva cadena en su lugar.

    Une cadenas con +, lo cual se llama concatenación:

    const first = "Ada";
    const last = "Lovelace";
    console.log(first + " " + last);   // Ada Lovelace
    
    3.2

    Métodos de String

    Un método es una función que pertenece a un valor. Llámaco con un punto. Un método de cadena devuelve un valor nuevo y deja el original intacto.

    const city = "  Hong Kong ";
    console.log(city.trim());                 // Hong Kong
    console.log(city.trim().toUpperCase());   // HONG KONG
    console.log(city.length);                 // 12  (the spaces are still there)
    
    Método Significado Ejemplo Resultado
    .toUpperCase() / .toLowerCase() cambiar mayúsculas/minúsculas "Hi".toLowerCase() "hi"
    .trim() eliminar espacios en ambos extremos " hi ".trim() "hi"
    .includes(t) ¿contiene t? "cat".includes("a") true
    .indexOf(t) primera posición de t, o -1 "cat".indexOf("t") 2
    .slice(a, b) caracteres desde a hasta (sin incluir) b "Script".slice(0, 3) "Scr"
    .split(sep) dividir en una matriz "a,b,c".split(",") ["a","b","c"]
    .replace(a, b) reemplazar la primera ocurrencia de a por b "cat".replace("c", "b") "bat"
    const email = "[email protected]";
    const at = email.indexOf("@");
    console.log(email.slice(0, at));          // mei
    console.log(email.slice(at + 1));         // school.org
    console.log(email.split("@"));            // ["mei","school.org"]
    
    3.3

    Literales de plantilla

    Un literal de plantilla es una cadena escrita entre comillas invertidas (en la mayoría de los teclados, la tecla a la izquierda de 1). Coloca cualquier expresión dentro de ${ } y su valor se inserta en el texto:

    const name = "Mei";
    const age = 17;
    console.log(`${name} is ${age} years old.`);   // Mei is 17 years old.
    console.log(`Next year: ${age + 1}`);          // Next year: 18
    
    • Las comillas invertidas también pueden contener varias líneas de texto.
    • Esto es más fácil de leer que muchos +: comparar "Hi " + name + "!" con `Hi ${name}!`.
    const price = 4.5;
    console.log(`Two cost $${(price * 2).toFixed(2)}`);   // Two cost $9.00
    

    Errores comunes

    • ${ } solo funciona dentro de comillas invertidas. En "Hi ${name}" el texto se imprime exactamente como está escrito.
    • Los métodos no modifican la cadena: llamar city.trim() en una línea sola no hace nada. Almacena el resultado: const clean = city.trim();.
    • slice(a, b) se detiene antes de b, al igual que el último índice es length - 1.
  • 4 Decisiones
    4.1

    Booleanos y comparaciones

    Un booleano es o bien true o bien false. Una comparación devuelve un booleano:

    Operador Significado Ejemplo Resultado
    === igual (mismo valor y mismo tipo) 5 === 5 true
    !== distinto 5 !== 3 true
    < > menor que, mayor que 2 > 7 false
    <= >= como máximo, como mínimo 7 >= 7 true
    console.log(5 === 5);     // true
    console.log(5 === "5");   // false  (a number is not a string)
    console.log(5 == "5");    // true   (== converts first: avoid it)
    
    • Utilice siempre === y !==. El antiguo == convierte los tipos primero y da resultados inesperados.

    Para condiciones booleanas, use los operadores lógicos de abajo. Con otros valores, && y || devuelven uno de sus operandos; no siempre devuelven un booleano:

    • && (y): verdadero solo si ambos lados son verdaderos.
    • || (o): verdadero si al menos uno de los lados es verdadero.
    • ! (no): transforma true en false y viceversa.
    const age = 15;
    console.log(age >= 13 && age <= 19);   // true   (a teenager)
    console.log(age < 5 || age > 65);      // false
    console.log(!(age > 18));              // true
    
    4.2

    if / else if / else

    Una instrucción if ejecuta un bloque de código cuando su condición es verdadera (tratada como tal). Con condiciones booleanas, esto significa el valor true. else if prueba otra condición; else captura todo lo restante:

    const mark = 72;
    if (mark >= 80) {
      console.log("A");
    } else if (mark >= 60) {
      console.log("B");
    } else {
      console.log("C");
    }
    // prints B
    
    • JavaScript evalúa las condiciones de arriba hacia abajo y ejecuta solo la primera rama verdadera.
    • La condición va entre paréntesis redondos; el código a ejecutar va entre llaves { }.

    Por eso importa el orden. Coloque la prueba más estricta primero:

    const temp = 35;
    if (temp > 30) {
      console.log("hot");
    } else if (temp > 20) {
      console.log("warm");   // skipped: the first branch already ran
    }
    // prints hot
    
    4.3

    switch

    Una instrucción switch compara un valor contra varios casos fijos. Es más limpia que una larga cadena else if cuando cada prueba es "¿es igual a …?":

    const day = "Sat";
    switch (day) {
      case "Sat":
      case "Sun":
        console.log("weekend");
        break;
      case "Fri":
        console.log("nearly there");
        break;
      default:
        console.log("school day");
    }
    // prints weekend
    
    • switch compara con ===, por lo que case 1: no coincide con la cadena "1".
    • break termina el switch. Sin ella, el código cae al siguiente caso.
    • default se ejecuta cuando ningún caso coincide, como un último else.
    • Dos casos sin código entre ellos comparten el mismo código, como "Sat" y "Sun" hacen aquí.

    Errores comunes

    • if (x = 5) asigna en lugar de comparar, y la prueba resulta siempre verdadera. Escriba if (x === 5).
    • if (age > 13 && < 19) es un error: repita la variable, age > 13 && age < 19.
    • Un break faltante en un switch ejecuta el siguiente caso también.
  • 5 Bucles
    5.1

    Bucle for

    Las tres partes de un bucle for y el orden en que se ejecutan

    Un bucle repite un bloque de código. Un bucle for es ideal cuando sabes cuántas veces debe repetirse. Sus corchetes contienen tres partes separadas por puntos y comas:

    for (let i = 1; i <= 3; i++) {
      console.log(i);
    }
    // 1
    // 2
    // 3
    
    1. inicio: let i = 1 se ejecuta una vez, antes del bucle.
    2. condición: i <= 3 se verifica antes de cada pasada; el bucle se detiene cuando la condición es falsa.
    3. paso: i++ (sumar 1 a i) se ejecuta después de cada pasada.

    Cada pasada a través del bucle es una iteración. Cambia el paso para contar de otras formas:

    let line = "";
    for (let i = 10; i > 0; i -= 3) {
      line += i + " ";
    }
    console.log(line);   // 10 7 4 1
    

    El patrón acumulador crea una variable antes del bucle y la actualiza en cada pasada:

    let total = 0;
    for (let n = 1; n <= 5; n++) {
      total += n;          // the same as total = total + n
    }
    console.log(total);    // 15
    
    5.2

    Bucle while

    Un bucle while se repite mientras su condición sea verdadera. Úsalo cuando no sepas de antemano cuántas pasadas necesitas:

    let money = 100;
    let years = 0;
    while (money < 200) {
      money = money * 1.1;   // 10% interest each year
      years++;
    }
    console.log(years);      // 8
    
    • La condición se verifica antes de cada pasada, por lo que el cuerpo podría ejecutarse cero veces.
    • Si la condición permanece verdadera y no se alcanza un break u otra salida, obtendrás un bucle infinito. (Presiona Detener si eso sucede.)
    5.3

    for...of, break y continue

    for...of visita cada elemento de un array (o cada carácter de una cadena) sucesivamente, sin necesidad de gestionar un índice:

    const fruits = ["apple", "kiwi", "plum"];
    for (const fruit of fruits) {
      console.log(fruit.toUpperCase());
    }
    // APPLE
    // KIWI
    // PLUM
    

    break sale inmediatamente de un bucle; continue omite el resto de esta iteración y pasa a la siguiente:

    const marks = [55, 80, -1, 90];
    let sum = 0;
    for (const m of marks) {
      if (m < 0) {
        break;            // -1 means "end of the data"
      }
      if (m < 60) {
        continue;         // skip a fail, keep looping
      }
      sum += m;
    }
    console.log(sum);     // 80
    

    Errores comunes

    • Error off-by-one: i < 3 itera sobre 0, 1, 2; i <= 3 se ejecuta una vez más. Cuenta las pasadas.
    • Iniciar el total dentro del bucle: let total = 0; debe colocarse antes del bucle, o se reiniciará en cada pasada.
    • Un bucle while se ejecutará indefinidamente si su condición permanece verdadera y no se alcanza ninguna salida.
  • 6 Funciones
    6.1

    Parámetros y retorno

    Una función es un fragmento de código reutilizable. Una declaración de función le asigna un nombre, que puedes usar para invocarla:

    function greet(name) {
      return `Hello, ${name}!`;
    }
    
    console.log(greet("Mei"));   // Hello, Mei!
    console.log(greet("Tom"));   // Hello, Tom!
    
    • name es un parámetro: una variable que recibe un valor cuando se llama a la función.
    • "Mei" es el argumento: el valor real que se pasa.
    • return devuelve un valor al llamador y termina la función de inmediato.

    Una función regular que llega a su final sin devolver un valor devuelve undefined. Por lo tanto, devuelve la respuesta y deja que el llamador decida si debe imprimirla:

    function area(width, height) {
      return width * height;
    }
    
    const a = area(4, 3);
    console.log(a + 1);          // 13  (a returned value can be used again)
    
    6.2

    Funciones de flecha

    Una función de flecha es una forma más corta de escribir una función. Guárdala en un const:

    const square = (n) => n * n;
    const add = (a, b) => a + b;
    
    console.log(square(5));      // 25
    console.log(add(2, 3));      // 5
    
    • Con una expresión después de =>, su valor se devuelve sin escribir return.
    • Con llaves necesitas return nuevamente:
    const grade = (mark) => {
      if (mark >= 50) {
        return "pass";
      }
      return "fail";
    };
    console.log(grade(64));      // pass
    

    Las funciones de flecha a menudo se pasan a otras funciones, como verás con map y filter en el tema 7.

    6.3

    Alcance

    El alcance de una variable es la parte del código que puede verla. Una variable creada con let o const dentro de { } es accesible en ese bloque y sus alcances anidados. Una función anidada puede mantener el acceso después de que la llamada externa regresa:

    const level = "global";
    
    function show() {
      const inside = "local";
      console.log(level);        // global  (outer variables are visible)
      console.log(inside);       // local
    }
    
    show();
    console.log(typeof inside);  // undefined  (inside does not exist out here)
    
    • Una variable creada dentro de una función es una variable local; cada llamada obtiene una nueva.
    • Pasa valores hacia adentro como parámetros y obtén resultados hacia afuera con return, en lugar de modificar variables externas desde dentro de una función.

    Errores comunes

    • Olvidar return: la función calcula la respuesta, luego devuelve undefined.
    • Llamar sin paréntesis: greet es la propia función; greet("Mei") la ejecuta.
    • Imprimir dentro de la función y imprimir su resultado imprime dos veces, o imprime undefined.
  • 7 Arreglos
    7.1

    Creación y modificación de arrays

    Un array contiene una lista de valores en orden, dentro de corchetes. Cada elemento es un ítem, y el primer índice es 0:

    const scores = [72, 88, 95];
    console.log(scores[0]);        // 72
    console.log(scores.length);    // 3
    scores[1] = 90;                // change one element
    console.log(scores);           // [72,90,95]
    
    • const te impide reasignar scores a un array completamente nuevo, pero aún puedes cambiar lo que hay dentro de él.
    • Leer más allá del final da undefined: scores[3] es undefined.

    Añade y elimina en el extremo con push y pop:

    const queue = ["Ann", "Ben"];
    queue.push("Cai");             // add to the end
    console.log(queue);            // ["Ann","Ben","Cai"]
    const last = queue.pop();      // remove from the end and return it
    console.log(last);             // Cai
    console.log(queue.length);     // 2
    

    Un array puede contener arrays. Eso crea una cuadrícula, leída con dos índices, fila primero:

    const grid = [
      [1, 2, 3],
      [4, 5, 6],
    ];
    console.log(grid[1][2]);       // 6  (row 1, column 2)
    
    7.2

    map, filter y reduce

    Estos métodos toman una función y la aplican a los elementos del array. Devuelven un array (o valor) nuevo sin reemplazar los elementos originales. La función que pasas puede modificar el array original o sus objetos:

    • map crea un nuevo array cambiando cada elemento.
    • filter conserva solo los elementos para los cuales la función retorna true.
    • reduce combina todos los elementos en un solo valor, como un total.
    const prices = [4, 10, 25];
    const withTax = prices.map((p) => p * 1.1);
    console.log(withTax.map((p) => p.toFixed(2)));   // ["4.40","11.00","27.50"]
    
    const cheap = prices.filter((p) => p < 20);
    console.log(cheap);                              // [4,10]
    
    const total = prices.reduce((sum, p) => sum + p, 0);
    console.log(total);                              // 39
    

    En reduce, sum es el acumulador. Comienza con el último argumento (0) y recibe el resultado de la función tras cada elemento.

    7.3

    Búsqueda y ordenamiento

    sort() sin función de comparación ordena números como texto
    Método Devuelve Ejemplo con [5, 8, 2] Resultado
    .includes(x) true o false .includes(8) true
    .indexOf(x) el primer índice de x, o -1 .indexOf(2) 2
    .find(f) el primer elemento donde f es verdadero .find((n) => n > 6) 8
    .findIndex(f) su índice, o -1 .findIndex((n) => n > 6) 1

    sort ordena los elementos. Sin función, los ordena como texto, por lo que los números quedan en el orden incorrecto:

    const nums = [10, 9, 100, 1];
    console.log([...nums].sort());                   // [1,10,100,9]   (as text!)
    console.log([...nums].sort((a, b) => a - b));    // [1,9,10,100]
    console.log([...nums].sort((a, b) => b - a));    // [100,10,9,1]
    
    • La función de comparación retorna un número negativo cuando a debe ir primero, y un número positivo cuando b debe irlo.
    • sort modifica el propio array. [...nums] hace una copia primero, por lo que nums mantiene su orden.

    Errores comunes

    • El último elemento es arr[arr.length - 1], no arr[arr.length].
    • map y filter no modifican el array: guarda su resultado.
    • nums.sort() sobre números los ordena como texto. Pasa (a, b) => a - b.
  • 8 Objetos
    8.1

    Objetos y propiedades

    Un objeto agrupa valores relacionados bajo nombres. Cada par nombre-valor es una propiedad. El nombre se llama clave:

    const pupil = {
      name: "Mei",
      age: 17,
      form: "11A",
    };
    console.log(pupil.name);       // Mei
    console.log(pupil["form"]);    // 11A  (bracket form, with the key as a string)
    
    • Lea una propiedad con un punto (pupil.age) o con corchetes (pupil["age"]). Use corchetes cuando la clave esté en una variable: pupil[field].
    • Una clave que no existe devuelve undefined.

    Cambie una propiedad o agregue una nueva asignándole un valor:

    const pupil = { name: "Mei", age: 17 };
    pupil.age = 18;                // change
    pupil.house = "Red";           // add
    console.log(pupil);            // {"name":"Mei","age":18,"house":"Red"}
    
    8.2

    Arreglos de objetos

    Una lista de registros es un array de objetos. Combinarlo con los métodos de array del tema 7:

    const pupils = [
      { name: "Mei", mark: 88 },
      { name: "Tom", mark: 64 },
      { name: "Sara", mark: 95 },
    ];
    
    const passed = pupils.filter((p) => p.mark >= 70);
    console.log(passed.map((p) => p.name));            // ["Mei","Sara"]
    
    const best = [...pupils].sort((a, b) => b.mark - a.mark)[0];
    console.log(`${best.name} has the top mark`);       // Sara has the top mark
    

    Para sumar una propiedad, use reduce o un bucle:

    const pupils = [{ mark: 88 }, { mark: 64 }, { mark: 95 }];
    let sum = 0;
    for (const p of pupils) {
      sum += p.mark;
    }
    console.log((sum / pupils.length).toFixed(1));      // 82.3
    
    8.3

    Iterar sobre un objeto

    Object.keys da un array de las claves, y Object.entries da pares [key, value], para poder iterar sobre ellos:

    const stock = { pens: 12, rulers: 0, books: 5 };
    
    console.log(Object.keys(stock));             // ["pens","rulers","books"]
    
    for (const [item, count] of Object.entries(stock)) {
      if (count === 0) {
        console.log(`${item}: sold out`);
      }
    }
    // rulers: sold out
    

    Un objeto es un buen contador: use cada elemento que cuente como una clave.

    const words = ["red", "blue", "red", "red"];
    const counts = {};
    for (const w of words) {
      counts[w] = (counts[w] || 0) + 1;   // 0 the first time the key is seen
    }
    console.log(counts);                  // {"red":3,"blue":1}
    

    Errores comunes

    • pupil.field busca una clave llamada field. Cuando la clave está en una variable, escriba pupil[field].
    • Una coma va entre propiedades, no punto y coma: { name: "Mei", age: 17 }.
    • for...of no puede iterar directamente sobre un objeto. Itere sobre Object.keys(...) o Object.entries(...).
  • 9 Errores
    9.1

    Lectura de mensajes de error

    Cuando JavaScript no puede continuar, se detiene y muestra un error. La primera palabra nombra el tipo de error; el resto indica qué salió mal y dónde. Léalo y luego revise la línea a la que hace referencia.

    SyntaxError: missing ) after argument list
    ReferenceError: totl is not defined
    TypeError: Cannot read properties of undefined (reading 'length')
    
    Error Significado Causa típica
    SyntaxError el código no está escrito correctamente, por lo que nada se ejecuta un paréntesis o comilla faltante
    ReferenceError un nombre que no existe un error ortográfico: totl por total
    TypeError el valor tiene el tipo incorrecto para lo que hizo usar .length sobre undefined

    La redacción exacta puede variar entre navegadores, pero el nombre del error es el mismo. Este programa captura cada error para poder imprimir su nombre:

    try {
      const total = 5;
      console.log(totl);
    } catch (e) {
      console.log(e.name);           // ReferenceError
    }
    
    try {
      const pupil = undefined;
      console.log(pupil.length);
    } catch (e) {
      console.log(e.name);           // TypeError
    }
    

    Algunos errores no generan una excepción, solo dan un resultado incorrecto: un error lógico. Para detectarlo, imprime los valores intermedios con console.log y verifícalos manualmente.

    9.2

    intentar, capturar y lanzar

    El código que podría fallar va dentro de un bloque try. Si ocurre un error allí, JavaScript salta a catch en lugar de detenerse, y e contiene el error:

    try {
      JSON.parse("{not valid}");
      console.log("parsed");         // skipped
    } catch (e) {
      console.log("Could not read the data");
    }
    console.log("The program carries on");
    

    Tu propio código puede lanzar un error con throw. Esto permite que una función rechace entradas incorrectas de forma clara, en vez de devolver un resultado erróneo:

    function average(list) {
      if (list.length === 0) {
        throw new Error("the list is empty");
      }
      return list.reduce((s, x) => s + x, 0) / list.length;
    }
    
    console.log(average([4, 6]));    // 5
    try {
      average([]);
    } catch (e) {
      console.log(`Error: ${e.message}`);   // Error: the list is empty
    }
    
    • new Error("…") crea un error cuyo message es tu texto.
    • Usa try solo alrededor de código que pueda fallar realmente, como la lectura de datos. No lo uses para ocultar errores en tu propio código.

    Errores comunes

    • Saltarse el mensaje. Su primera línea indica el tipo de error y qué salió mal; comienza por ahí.
    • Un catch que no hace nada (catch (e) {}) oculta el problema: al menos imprime e.message.
    • throw "text" funciona, pero throw new Error("text") también registra dónde ocurrió el error.

Iniciar sesión o crear cuenta

IGCSE, A-Level & AP