Volver al blog

Ejercicios de JavaScript resueltos para principiantes: 10 ejercicios de menos a más (con DOM y fetch)

Ejercicios de JavaScript resueltos para principiantes: 10 ejercicios de menos a más (con DOM y fetch)

JavaScript se aprende resolviendo problemas pequeños y viendo el resultado en la consola, no memorizando métodos. Aquí tienes diez ejercicios de JavaScript resueltos para principiantes, ordenados de menos a más difíciles: números y conversiones, bucles, cadenas, arrays con map, filter y reduce, objetos, Set, un formulario con validación en el DOM y una petición con fetch y async/await. Cada uno tiene el enunciado, la solución completa, el resultado exacto que debe salirte, la explicación de la trampa típica y una variación para practicar.

Son los ejercicios que más se repiten en Desarrollo Web en Entorno Cliente de DAW, en las asignaturas de programación web de la universidad y en cualquier curso de iniciación al desarrollo web. Al final tienes seis preguntas de "¿qué imprime?" con las rarezas de JavaScript que más caen en los exámenes.

Cómo usar estos ejercicios

  1. Tápate la solución y escribe primero los pasos en comentarios, en castellano.
  2. Inténtalo al menos 15 minutos. Si te atascas, mira solo la parte que te falta y sigue tú.
  3. Haz la variación sin mirar nada. Si te sale, el concepto está aprendido.

Los ejercicios 1 a 8 se pueden ejecutar en la consola del navegador (F12 → Consola) o con Node.js (node ejercicio.js). Los ejercicios 9 y 10 necesitan una página HTML. Todo el código está probado y usa JavaScript moderno: const y let, funciones flecha y plantillas de texto. No uses var: en el último bloque verás por qué.

Nº Ejercicio Qué practicas
1 Precio final con descuento e IVA Números, redondeo, Number()
2 FizzBuzz for, operador %, condiciones
3 Detectar palíndromos Métodos de cadena, normalize, expresiones regulares
4 Contar vocales con tildes for...of, includes
5 Suma, media, máximo y mínimo reduce, Math.max, spread
6 Alumnos aprobados ordenados por nota Arrays de objetos, filter, sort, map
7 Palabras más repetidas de un texto Objetos como diccionario, Object.entries
8 Duplicados, intersección y unión Set
9 Validar un formulario DOM, eventos, preventDefault
10 Mostrar datos de una API fetch, async/await, try/catch

Ejercicio 1: precio final con descuento e IVA

Enunciado. Escribe una función que reciba un precio y un porcentaje de descuento, aplique el descuento, sume el 21 % de IVA y devuelva el resultado redondeado a dos decimales.

function precioFinal(precio, descuento) {
  const conDescuento = precio * (1 - descuento / 100);
  const conIva = conDescuento * 1.21;
  return Math.round(conIva * 100) / 100;
}

console.log(precioFinal(49.99, 15));   // 51.41
console.log(precioFinal(100, 0));      // 121

Por qué está hecho así:

  • El redondeo se hace al final, sobre el número. Math.round(x * 100) / 100 devuelve un número; x.toFixed(2) devuelve un texto ("51.41"), útil solo para mostrarlo.
  • Los decimales en JavaScript no son exactos: 0.1 + 0.2 da 0.30000000000000004. No es un fallo de tu código, es cómo se guardan los números en binario en casi todos los lenguajes. Por eso se redondea antes de mostrar dinero.

Si el precio viene de un input, llega como texto. Number("12,5") da NaN porque JavaScript espera punto decimal: hay que hacer Number(texto.replace(",", ".")). Y cuidado con parseInt("12abc"), que devuelve 12 sin quejarse, mientras que Number("12abc") devuelve NaN, que es lo que normalmente quieres para detectar errores.

Variación: si el descuento no está entre 0 y 100, la función debe devolver null.

Ejercicio 2: FizzBuzz

Enunciado. Muestra los números del 1 al 15. Si el número es múltiplo de 3, escribe "Fizz"; si es múltiplo de 5, "Buzz"; si es de los dos, "FizzBuzz".

for (let i = 1; i <= 15; i++) {
  let salida = "";
  if (i % 3 === 0) salida += "Fizz";
  if (i % 5 === 0) salida += "Buzz";
  console.log(salida || i);
}
// 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz

La versión típica con if / else if falla si compruebas primero el 3: el 15 entraría ahí y nunca llegaría a "FizzBuzz". Construir el texto por partes evita tener que pensar en el orden. salida || i aprovecha que una cadena vacía cuenta como falsa: si no se ha añadido nada, se muestra el número.

