Nivel inicial12 min de lectura · Publicado el

Kata Roman Numerals en JavaScript con TDD paso a paso

Kata Roman Numerals en JavaScript: las letras romanas como monedas de una caja, de M a I, y el 14 pagado con X e IV: XIV. Romanos: la mayor que caberubentejera.com MCMDCDCXCLXLXIXVIVI14XIV= XIVresta
Cada letra es una moneda, de M (1000) a I (1), y las rosas, como CM o IV, son las restas. Para 14 se da siempre la mayor que cabe: X (10), y para los 4 que quedan, IV. Total: XIV.

Una kata es un ejercicio corto que se repite para practicar una técnica, como las escalas de un músico. La de los números romanos es de las más conocidas para empezar con TDD (desarrollo guiado por pruebas): el enunciado cabe en una línea y, aun así, el algoritmo no es evidente.

En este artículo se resuelve en JavaScript, test a test. Si es tu primera kata, en Qué es una kata o un koan tienes el contexto.

El enunciado

Según Coding Dojo, la kata tiene dos partes:

  1. Escribir una función que convierta números normales en romanos: 1 → I, 10 → X, 7 → VII.
  2. Escribir la función contraria: de romano a número.

No hace falta pasar de unos 3000. Los romanos usaban siete letras y no tenían cero:

Letra I V X L C D M
Valor 1 5 10 50 100 500 1000

Las letras se suman de mayor a menor (VI = 5 + 1). La excepción: una letra pequeña delante de una mayor resta (IV = 5 − 1). Con estas reglas, el número más alto que se puede escribir es el 3999, MMMCMXCIX.

Prepara el proyecto

Node 24 trae su propio ejecutor de tests, node:test, así que no necesitas instalar nada. Crea una carpeta con tres ficheros:

{
  "type": "module",
  "scripts": { "test": "node --test" }
}

Ese es el package.json: "type": "module" permite usar import y export. Los otros dos son roman.js (el código) y roman.test.js (los tests). node --test busca, entre otros, los ficheros que terminan en .test.js.

El ciclo: rojo, verde, refactor

Cada paso sigue el mismo ritmo de TDD:

  1. Rojo: escribe un test que falle.
  2. Verde: escribe el código mínimo para que pase, aunque te dé vergüenza.
  3. Refactor: limpia el código sin cambiar lo que hace, con los tests en verde.

Si quieres el ciclo con más detalle, está en El algoritmo de TDD.

Paso 1: el 1 es I

El primer test es el caso más sencillo:

// roman.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { toRoman } from './roman.js';

test('1 es I', () => {
  assert.equal(toRoman(1), 'I');
});

Con una función vacía, npm test falla: esperaba 'I' y ha recibido undefined. Rojo. El código mínimo para pasar es devolver la respuesta tal cual:

// roman.js
export function toRoman(number) {
  return 'I';
}

Parece una trampa, y lo es a propósito: el siguiente test te obligará a hacerlo mejor.

Paso 2: el 2 es II, y el 3 ya funciona

Añade el test del 2. Falla, porque seguimos devolviendo 'I'. Lo mínimo ahora es repetir la I tantas veces como diga el número:

export function toRoman(number) {
  return 'I'.repeat(number);
}

Después añade el test del 3 (III). Pasa sin tocar el código. Eso también es información: no todos los tests nuevos te hacen escribir código, y está bien dejarlos como red de seguridad.

Paso 3: aparece la V

El test del 5 (V) falla: devuelve IIIII. Lo mínimo es un caso especial:

export function toRoman(number) {
  if (number === 5) return 'V';
  return 'I'.repeat(number);
}

El 6 (VI) vuelve a fallar. Ahí se ve el patrón: si el número llega a 5, pones una V y conviertes lo que sobra.

export function toRoman(number) {
  if (number >= 5) return 'V' + toRoman(number - 5);
  return 'I'.repeat(number);
}

Paso 4: la resta del IV

