Saltar al contenido

Cifrado César en JavaScript

La función completa cabe en una pantalla y funciona en cualquier navegador. Cópiala, o escribe tu propio texto y mira qué hace el código con cada letra.

caesar.js
function caesar(text, shift) {    let result = "";    for (const char of text) {        if (/[a-z]/i.test(char)) {            const base = char <= "Z" ? 65 : 97;            const code = char.charCodeAt(0) - base;            const index = ((code + shift) % 26 + 26) % 26;            result += String.fromCharCode(index + base);        } else {            result += char;        }    }    return result;} console.log(caesar("¡Hola, mundo!", 3));// ¡Krod, pxqgr!
anuncio

Ejecutar el código

Lo más rápido es el navegador: pulsa F12, abre la pestaña Consola, pega el código y pulsa Intro. Para ejecutarlo fuera del navegador, guárdalo como caesar.js y usa Node.js:

Terminal
node caesar.js

Si el cifrado en sí es nuevo para ti, la guía lo explica sin código.

Cómo funciona el código

El bucle for...of recorre el texto carácter a carácter, y la expresión regular reconoce las letras de la A a la Z, mayúsculas o minúsculas. charCodeAt(0) da el número de una letra: 72 para la H y 104 para la h. Al restar 65 o 97 obtienes su posición en el alfabeto, de 0 a 25.

Después de sumar el desplazamiento, el módulo da la vuelta al alfabeto: con un desplazamiento de 3, la Z cae en la C. String.fromCharCode devuelve el número a su forma de letra.

Todo lo demás pasa por la rama else y se queda igual. También la ñ y las vocales con tilde, que la expresión regular no incluye.

Descifrar en JavaScript

No hace falta una segunda función. Descifrar es desplazar en sentido contrario, así que basta con pasar un número negativo:

JavaScript
console.log(caesar("¡Krod, pxqgr!", -3));// ¡Hola, mundo!

De ahí el + 26 adicional de la fórmula. En JavaScript, % conserva el signo del número de la izquierda: -3 % 26 da -3, y String.fromCharCode devolvería un carácter equivocado. Si sumas 26 y vuelves a aplicar el módulo sale 23, y la A vuelve a la X. En la versión en Python, el propio % ya lo resuelve.

El cifrado César en una página web

Esta es una página completa: guárdala como archivo .html y ábrela en el navegador. El resultado cambia mientras escribes, y todo ocurre en tu ordenador.

HTML
<textarea id="text"></textarea><input id="shift" type="number" value="3"><output id="result"></output> <script>    // Pega aquí la función caesar     const text = document.querySelector("#text");    const shift = document.querySelector("#shift");    const result = document.querySelector("#result");     function update() {        result.textContent = caesar(text.value, Number(shift.value));    }     text.addEventListener("input", update);    shift.addEventListener("input", update);</script>

Hay dos detalles importantes. El valor de un campo siempre es una cadena, por lo que el desplazamiento pasa por Number(). Y el resultado se escribe con textContent, porque innerHTML ejecutaría cualquier HTML escrito en el campo.

Una herramienta de línea de comandos en Node.js

Sustituye las dos últimas líneas de caesar.js por este código para recibir el desplazamiento y el texto por línea de comandos:

JavaScript
const [shift, ...words] = process.argv.slice(2);console.log(caesar(words.join(" "), Number(shift))); // node caesar.js 3 Hola// Krod

Romper el cifrado por fuerza bruta

Con 26 letras solo hay 25 desplazamientos posibles, y un bucle corto basta para leer el mensaje sin la clave. Busca en la salida la línea que tenga sentido:

JavaScript
function crack(text) {    for (let shift = 1; shift < 26; shift++) {        console.log(shift, caesar(text, -shift));    }} crack("¡Krod, pxqgr!");// 1 ¡Jqnc, owpfq!// 2 ¡Ipmb, nvoep!// 3 ¡Hola, mundo!// ...

El artículo sobre el ataque de fuerza bruta entra en más detalle, y el descifrador en línea hace lo mismo en tu navegador.