Variación: añade "Bang" para los múltiplos de 7. Con este enfoque es una línea más.

Ejercicio 3: detectar palíndromos

Enunciado. Una función que diga si una frase se lee igual al derecho que al revés, ignorando mayúsculas, espacios, signos y tildes.

function esPalindromo(texto) {
  const limpio = texto
    .toLowerCase()
    .normalize("NFD")
    .replace(/[̀-ͯ]/g, "")
    .replace(/[^a-z0-9]/g, "");
  return limpio === [...limpio].reverse().join("");
}

console.log(esPalindromo("Dábale arroz a la zorra el abad"));   // true
console.log(esPalindromo("Anita lava la tina"));                // true
console.log(esPalindromo("Hola"));                              // false
  • normalize("NFD") separa cada letra de su tilde (á pasa a ser a + un acento suelto) y la expresión regular [̀-ͯ] borra esos acentos. Sin esto, "Dábale" nunca coincidiría con "abad" al revés. La ñ también se queda en n, que para un palíndromo no importa.
  • Las cadenas no tienen reverse(). Se convierten en array con [...limpio], se invierten y se vuelven a unir con join("").

Variación: hazlo sin reverse(), comparando con un bucle el primer carácter con el último, el segundo con el penúltimo, etc. Es la versión que te pedirán si el examen prohíbe métodos de array.

Ejercicio 4: contar vocales (también con tilde)

Enunciado. Cuenta cuántas vocales tiene un texto, incluidas las acentuadas.

function contarVocales(texto) {
  const vocales = "aeiouáéíóúü";
  let cuenta = 0;
  for (const letra of texto.toLowerCase()) {
    if (vocales.includes(letra)) cuenta++;
  }
  return cuenta;
}

console.log(contarVocales("Programación en JavaScript"));   // 9

for...of recorre directamente los caracteres de la cadena, sin índices. Pasar a minúsculas antes de comparar evita tener que escribir también las vocales en mayúscula. En un texto en español, si olvidas las vocales con tilde, "Programación" cuenta una vocal menos.

Variación: devuelve un objeto con cuántas veces aparece cada vocal: { a: 4, e: 1, ... }.

Ejercicio 5: suma, media, máximo y mínimo

Enunciado. Una función que reciba un array de números y devuelva un objeto con la suma, la media, el máximo y el mínimo. Con un array vacío debe devolver null.

function estadisticas(numeros) {
  if (numeros.length === 0) return null;
  const suma = numeros.reduce((acc, n) => acc + n, 0);
  return {
    suma,
    media: suma / numeros.length,
    max: Math.max(...numeros),
    min: Math.min(...numeros),
  };
}

console.log(estadisticas([7, -2, 15, 0, 9]));
// { suma: 29, media: 5.8, max: 15, min: -2 }
console.log(estadisticas([]));   // null
  • reduce recorre el array acumulando un valor. El segundo argumento (0) es el valor inicial del acumulador: si lo omites y el array está vacío, reduce lanza un error.
  • Math.max no acepta un array, acepta números sueltos. Los tres puntos (...numeros) "esparcen" el array como argumentos.
  • Sin la comprobación del principio, la media de un array vacío sería 0 / 0, que da NaN, y Math.max() sin argumentos da -Infinity. Comprobar los casos límite antes de calcular es lo que distingue una solución de 10 de una de 7.

Variación: hazlo con un solo bucle for, sin reduce ni Math.max. Es lo que se pide en los primeros exámenes.

Ejercicio 6: alumnos aprobados ordenados por nota

Enunciado. A partir de una lista de alumnos, obtén los nombres de los aprobados, ordenados de mayor a menor nota, con el formato Nombre (nota). Calcula también la media del grupo.

const alumnos = [
  { nombre: "Pau", nota: 7.5 },
  { nombre: "Lucía", nota: 4.2 },
  { nombre: "Jordi", nota: 9.1 },
  { nombre: "Sara", nota: 5 },
  { nombre: "Hugo", nota: 3.8 },
];

const aprobados = alumnos
  .filter((a) => a.nota >= 5)
  .sort((a, b) => b.nota - a.nota)
  .map((a) => `${a.nombre} (${a.nota})`);

console.log(aprobados);   // ["Jordi (9.1)", "Pau (7.5)", "Sara (5)"]

const media = alumnos.reduce((acc, a) => acc + a.nota, 0) / alumnos.length;
console.log(media.toFixed(2));   // "5.92"