El 4 devuelve IIII y debería ser IV. Con el patrón anterior, la solución es tratar IV como si fuera otra letra que vale 4:

export function toRoman(number) {
  if (number >= 5) return 'V' + toRoman(number - 5);
  if (number >= 4) return 'IV' + toRoman(number - 4);
  return 'I'.repeat(number);
}

Este es el truco de toda la kata: las restas (IV, IX, XL…) se tratan como símbolos propios, y así no hace falta ninguna regla especial para restar.

Paso 5: la X, la IX y el refactor

Los tests del 10 (X) y del 9 (IX) fallan. Siguiendo el mismo patrón, pasan con dos líneas más:

export function toRoman(number) {
  if (number >= 10) return 'X' + toRoman(number - 10);
  if (number >= 9) return 'IX' + toRoman(number - 9);
  if (number >= 5) return 'V' + toRoman(number - 5);
  if (number >= 4) return 'IV' + toRoman(number - 4);
  return 'I'.repeat(number);
}

Todo en verde, pero hay cuatro líneas casi iguales. Es el momento del refactor: lo que cambia entre ellas son solo el valor y el símbolo, así que se sacan a una tabla.

const SYMBOLS = [
  [10, 'X'],
  [9, 'IX'],
  [5, 'V'],
  [4, 'IV'],
  [1, 'I'],
];

export function toRoman(number) {
  let roman = '';
  let rest = number;
  for (const [value, symbol] of SYMBOLS) {
    while (rest >= value) {
      roman += symbol;
      rest -= value;
    }
  }
  return roman;
}

Funciona como dar el cambio en una tienda: usas siempre la moneda más grande que cabe en lo que queda y repites hasta llegar a cero. Para devolver 8 €, primero un billete de 5 y luego tres monedas de 1: VIII. El símil tiene un matiz: aquí existen «monedas» raras de 4 y de 9, que son las restas.

Las restas no son una regla: son monedas.

Los tests también tienen duplicación, así que se convierten en una tabla de casos:

const cases = [
  [1, 'I'],
  [2, 'II'],
  [3, 'III'],
  [4, 'IV'],
  [5, 'V'],
  [6, 'VI'],
  [9, 'IX'],
  [10, 'X'],
];

for (const [number, roman] of cases) {
  test(`${number} es ${roman}`, () => {
    assert.equal(toRoman(number), roman);
  });
}

Cada caso sigue siendo un test independiente: si falla uno, el mensaje te dice exactamente cuál.

Paso 6: hasta el 3999

Añade a la tabla los casos del 40 (XL), 50, 90, 100, 400, 500, 900 y 1000, uno a uno. Cada uno falla y se arregla con una fila más en SYMBOLS: ya no hace falta tocar la función. Con la tabla completa, el 2648 y el 3999 pasan sin hacer nada más:

const SYMBOLS = [
  [1000, 'M'],
  [900, 'CM'],
  [500, 'D'],
  [400, 'CD'],
  [100, 'C'],
  [90, 'XC'],
  [50, 'L'],
  [40, 'XL'],
  [10, 'X'],
  [9, 'IX'],
  [5, 'V'],
  [4, 'IV'],
  [1, 'I'],
];

El orden importa: el bucle recorre la tabla de mayor a menor. Si pusieras el 1 primero, todo saldría como una fila de I.

Paso 7: los números que no existen

¿Qué hace toRoman(0)? Devuelve una cadena vacía, y toRoman(4000) devuelve MMMM, que no es un romano válido. Mejor fallar con un error claro. Primero el test:

test('rechaza números que no tienen forma romana', () => {
  for (const number of [0, -1, 4000, 2.5]) {
    assert.throws(() => toRoman(number), RangeError);
  }
});

Y después la comprobación al principio de la función:

const MIN = 1;
const MAX = 3999;

export function toRoman(number) {
  if (!Number.isInteger(number) || number < MIN || number > MAX) {
    throw new RangeError(`Solo se convierten enteros del ${MIN} al ${MAX}; recibido: ${number}`);
  }
  // … el bucle de antes
}