Una versión más corta con replace

replace con una expresión regular global llama a tu función para cada letra y deja lo demás como está, así que ya no necesitas el bucle ni el else.

JavaScript
const caesar = (text, shift) =>    text.replace(/[a-z]/gi, (char) => {        const base = char <= "Z" ? 65 : 97;        const code = char.charCodeAt(0) - base;        return String.fromCharCode(((code + shift) % 26 + 26) % 26 + base);    });

Cifrado César con la ñ

Para desplazar también la ñ, guarda el alfabeto en una cadena y busca cada carácter con indexOf(). Son las mismas 27 letras que usa nuestra herramienta:

JavaScript
const ALPHABET = "abcdefghijklmnñopqrstuvwxyz"; function caesarAlphabet(text, shift) {    const size = ALPHABET.length;    let result = "";    for (const char of text) {        const position = ALPHABET.indexOf(char.toLowerCase());        if (position === -1) {            result += char;        } else {            const next = ALPHABET[((position + shift) % size + size) % size];            result += char === char.toLowerCase() ? next : next.toUpperCase();        }    }    return result;} console.log(caesarAlphabet("El niño", 3));// Hñ plqr

Ahora la vuelta depende de la longitud del alfabeto, así que no tienes que escribir el 27 en ningún sitio. Puedes comparar el resultado en la herramienta de cifrado César con el alfabeto español.

Cifrar un archivo de texto

En Node.js, leer y escribir un archivo lleva una línea cada cosa. Este código usa import, así que llama al archivo caesar.mjs o añade "type": "module" en package.json.

JavaScript
import { readFileSync, writeFileSync } from "node:fs"; const text = readFileSync("message.txt", "utf8");writeFileSync("encrypted.txt", caesar(text, 3));

Una librería ya hecha

Si necesitas el cifrado en un proyecto y no quieres mantenerlo, nuestra librería caesar-cipher-js no tiene dependencias e incluye tipos de TypeScript. Se instala con npm install caesar-cipher-js:

JavaScript
import { encrypt, decrypt } from "caesar-cipher-js"; console.log(encrypt("¡Hola, mundo!", 3));// ¡Krod, pxqgr!console.log(decrypt("¡Krod, pxqgr!", 3));// ¡Hola, mundo!

Probar el código

Node.js trae un módulo de aserciones, y unas pocas líneas detectan casi todos los errores: pasar de la Z, conservar mayúsculas y minúsculas, respetar los signos y recuperar el texto original. Si todo va bien, imprime OK.

JavaScript
import assert from "node:assert/strict"; assert.equal(caesar("ABC", 3), "DEF");assert.equal(caesar("xyz", 3), "abc");assert.equal(caesar("Hello, World!", 5), "Mjqqt, Btwqi!");assert.equal(caesar(caesar("JavaScript", 7), -7), "JavaScript");assert.equal(caesar("A", -27), "Z");assert.equal(caesar("é", 3), "é");console.log("OK");

Errores frecuentes

El más común es dejar el desplazamiento como cadena: 7 + "3" da "73", y el programa devuelve sin avisar una letra equivocada. Le sigue % con un desplazamiento negativo, como vimos antes. Y no uses innerHTML para mostrar el resultado, porque el texto viene del usuario.

Preguntas frecuentes

¿Funciona en todos los navegadores?

Sí, todos los navegadores actuales admiten la sintaxis usada aquí. Hemos ejecutado el código de esta página en Node.js 25 y probado la página web en un navegador.

¿Sirve para proteger datos reales?

No. El bucle de arriba lo rompe en segundos. Úsalo para aprender y para pasatiempos. Para datos reales, los navegadores y Node.js ofrecen cifrado moderno mediante la Web Crypto API.

¿Cómo compruebo que mi resultado es correcto?

Introduce el mismo texto y desplazamiento en nuestra herramienta de cifrado César y compara. También puedes llamar a la API REST gratuita desde tus pruebas.

Sigue aprendiendo