Este es el patrón más útil de JavaScript y el que más se usa en el trabajo real: filter decide qué elementos se quedan, sort los ordena y map transforma cada uno. Cada método devuelve un array nuevo, así que se pueden encadenar.

La trampa está en sort. Sin función de comparación, sort ordena como texto: [10, 1, 2, 25].sort() da [1, 10, 2, 25]. Para ordenar números, la función (a, b) => b.nota - a.nota devuelve un número negativo, cero o positivo y JavaScript coloca los elementos según el signo. Además, filter se aplica antes que sort por un motivo práctico: así no se modifica el array original alumnos, porque sort ordena el array sobre el que se llama.

Variación: obtén un objeto con el número de suspensos, aprobados, notables y sobresalientes.

Ejercicio 7: las palabras más repetidas de un texto

Enunciado. Cuenta cuántas veces aparece cada palabra en un texto (sin distinguir mayúsculas ni signos) y devuelve la lista ordenada de más a menos frecuente.

function frecuencias(texto) {
  const palabras = texto.toLowerCase().match(/[a-záéíóúüñ]+/g) ?? [];
  const cuenta = {};
  for (const p of palabras) {
    cuenta[p] = (cuenta[p] ?? 0) + 1;
  }
  return Object.entries(cuenta).sort((a, b) => b[1] - a[1]);
}

console.log(frecuencias("El perro y el gato. El gato duerme, el perro no."));
// [["el", 4], ["perro", 2], ["gato", 2], ["y", 1], ["duerme", 1], ["no", 1]]
  • match con la bandera g devuelve todas las palabras; si el texto no tiene ninguna devuelve null, y el operador ?? lo cambia por un array vacío.
  • cuenta[p] ?? 0 vale 0 la primera vez que aparece una palabra. Sin eso, undefined + 1 daría NaN.
  • Object.entries convierte el objeto en una lista de pares [palabra, veces] que ya se puede ordenar. En empates se mantiene el orden de aparición, porque sort es estable.

Variación: devuelve solo las tres palabras más frecuentes que tengan más de tres letras.

Ejercicio 8: duplicados, intersección y unión con Set

Enunciado. Dados dos arrays, obtén: el primero sin duplicados, los elementos comunes a los dos y la unión sin repetidos.

const a = [1, 2, 2, 3, 4, 4, 5];
const b = [4, 5, 6, 7, 5];

const sinDuplicados = [...new Set(a)];                  // [1, 2, 3, 4, 5]
const conjuntoB = new Set(b);
const comunes = sinDuplicados.filter((x) => conjuntoB.has(x));   // [4, 5]
const union = [...new Set([...a, ...b])];               // [1, 2, 3, 4, 5, 6, 7]

Un Set solo guarda valores únicos, así que pasar un array por un Set y volver a convertirlo es la forma más corta de quitar duplicados. Para la intersección se podría usar b.includes(x), pero includes recorre el array entero en cada búsqueda; Set.has es inmediato, y con miles de elementos la diferencia se nota.

Ojo: un Set compara objetos por referencia, no por contenido. Dos objetos { id: 1 } distintos no se consideran duplicados.

Variación: obtén los elementos que están en a pero no en b.

Ejercicio 9: validar un formulario en el DOM

Enunciado. Un formulario de registro con email y contraseña. Al enviarlo, comprueba que el email tenga un formato válido y que la contraseña tenga al menos 8 caracteres y un número. Muestra los errores debajo del formulario sin recargar la página.

<form id="registro" novalidate>
  <input id="email" type="email" placeholder="Email">
  <input id="password" type="password" placeholder="Contraseña">
  <button type="submit">Crear cuenta</button>
  <ul id="errores"></ul>
</form>

<script>
  const form = document.querySelector("#registro");
  const listaErrores = document.querySelector("#errores");

  form.addEventListener("submit", (evento) => {
    evento.preventDefault();

    const email = document.querySelector("#email").value.trim();
    const password = document.querySelector("#password").value;
    const errores = [];

    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
      errores.push("El email no tiene un formato válido");
    }
    if (password.length < 8) {
      errores.push("La contraseña necesita al menos 8 caracteres");
    }
    if (!/\d/.test(password)) {
      errores.push("La contraseña necesita al menos un número");
    }

    listaErrores.innerHTML = "";
    for (const error of errores) {
      const li = document.createElement("li");
      li.textContent = error;
      listaErrores.append(li);
    }

    if (errores.length === 0) {
      listaErrores.textContent = "Cuenta creada correctamente";
    }
  });