Segunda parte: de romano a número

La segunda parte de la kata va al revés. La idea: lees el romano de izquierda a derecha y sumas el valor de cada letra, salvo cuando la siguiente es mayor; entonces la restas (en IV, la I resta).

const VALUES = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000 };

export function fromRoman(roman) {
  if (!/^[IVXLCDM]+$/.test(roman)) {
    throw new RangeError(`No es un número romano: ${roman}`);
  }
  let total = 0;
  for (let i = 0; i < roman.length; i++) {
    const current = VALUES[roman[i]];
    const next = VALUES[roman[i + 1]] ?? 0;
    total += current < next ? -current : current;
  }
  if (total > MAX || toRoman(total) !== roman) {
    throw new RangeError(`No es un número romano bien escrito: ${roman}`);
  }
  return total;
}

La última comprobación evita aceptar formas incorrectas como IIII o VX: si al volver a convertir el número no sale el mismo texto, el romano estaba mal escrito.

Teniendo las dos funciones, hay un test que vale por miles: convertir cada número del 1 al 3999 en romano y de vuelta, y comprobar que sale el mismo.

test('ida y vuelta: del 1 al 3999 recupera el mismo número', () => {
  for (let number = 1; number <= 3999; number++) {
    assert.equal(fromRoman(toRoman(number)), number);
  }
});

Responde a una de las preguntas que propone la kata: ¿cómo sabes que tus tests son correctos? Aquí, porque dos funciones escritas por separado tienen que estar de acuerdo en 3999 casos.

El código completo

// roman.js
const SYMBOLS = [
  [1000, 'M'],
  [900, 'CM'],
  [500, 'D'],
  [400, 'CD'],
  [100, 'C'],
  [90, 'XC'],
  [50, 'L'],
  [40, 'XL'],
  [10, 'X'],
  [9, 'IX'],
  [5, 'V'],
  [4, 'IV'],
  [1, 'I'],
];

const MIN = 1;
const MAX = 3999;

export function toRoman(number) {
  if (!Number.isInteger(number) || number < MIN || number > MAX) {
    throw new RangeError(`Solo se convierten enteros del ${MIN} al ${MAX}; recibido: ${number}`);
  }
  let roman = '';
  let rest = number;
  for (const [value, symbol] of SYMBOLS) {
    while (rest >= value) {
      roman += symbol;
      rest -= value;
    }
  }
  return roman;
}

const VALUES = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000 };

export function fromRoman(roman) {
  if (!/^[IVXLCDM]+$/.test(roman)) {
    throw new RangeError(`No es un número romano: ${roman}`);
  }
  let total = 0;
  for (let i = 0; i < roman.length; i++) {
    const current = VALUES[roman[i]];
    const next = VALUES[roman[i + 1]] ?? 0;
    total += current < next ? -current : current;
  }
  if (total > MAX || toRoman(total) !== roman) {
    throw new RangeError(`No es un número romano bien escrito: ${roman}`);
  }
  return total;
}
// roman.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { toRoman, fromRoman } from './roman.js';

const cases = [
  [1, 'I'],
  [2, 'II'],
  [3, 'III'],
  [4, 'IV'],
  [5, 'V'],
  [6, 'VI'],
  [9, 'IX'],
  [10, 'X'],
  [40, 'XL'],
  [50, 'L'],
  [90, 'XC'],
  [100, 'C'],
  [400, 'CD'],
  [500, 'D'],
  [900, 'CM'],
  [1000, 'M'],
  [2648, 'MMDCXLVIII'],
  [3999, 'MMMCMXCIX'],
];

for (const [number, roman] of cases) {
  test(`${number} es ${roman}`, () => {
    assert.equal(toRoman(number), roman);
  });

  test(`${roman} es ${number}`, () => {
    assert.equal(fromRoman(roman), number);
  });
}