</script>
  • preventDefault() evita que el formulario se envíe y recargue la página. Sin él, los mensajes aparecen y desaparecen en un instante.
  • Se escucha el evento submit del formulario, no el click del botón: así también funciona al pulsar Intro.
  • El <script> va al final del <body> (o con defer): si se ejecuta antes de que exista el formulario, querySelector devuelve null y todo falla.
  • Los errores se insertan con textContent y no con innerHTML, para que un texto escrito por el usuario nunca se interprete como HTML.
  • La validación en el navegador es para mejorar la experiencia del usuario, no para seguridad: el servidor siempre tiene que volver a validar.

Este es el tipo de ejercicio central de la parte de DOM en DAW. Si te da problemas, tienes los siete errores más habituales explicados en JavaScript en DAW: Desarrollo Web en Entorno Cliente.

Variación: muestra cada error al lado de su campo y valídalo en el evento input, mientras el usuario escribe.

Ejercicio 10: mostrar datos de una API con fetch

Enunciado. Pide la lista de usuarios a la API de pruebas https://jsonplaceholder.typicode.com/users y muestra en una lista el nombre y la ciudad de cada uno. Si algo falla, muestra un mensaje de error.

<ul id="usuarios"><li>Cargando...</li></ul>

<script>
  async function cargarUsuarios() {
    const lista = document.querySelector("#usuarios");
    try {
      const respuesta = await fetch("https://jsonplaceholder.typicode.com/users");
      if (!respuesta.ok) {
        throw new Error(`Error HTTP ${respuesta.status}`);
      }
      const usuarios = await respuesta.json();

      lista.innerHTML = "";
      for (const u of usuarios) {
        const li = document.createElement("li");
        li.textContent = `${u.name} (${u.address.city})`;
        lista.append(li);
      }
    } catch (error) {
      lista.textContent = "No se han podido cargar los usuarios: " + error.message;
    }
  }

  cargarUsuarios();
</script>
  • fetch no devuelve los datos: devuelve una promesa de que llegarán. await espera a que se cumpla, y solo se puede usar dentro de una función async (o en un módulo).
  • Hay que hacer dos await: uno para la respuesta y otro para leer el cuerpo con .json(), que también es asíncrono.
  • fetch no lanza un error con un 404 o un 500, solo cuando no hay conexión. Por eso se comprueba respuesta.ok y se lanza el error a mano.
  • El fallo más común en clase es usar los datos fuera de la función, antes de que hayan llegado: el código que depende de la respuesta tiene que ir después del await.

Variación: añade un campo de búsqueda que filtre la lista por nombre sin volver a llamar a la API.

Seis preguntas de "¿qué imprime?"

Intenta responder antes de leer la solución. Son las rarezas de JavaScript que más aparecen en exámenes y entrevistas.

1. Ordenar números

console.log([10, 1, 2, 25].sort());

[1, 10, 2, 25]. Sin función de comparación, sort convierte los elementos a texto y "10" va antes que "2". Se arregla con .sort((a, b) => a - b).

2. Sumar y restar textos

console.log("5" + 3, "5" - 3, "5" * "2", true + 1);

53 2 10 2. + con un texto concatena; - y * solo funcionan con números, así que convierten. true vale 1. Es el motivo de que un formulario "sume" "5" + "3" y dé "53".

3. == frente a ===

console.log(0 == "", null == undefined, null === undefined, NaN === NaN);

true true false false. == convierte tipos antes de comparar y da resultados sorprendentes; === compara valor y tipo. Usa siempre ===. NaN no es igual a nada, ni a sí mismo: se comprueba con Number.isNaN(x).

4. typeof

console.log(typeof null, typeof [], typeof NaN);

object object number. Lo de null es un error histórico del lenguaje que nunca se corrigió. Para saber si algo es un array se usa Array.isArray(x).

5. var frente a let en un bucle

for (var i = 0; i < 3; i++) setTimeout(() => console.log(i), 0);
for (let j = 0; j < 3; j++) setTimeout(() => console.log(j), 0);

Primero 3 3 3 y después 0 1 2. Con var hay una única variable i para todo el bucle y, cuando se ejecutan los setTimeout, ya vale 3. Con let cada vuelta tiene su propia j.

6. Copiar un objeto

const o = { n: 1 };
const o2 = o;
o2.n = 2;
console.log(o.n, [1, 2] === [1, 2]);