test('rechaza números que no tienen forma romana', () => {
  for (const number of [0, -1, 4000, 2.5]) {
    assert.throws(() => toRoman(number), RangeError);
  }
});

test('rechaza romanos mal escritos', () => {
  for (const roman of ['', 'IIII', 'VX', 'ABC', 'iv', 'MMMM']) {
    assert.throws(() => fromRoman(roman), RangeError);
  }
});

test('ida y vuelta: del 1 al 3999 recupera el mismo número', () => {
  for (let number = 1; number <= 3999; number++) {
    assert.equal(fromRoman(toRoman(number)), number);
  }
});

Ejecuta npm test y verás los 39 tests en verde. Para que se repitan solos cada vez que guardas, usa node --test --watch (en Node 24 ese modo aún es experimental).

Con Jest

Si tu proyecto usa Jest, la tabla de casos se escribe con test.each:

import { toRoman } from './roman.js';

test.each([
  [1, 'I'],
  [4, 'IV'],
  [9, 'IX'],
  [2648, 'MMDCXLVIII'],
])('%i es %s', (number, roman) => {
  expect(toRoman(number)).toBe(roman);
});

Jest 30 todavía trata los módulos import/export como experimentales: necesita "jest": { "transform": {} } en el package.json y arrancarlo con node --experimental-vm-modules node_modules/jest/bin/jest.js.

Lo que cambió desde la versión de 2018

Esta kata se publicó en 2018 con un vídeo, que hoy es privado en YouTube, y el repositorio rubentejera/kataRomanNumbers, que sigue disponible.

El algoritmo es el mismo, la tabla de símbolos de mayor a menor. Lo que ha cambiado son las herramientas y algunos detalles:

2018

  • Jest 22 y Babel 6 para poder usar import
  • Un solo test con cinco comprobaciones
  • var y el parámetro modificado dentro del bucle
  • Sin control de 0, negativos o más de 3999

Hoy

  • node:test, incluido en Node, sin dependencias
  • Un test por caso: si falla, sabes cuál
  • const, let y una variable propia para el resto
  • Errores claros fuera del rango y la conversión inversa

Y si la haces con un asistente de IA

Desde el enfoque de IA Limpia, una kata es buen terreno para practicar cómo trabajar con un agente sin perder el control. Un aviso: esta kata está en miles de repositorios públicos, así que un asistente de IA puede saltar directamente a la tabla final. Eso se salta justo lo que viene a enseñar la kata.

Si quieres practicar TDD con un agente, prueba a escribir tú cada test y pedirle solo el código mínimo para ponerlo en verde, paso a paso. Tu trabajo es revisar que no se adelante: si añade la tabla completa cuando solo hay tres tests, ha escrito código que ningún test pide.

Siguiente paso

Repite la kata cambiando el orden de los tests: empieza por el 1000, por ejemplo, y mira si llegas al mismo diseño. Es otra de las preguntas que propone el enunciado. Si buscas más ejercicios, en Katas para pruebas tienes una selección ordenada por dificultad.

Fuentes

  • Enunciado y preguntas de la kata: Roman Numerals en Coding Dojo, leído en noviembre de 2026. La propia página atribuye la kata a Kent Beck en XP2001 con un «creo», así que no se da como dato firme.
  • node:test en la documentación de Node.js 24: estable desde Node 20; el modo --watch sigue marcado como experimental; patrones de búsqueda de ficheros de test.
  • Jest 30.5 y los módulos ECMAScript: soporte experimental, --experimental-vm-modules y transform: {}.
  • Código ejecutado el 7 de noviembre de 2026 con Node.js 24.21.0 en Linux: cada paso del artículo, en rojo y en verde, y la versión final con 39 tests en verde. La variante con test.each se ejecutó con Jest 30.5.2.
  • Código original de 2018: rubentejera/kataRomanNumbers (Jest 22.4 y Babel 6).
  • El vídeo de 2018 (hRIU7463Ifo) aparece como «Vídeo privado» en YouTube, comprobado el 7 de noviembre de 2026; por eso no se inserta.