2 false. o2 = o no copia el objeto: las dos variables apuntan al mismo. Y dos arrays con el mismo contenido son objetos distintos, así que === da false. Para copiar se usa { ...o } o structuredClone(o). Si vienes de C, es la misma idea que dos punteros a la misma dirección (lo tienes explicado en punteros en C explicados).

Si has fallado alguna, ejecútala con un punto de ruptura en las herramientas del navegador y mira cómo cambian las variables. Tienes la técnica en cómo depurar código paso a paso.

Cómo practicar para que se quede

Usa la consola todo el rato. Antes de usar un método en tu código, pruébalo en la consola con un ejemplo pequeño. Así descubres que sort ordena como texto en diez segundos y no en el examen.

Primero con bucles, luego con métodos. Si map, filter y reduce te cuestan, resuelve el ejercicio con un for y después reescríbelo. Entender qué hace un reduce por dentro es más importante que memorizar su sintaxis.

No dejes que la IA escriba los ejercicios por ti. Usarla para que te explique un error está bien; dejar que complete el código hace que entiendas la solución pero no sepas escribirla. Si el examen es sin ayudas, practica sin ayudas. Tienes más estrategias en cómo preparar un examen práctico de programación.

Construye algo pequeño. Cuando domines estos diez, junta varios en una mini aplicación: una lista de tareas que se guarde en localStorage, un buscador sobre una API o un carrito con descuento e IVA. Es lo que más se parece a una práctica de DAW o a una prueba técnica.

Cuándo pedir ayuda

Vas bien si resuelves los diez ejercicios sin mirar la solución y aciertas al menos cinco de las seis preguntas de "¿qué imprime?". Merece la pena pedir ayuda cuando:

  • Entiendes las soluciones al leerlas, pero delante de un enunciado nuevo no sabes por dónde empezar.
  • El DOM o fetch "a veces funcionan y a veces no" y no sabes por qué.
  • Tu curso ya va por frameworks como React o Angular y todavía dudas con arrays, objetos o promesas.
  • Tienes un examen, una práctica o una prueba técnica cerca y no sabes qué priorizar.

En nuestras clases particulares de JavaScript online trabajamos con tus enunciados, tus prácticas y tus exámenes de otros años: escribes tú el código y el profesor te guía hasta que te sale solo. Si estudias un ciclo, lo adaptamos al temario de DAM y DAW, y si partes de cero, empezamos por la lógica con las clases para aprender programación desde cero. Son clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.

Preguntas frecuentes

¿Por dónde empiezo a hacer ejercicios de JavaScript?

Por ejercicios de variables, condiciones y bucles en la consola (como los ejercicios 1 y 2), luego cadenas y arrays, después arrays de objetos con map, filter y reduce, y por último DOM y fetch. Si todavía no tienes claro qué es una variable o un bucle, sigue antes la ruta de cómo aprender programación desde cero.

¿Dónde ejecuto los ejercicios de JavaScript?

En la consola del navegador (F12 en Chrome, Firefox o Edge) para los ejercicios sin HTML, o con Node.js desde la terminal. Para los ejercicios con DOM, crea un archivo index.html con el código y ábrelo en el navegador. VS Code con la extensión Live Server recarga la página cada vez que guardas.

¿Es difícil JavaScript para principiantes?

Empezar es fácil porque no hay que instalar nada y el resultado se ve en el navegador. Lo que cuesta son sus rarezas (conversiones de tipos, this, asincronía) y que muchos errores no paran el programa: simplemente da un resultado inesperado. Por eso conviene aprenderlo con ejercicios que muestren el resultado exacto, como estos.

¿Qué debo saber de JavaScript antes de aprender React?

Arrays y objetos con soltura, map y filter (React los usa constantemente para pintar listas), funciones flecha, desestructuración, spread (...), módulos con import y export, y promesas con async/await. Si resuelves los ejercicios 5 a 10 sin mirar, estás preparado.

¿JavaScript o Python para empezar a programar?

Si te interesa el desarrollo web o estudias DAW, JavaScript, porque lo vas a necesitar igualmente y ves el resultado en una página. Si quieres aprender lógica con la menor sintaxis posible, o te interesan los datos y la automatización, Python. Tienes ejercicios equivalentes en ejercicios de Python resueltos para principiantes.

¿Cuántos ejercicios tengo que hacer para aprender JavaScript?

No hay un número mágico. Es más útil hacer bien veinte ejercicios, con sus variaciones y sin mirar la solución, que leer doscientos resueltos. La señal de que puedes pasar al siguiente tema es que resuelves un enunciado nuevo sin consultar nada.

WhatsApp