DEV Community: ToolRapido

Formatear y validar JSON en JavaScript: JSON.stringify(), errores comunes y casos límite

ToolRapido — Fri, 01 May 2026 20:14:31 +0000

JSON es el formato de intercambio de datos más usado en desarrollo web. Pero JSON.stringify() y JSON.parse() tienen matices que sorprenden incluso a desarrolladores con años de experiencia.

Formateo con indentación

const data = { name: 'ToolRapido', tools: ['NIF', 'QR', 'UUID'], active: true };

// Compacto (por defecto)
JSON.stringify(data);
// '{"name":"ToolRapido","tools":["NIF","QR","UUID"],"active":true}'

// Indentado con 2 espacios
JSON.stringify(data, null, 2);
// {
//   "name": "ToolRapido",
//   "tools": ["NIF", "QR", "UUID"],
//   "active": true
// }

// Indentado con tabuladores
JSON.stringify(data, null, '\t');

Validar JSON sin try/catch en cada sitio

function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch {
    return false;
  }
}

// Versión que devuelve el error
function parseJSON(str) {
  try {
    return { ok: true, data: JSON.parse(str) };
  } catch (err) {
    return { ok: false, error: err.message };
  }
}

const result = parseJSON('{"broken": json}');
result.ok;    // false
result.error; // 'Unexpected token j in JSON at position 12'

Tipos que JSON.stringify() ignora o transforma

Esto sorprende a muchos:

JSON.stringify({
  fn: () => {},           // undefined (se omite)
  sym: Symbol('x'),       // undefined (se omite)
  undef: undefined,       // undefined (se omite)
  nan: NaN,               // null
  inf: Infinity,          // null
  date: new Date(),       // string ISO
  regexp: /regex/,        // {}  ← TRAMPA
  map: new Map([['a', 1]]), // {} ← TRAMPA
  set: new Set([1, 2]),   // [] ← TRAMPA
});

Para serializar Map y Set:

function replacer(key, value) {
  if (value instanceof Map) {
    return { __type: 'Map', entries: [...value.entries()] };
  }
  if (value instanceof Set) {
    return { __type: 'Set', values: [...value] };
  }
  return value;
}

function reviver(key, value) {
  if (value?.__type === 'Map') return new Map(value.entries);
  if (value?.__type === 'Set') return new Set(value.values);
  return value;
}

const data = { myMap: new Map([['a', 1]]) };
const json = JSON.stringify(data, replacer, 2);
const back = JSON.parse(json, reviver);
back.myMap instanceof Map; // true

El replacer para filtrar campos

// Solo incluir campos específicos
JSON.stringify(user, ['name', 'email'], 2);

// Excluir campos sensibles
function omitSensitive(key, value) {
  const sensitive = ['password', 'token', 'secret'];
  if (sensitive.includes(key)) return undefined;
  return value;
}
JSON.stringify(user, omitSensitive, 2);

Clonar objetos con JSON

// Forma rápida (limitada — pierde funciones, fechas, etc.)
const clone = JSON.parse(JSON.stringify(obj));

// Forma moderna y correcta
const clone = structuredClone(obj); // soporta Date, Map, Set, etc.

structuredClone() está disponible en Node 17+ y todos los navegadores modernos.

Diferencias entre JSON y JSON5

JSON5 es un superconjunto de JSON que permite comentarios, comas finales y más:

{
  // Comentarios
  name: 'sin comillas en keys',
  trailing: 'coma',
  hex: 0xFF,
  multiline: "primera línea \
segunda línea",
}

JSON5 es útil para archivos de configuración pero no para APIs (usar siempre JSON estándar en APIs).

Herramienta online

Si necesitas formatear o validar un JSON rápidamente durante el desarrollo, puedes usar este formateador de JSON gratuito que funciona en el navegador con resaltado de errores.

Conclusión

Usa JSON.stringify(data, null, 2) para formateo legible
Map, Set, RegExp y funciones no se serializan como esperas — planifica cómo manejarlos
structuredClone() es mejor que JSON.parse(JSON.stringify()) para clonar objetos
Centraliza el parseo en una función que devuelva { ok, data, error } para manejar errores limpiamente

Cómo calcular la cuota de autónomos en España en 2025: el sistema de cotización por ingresos reales

ToolRapido — Fri, 01 May 2026 20:14:09 +0000

Si eres desarrollador freelance en España, desde 2023 la cuota de autónomos ya no es fija: depende de tus ingresos reales. Aquí te explico cómo funciona el sistema y cómo calcularlo.

El nuevo sistema (desde 2023)

Antes había una base de cotización única (la mínima era 294€/mes). Ahora hay 15 tramos según los rendimientos netos anuales.

Rendimiento neto = Ingresos - Gastos deducibles - 7% de gastos de difícil justificación

Los 15 tramos para 2025

Tramo	Rendimiento neto (€/año)	Cuota mínima (€/mes)	Cuota máxima (€/mes)
1	< 670	200	260
2	670 – 900	220	281
3	900 – 1.166,70	260	294
4	1.166,70 – 1.300	294	320
5	1.300 – 1.500	294	350
6	1.500 – 1.700	294	370
7	1.700 – 1.850	310	390
8	1.850 – 2.030	315	420
9	2.030 – 2.330	320	445
10	2.330 – 2.760	330	480
11	2.760 – 3.190	350	520
12	3.190 – 3.620	370	570
13	3.620 – 4.050	390	620
14	4.050 – 6.000	420	720
15	> 6.000	461	1.267

La fórmula de cálculo

const TRAMOS = [
  { min: 0,       max: 670,    cuotaMin: 200, cuotaMax: 260 },
  { min: 670,     max: 900,    cuotaMin: 220, cuotaMax: 281 },
  { min: 900,     max: 1167,   cuotaMin: 260, cuotaMax: 294 },
  { min: 1167,    max: 1300,   cuotaMin: 294, cuotaMax: 320 },
  { min: 1300,    max: 1500,   cuotaMin: 294, cuotaMax: 350 },
  { min: 1500,    max: 1700,   cuotaMin: 294, cuotaMax: 370 },
  { min: 1700,    max: 1850,   cuotaMin: 310, cuotaMax: 390 },
  { min: 1850,    max: 2030,   cuotaMin: 315, cuotaMax: 420 },
  { min: 2030,    max: 2330,   cuotaMin: 320, cuotaMax: 445 },
  { min: 2330,    max: 2760,   cuotaMin: 330, cuotaMax: 480 },
  { min: 2760,    max: 3190,   cuotaMin: 350, cuotaMax: 520 },
  { min: 3190,    max: 3620,   cuotaMin: 370, cuotaMax: 570 },
  { min: 3620,    max: 4050,   cuotaMin: 390, cuotaMax: 620 },
  { min: 4050,    max: 6000,   cuotaMin: 420, cuotaMax: 720 },
  { min: 6000,    max: Infinity, cuotaMin: 461, cuotaMax: 1267 },
];

function calcularCuota(ingresosMensuales, gastosMensuales) {
  const ingresosAnuales = ingresosMensuales * 12;
  const gastosAnuales = gastosMensuales * 12;

  // Gastos de difícil justificación: 7% de los ingresos netos
  const rendimientoBruto = ingresosAnuales - gastosAnuales;
  const deduccionDificilJustificacion = rendimientoBruto * 0.07;
  const rendimientoNeto = rendimientoBruto - deduccionDificilJustificacion;
  const rendimientoMensual = rendimientoNeto / 12;

  const tramo = TRAMOS.find(
    (t) => rendimientoMensual >= t.min && rendimientoMensual < t.max
  ) || TRAMOS[TRAMOS.length - 1];

  return {
    rendimientoNeto: Math.round(rendimientoNeto),
    rendimientoMensual: Math.round(rendimientoMensual),
    cuotaMinima: tramo.cuotaMin,
    cuotaMaxima: tramo.cuotaMax,
    tramo: TRAMOS.indexOf(tramo) + 1,
  };
}

// Ejemplo: 3.000€/mes brutos, 500€/mes de gastos
calcularCuota(3000, 500);
// {
//   rendimientoNeto: 29_670,
//   rendimientoMensual: 2_472,
//   cuotaMinima: 330,
//   cuotaMaxima: 480,
//   tramo: 10
// }

Cosas importantes a tener en cuenta

Regularización anual: Durante el año cotizas según tu previsión. En enero del año siguiente la Seguridad Social calcula tus ingresos reales con los datos de Hacienda y te cobra o devuelve la diferencia.

Tarifa plana: Los nuevos autónomos pagan 80€/mes durante el primer año, independientemente de sus ingresos.

Gastos deducibles habituales para devs:

Material informático
Suscripciones de software (GitHub, Figma, cloud...)
Conexión a internet (parte proporcional si trabajas desde casa)
Formación
Asesoría

Herramienta de cálculo

Si quieres calcular tu cuota de autónomos sin implementarlo, puedes usar esta calculadora de cuota de autónomos gratuita que aplica los tramos de 2025.

Conclusión

El nuevo sistema es más justo para freelancers con ingresos variables, pero requiere llevar un control más estricto de los ingresos y gastos para hacer una previsión correcta. El mayor riesgo es infraestimar los ingresos y que la regularización de enero sea una sorpresa desagradable.

Cómo convertir imágenes en el navegador con Canvas API sin subir nada a un servidor

ToolRapido — Fri, 01 May 2026 20:13:25 +0000

Convertir imágenes normalmente implica un servidor, pero con Canvas API puedes hacerlo íntegramente en el navegador. El usuario carga la imagen, se procesa en su dispositivo y descarga el resultado. Cero privacidad comprometida, cero coste de servidor.

El flujo completo

Usuario selecciona un archivo con <input type="file">
Lo leemos con FileReader o URL.createObjectURL()
Lo dibujamos en un <canvas>
Exportamos el canvas al formato deseado con toBlob() o toDataURL()
Disparamos la descarga

Implementación

async function convertImage(file, targetFormat, quality = 0.92) {
  // 1. Cargar la imagen
  const img = await loadImage(file);

  // 2. Crear canvas con las dimensiones originales
  const canvas = document.createElement('canvas');
  canvas.width = img.naturalWidth;
  canvas.height = img.naturalHeight;

  // 3. Dibujar
  const ctx = canvas.getContext('2d');

  // Fondo blanco para conversiones a JPG (JPG no soporta transparencia)
  if (targetFormat === 'image/jpeg') {
    ctx.fillStyle = '#ffffff';
    ctx.fillRect(0, 0, canvas.width, canvas.height);
  }

  ctx.drawImage(img, 0, 0);

  // 4. Exportar
  return new Promise((resolve) => {
    canvas.toBlob(resolve, targetFormat, quality);
  });
}

function loadImage(file) {
  return new Promise((resolve, reject) => {
    const img = new Image();
    img.onload = () => resolve(img);
    img.onerror = reject;
    img.src = URL.createObjectURL(file);
  });
}

Disparar la descarga

function downloadBlob(blob, filename) {
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = filename;
  a.click();
  URL.revokeObjectURL(url); // liberar memoria
}

// Uso completo
async function handleConvert(file, format) {
  const mimeTypes = {
    jpg: 'image/jpeg',
    png: 'image/png',
    webp: 'image/webp',
  };

  const blob = await convertImage(file, mimeTypes[format]);
  const ext = format;
  const name = file.name.replace(/\.[^.]+$/, '') + '.' + ext;
  downloadBlob(blob, name);
}

Soporte de formatos

// Detectar si el navegador soporta WebP
async function supportsWebP() {
  const canvas = document.createElement('canvas');
  canvas.width = 1;
  canvas.height = 1;
  return canvas.toDataURL('image/webp').startsWith('data:image/webp');
}

// Detectar soporte de AVIF
async function supportsAVIF() {
  return new Promise((resolve) => {
    const img = new Image();
    img.onload = () => resolve(true);
    img.onerror = () => resolve(false);
    img.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQ==';
  });
}

Redimensionar antes de convertir

function resizeAndConvert(file, maxWidth, maxHeight, format, quality = 0.9) {
  return new Promise(async (resolve) => {
    const img = await loadImage(file);

    let { naturalWidth: w, naturalHeight: h } = img;

    // Mantener proporción
    if (w > maxWidth) { h = Math.round(h * maxWidth / w); w = maxWidth; }
    if (h > maxHeight) { w = Math.round(w * maxHeight / h); h = maxHeight; }

    const canvas = document.createElement('canvas');
    canvas.width = w;
    canvas.height = h;
    canvas.getContext('2d').drawImage(img, 0, 0, w, h);
    canvas.toBlob(resolve, format, quality);
  });
}

Limitaciones

SVG: Canvas puede rasterizar SVG, pero pierde la escalabilidad vectorial
Archivos grandes: el canvas tiene límites de tamaño (varía por navegador, ~4096×4096 en móvil)
AVIF: soporte limitado en toBlob(), mejor comprobarlo antes
GIF animado: Canvas solo exporta el primer frame; para GIFs animados necesitas una librería

Herramienta lista para usar

Si necesitas convertir imágenes sin implementarlo, puedes usar este conversor de imágenes gratuito que soporta PNG, JPG, WebP, GIF y SVG con conversión completamente en el navegador.

Conclusión

Canvas API es todo lo que necesitas para convertir imágenes en el navegador. El resultado es:

Sin coste de servidor
Sin límites de uso
Sin comprometer la privacidad del usuario
Compatible con todos los navegadores modernos

Expresiones regulares en JavaScript: guía práctica con ejemplos reales

ToolRapido — Fri, 01 May 2026 20:12:52 +0000

Las expresiones regulares tienen fama de ilegibles, pero dominando una docena de patrones resuelves el 90% de los casos reales. Aquí van los más útiles con explicaciones.

Los métodos principales

// test() — devuelve boolean
/^\d+$/.test('123');        // true
/^\d+$/.test('12a');        // false

// match() — devuelve array o null
'foo123bar'.match(/\d+/);   // ['123']
'foo123bar'.match(/\d+/g);  // ['123'] (con /g devuelve todos)

// replace() — reemplazar
'hola mundo'.replace(/\s+/g, '-');  // 'hola-mundo'

// split() — dividir
'a,b,,c'.split(/,+/);       // ['a', 'b', 'c']

Patrones de validación más usados

Email

const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
emailRegex.test('user@example.com');  // true
emailRegex.test('not-an-email');      // false

Teléfono español

// Móvil: empieza por 6 o 7, 9 dígitos
const phoneRegex = /^[67]\d{8}$/;
phoneRegex.test('612345678');  // true
phoneRegex.test('912345678');  // false (fijo)

URL

const urlRegex = /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
urlRegex.test('https://toolrapido.com');  // true

Solo números

/^\d+$/.test('123');    // true
/^\d+$/.test('12.3');   // false
/^[\d.]+$/.test('12.3'); // true (con decimales)

Código postal español

/^(?:0[1-9]|[1-4]\d|5[0-2])\d{3}$/.test('28001');  // true (Madrid)
/^(?:0[1-9]|[1-4]\d|5[0-2])\d{3}$/.test('99999');  // false

Grupos de captura

// Extraer partes de una fecha DD/MM/YYYY
const match = '25/04/2026'.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
if (match) {
  const [, day, month, year] = match;
  console.log(day, month, year); // '25' '04' '2026'
}

Grupos nombrados (ES2018)

const match = '25/04/2026'.match(/^(?<day>\d{2})\/(?<month>\d{2})\/(?<year>\d{4})$/);
match?.groups; // { day: '25', month: '04', year: '2026' }

Lookahead y lookbehind

// Lookahead positivo: palabra seguida de un número (sin capturar el número)
'precio100'.match(/\w+(?=\d)/);  // ['precio']

// Lookbehind positivo: número precedido de euro
'€42'.match(/(?<=€)\d+/);  // ['42']

// Lookahead negativo: palabras que NO van seguidas de un punto
'hola mundo.'.match(/\b\w+\b(?!\.)/g);  // ['hola']

Transformaciones de texto útiles

// camelCase a kebab-case
'myVariableName'.replace(/([A-Z])/g, '-$1').toLowerCase();
// 'my-variable-name'

// Eliminar acentos
'café España'.normalize('NFD').replace(/[̀-ͯ]/g, '');
// 'cafe Espana'

// Slug para URLs
function slugify(str) {
  return str
    .toLowerCase()
    .normalize('NFD')
    .replace(/[̀-ͯ]/g, '')
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-|-$/g, '');
}
slugify('Herramienta de Validación NIF'); // 'herramienta-de-validacion-nif'

// Truncar en límite de palabra
function truncate(str, max) {
  if (str.length <= max) return str;
  return str.slice(0, max).replace(/\s\S*$/, '') + '…';
}

Flags importantes

/patrón/i   // case-insensitive
/patrón/g   // global (todas las coincidencias)
/patrón/m   // multiline (^ y $ por línea)
/patrón/s   // dotAll (. incluye saltos de línea)
/patrón/u   // unicode (soporte completo de emojis y unicode)

Herramienta para probar regex

Si quieres probar expresiones regulares en tiempo real con texto de ejemplo y ver todas las coincidencias resaltadas, puedes usar este tester de regex gratuito.

Conclusión

Las regex son una herramienta poderosa, pero no siempre la mejor. Para parsing de HTML usa un DOM parser, para JSON usa JSON.parse(). Las regex brillan en validación de formatos, transformaciones de texto y extracción de patrones simples.

Generando UUIDs en JavaScript: crypto.randomUUID() y todo lo que necesitas saber

ToolRapido — Fri, 01 May 2026 20:10:19 +0000

UUID (Universally Unique Identifier) es el estándar para generar identificadores únicos sin coordinación entre sistemas. Aquí te explico todo lo que necesitas saber para usarlos correctamente en JavaScript.

La forma moderna: crypto.randomUUID()

Desde 2022, todos los navegadores modernos y Node.js 14.17+ tienen crypto.randomUUID() nativo:

crypto.randomUUID();
// 'f47ac10b-58cc-4372-a567-0e02b2c3d479'

Es criptográficamente seguro, rápido y no requiere ninguna librería. Úsalo siempre que puedas.

Implementación manual de UUID v4

Si necesitas soporte para entornos sin crypto.randomUUID() o quieres entender cómo funciona:

function uuidv4() {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);

  // Versión 4: bits 12-15 del byte 6 = 0100
  bytes[6] = (bytes[6] & 0x0f) | 0x40;

  // Variante RFC 4122: bits 6-7 del byte 8 = 10
  bytes[8] = (bytes[8] & 0x3f) | 0x80;

  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0'));

  return [
    hex.slice(0, 4).join(''),
    hex.slice(4, 6).join(''),
    hex.slice(6, 8).join(''),
    hex.slice(8, 10).join(''),
    hex.slice(10).join(''),
  ].join('-');
}

¿Cuándo hay colisiones?

UUID v4 tiene 122 bits de aleatoriedad (los otros 6 son fijos por la especificación). La probabilidad de colisión es:

Con 1 millón de UUIDs: probabilidad de colisión ≈ 0.000000000001%
Para tener 50% de probabilidad de colisión necesitarías generar 2.71 × 10^18 UUIDs

En la práctica, las colisiones son imposibles. No necesitas verificar unicidad en base de datos salvo en sistemas con millones de registros por segundo durante años.

UUID vs ULID vs NanoID

// UUID v4 — estándar universal, desordenado
'f47ac10b-58cc-4372-a567-0e02b2c3d479'  // 36 chars

// ULID — ordenable por tiempo (útil como PK en bases de datos)
'01ARZ3NDEKTSV4RRFFQ69G5FAV'           // 26 chars

// NanoID — más corto, URL-safe
'V1StGXR8_Z5jdHi6B-myT'               // 21 chars (configurable)

Para claves primarias en bases de datos, ULID es mejor que UUID porque es ordenable y más eficiente en índices B-tree. Para identificadores públicos en URLs, NanoID es más compacto.

UUID como clave primaria en PostgreSQL

CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  email TEXT NOT NULL
);

En PostgreSQL 13+ gen_random_uuid() es nativo. En versiones anteriores necesitas la extensión pgcrypto.

Validar un UUID

function isValidUUID(str) {
  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str);
}

isValidUUID('f47ac10b-58cc-4372-a567-0e02b2c3d479'); // true
isValidUUID('not-a-uuid');                            // false

Herramienta online

Si necesitas generar UUIDs rápidamente para pruebas o desarrollo, puedes usar este generador de UUID gratuito que funciona en el navegador.

Conclusión

Usa crypto.randomUUID() siempre que sea posible — es nativo, seguro y rápido
Las colisiones son prácticamente imposibles, no las gestiones en código
Para PKs en bases de datos considera ULID si el orden importa
UUID v4 es el estándar universal: úsalo cuando necesites interoperabilidad

Base64 en JavaScript: codificación, decodificación y casos de uso reales

ToolRapido — Fri, 01 May 2026 20:09:01 +0000

Base64 aparece en todas partes del desarrollo web: imágenes incrustadas en CSS, tokens JWT, APIs REST, cabeceras de autenticación. Aquí tienes todo lo que necesitas saber.

Las funciones nativas: btoa() y atob()

// Codificar
btoa('Hola mundo');         // 'SG9sYSBtdW5kbw=='
btoa('toolrapido.com');     // 'dG9vbHJhcGlkby5jb20='

// Decodificar
atob('SG9sYSBtdW5kbw==');  // 'Hola mundo'

El problema: btoa() solo acepta caracteres ASCII. Con caracteres Unicode (tildes, ñ, emojis) lanza un error.

El problema con Unicode

btoa('Ñoño');  // ❌ InvalidCharacterError

La solución correcta en 2024 usa TextEncoder:

function toBase64(str) {
  const bytes = new TextEncoder().encode(str);
  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join('');
  return btoa(binary);
}

function fromBase64(str) {
  const binary = atob(str);
  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
  return new TextDecoder().decode(bytes);
}

toBase64('Ñoño');           // 'w5Bvw5Bv' — funciona
fromBase64('w5Bvw5Bv');    // 'Ñoño'

Base64 URL-safe

El Base64 estándar usa +, / y = que necesitan escaparse en URLs. La variante URL-safe los reemplaza:

function toBase64URL(str) {
  return toBase64(str)
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=/g, '');
}

function fromBase64URL(str) {
  const padded = str + '='.repeat((4 - str.length % 4) % 4);
  return fromBase64(padded.replace(/-/g, '+').replace(/_/g, '/'));
}

Esta variante es la que usan los tokens JWT.

Data URLs: incrustar archivos en HTML/CSS

async function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result); // "data:image/png;base64,..."
    reader.onerror = reject;
    reader.readAsDataURL(file);
  });
}

// Usar en una imagen
const img = document.createElement('img');
img.src = await fileToBase64(file);

Decodificar un JWT manualmente

function decodeJWT(token) {
  const [header, payload] = token.split('.');
  return {
    header: JSON.parse(fromBase64URL(header)),
    payload: JSON.parse(fromBase64URL(payload)),
  };
}

const token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjMifQ.xxx';
decodeJWT(token).payload; // { sub: '123' }

Ojo: esto solo decodifica, no verifica la firma. Nunca confíes en el payload sin verificar el JWT en el servidor.

Cuándo NO usar Base64

Base64 aumenta el tamaño un 33%. No uses Base64 para:

Transferir archivos grandes (usa multipart/form-data)
Almacenar contraseñas (usa bcrypt/argon2)
Cifrar datos (Base64 no es cifrado, solo codificación)

Herramienta online

Si necesitas codificar o decodificar Base64 rápidamente sin escribir código, puedes usar este codificador Base64 gratuito que funciona en el navegador.

Resumen

Caso	Solución
ASCII simple	`btoa()` / `atob()`
Unicode (tildes, ñ)	`TextEncoder` + `btoa()`
URLs y JWT	Base64 URL-safe
Imágenes en HTML	Data URL con `FileReader`

Cómo crear una ruleta giratoria con Canvas API en JavaScript

ToolRapido — Sun, 26 Apr 2026 17:02:43 +0000

Una ruleta giratoria parece compleja pero se puede construir con Canvas 2D puro en menos de 200 líneas. En este tutorial explico cada parte del algoritmo.

La estructura básica

<canvas id="wheel" width="400" height="400"></canvas>
<button id="spin">Girar</button>

const canvas = document.getElementById('wheel');
const ctx = canvas.getContext('2d');
const cx = canvas.width / 2;
const cy = canvas.height / 2;
const radius = cx - 10;

Dibujar los segmentos

Cada segmento es un arco de círculo. Con N elementos, cada segmento ocupa 2π/N radianes.

function drawWheel(items, colors, currentAngle) {
  ctx.clearRect(0, 0, canvas.width, canvas.height);

  const n = items.length;
  const segAngle = (2 * Math.PI) / n;

  ctx.save();
  ctx.translate(cx, cy);
  ctx.rotate(currentAngle);

  for (let i = 0; i < n; i++) {
    const start = -Math.PI / 2 + i * segAngle;
    const end = start + segAngle;

    // Segmento
    ctx.beginPath();
    ctx.moveTo(0, 0);
    ctx.arc(0, 0, radius, start, end);
    ctx.closePath();
    ctx.fillStyle = colors[i];
    ctx.fill();
    ctx.strokeStyle = 'rgba(255,255,255,0.7)';
    ctx.lineWidth = 2;
    ctx.stroke();

    // Texto
    ctx.save();
    ctx.rotate(start + segAngle / 2);
    ctx.textAlign = 'right';
    ctx.fillStyle = '#fff';
    ctx.font = 'bold 14px sans-serif';
    ctx.fillText(items[i], radius - 12, 0);
    ctx.restore();
  }

  ctx.restore();
}

El algoritmo de giro con easing

La física del giro tiene tres fases: aceleración, velocidad máxima y desaceleración. La función easeOut simula la fricción.

const SPIN_DURATION = 5500; // ms
const MIN_SPINS = 6;

let animStart = null;
let animStartAngle = 0;
let targetAngle = 0;
let currentAngle = 0;

function easeOut(t) {
  return 1 - Math.pow(1 - t, 4);
}

function animate(timestamp) {
  if (!animStart) animStart = timestamp;

  const elapsed = timestamp - animStart;
  const progress = Math.min(elapsed / SPIN_DURATION, 1);

  currentAngle = animStartAngle + (targetAngle - animStartAngle) * easeOut(progress);
  drawWheel(items, colors, currentAngle);

  if (progress < 1) {
    requestAnimationFrame(animate);
  } else {
    onSpinEnd();
  }
}

Calcular el ganador

El puntero está fijo arriba (en -π/2). Para saber qué segmento apunta arriba al terminar el giro:

function getWinnerIndex(angle, n) {
  const segAngle = (2 * Math.PI) / n;
  const normalized = (((-angle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI));
  return Math.floor(normalized / segAngle) % n;
}

Calcular el ángulo objetivo

Para garantizar que la ruleta se detiene en un ganador concreto (o aleatorio):

function startSpin(items) {
  const n = items.length;
  const segAngle = (2 * Math.PI) / n;
  const winnerIndex = Math.floor(Math.random() * n);

  // Ángulo donde debe quedar el centro del segmento ganador apuntando arriba
  const f = 0.2 + Math.random() * 0.6; // posición aleatoria dentro del segmento
  const targetMod = 2 * Math.PI - (winnerIndex + f) * segAngle;
  const currentMod = ((currentAngle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
  const step = (targetMod - currentMod + 2 * Math.PI) % (2 * Math.PI);
  const extraSpins = (MIN_SPINS + Math.floor(Math.random() * 5)) * 2 * Math.PI;

  animStartAngle = currentAngle;
  targetAngle = currentAngle + extraSpins + step;
  animStart = null;

  requestAnimationFrame(animate);
}

El sonido de tick

Usando la Web Audio API puedes añadir el sonido de tick cuando la ruleta pasa por cada segmento, sin archivos de audio externos:

function playTick() {
  const ac = new AudioContext();
  const osc = ac.createOscillator();
  const gain = ac.createGain();

  osc.connect(gain);
  gain.connect(ac.destination);
  osc.frequency.value = 680;
  osc.type = 'triangle';
  gain.gain.setValueAtTime(0.05, ac.currentTime);
  gain.gain.exponentialRampToValueAtTime(0.001, ac.currentTime + 0.07);
  osc.start(ac.currentTime);
  osc.stop(ac.currentTime + 0.07);
}

Ver el resultado final

Si quieres ver una implementación completa y funcional con presets, modo eliminar ganador e historial, puedes probar esta ruleta aleatoria online, construida exactamente con las técnicas de este artículo.

Conclusión

Canvas 2D + requestAnimationFrame son suficientes para una animación fluida
El truco está en calcular el targetAngle correctamente para garantizar el ganador
easeOut con exponente 4 da una desaceleración natural muy convincente
La Web Audio API permite sonido sin archivos externos

Cómo generar contraseñas seguras en JavaScript con la Web Crypto API

ToolRapido — Sun, 26 Apr 2026 17:01:46 +0000

Generar contraseñas seguras no es tan trivial como parece. Math.random() no es criptográficamente seguro. La solución correcta está en la Web Crypto API, disponible en todos los navegadores modernos.

El problema con Math.random()

// MAL — no usar para contraseñas
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
const password = Array.from({ length: 16 }, () =>
  chars[Math.floor(Math.random() * chars.length)]
).join('');

Math.random() usa un generador pseudoaleatorio predecible. No sirve para seguridad.

La solución correcta: crypto.getRandomValues()

function generatePassword(length = 16, options = {}) {
  const {
    uppercase = true,
    lowercase = true,
    numbers = true,
    symbols = false,
  } = options;

  let charset = '';
  if (uppercase) charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  if (lowercase) charset += 'abcdefghijklmnopqrstuvwxyz';
  if (numbers)   charset += '0123456789';
  if (symbols)   charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';

  if (!charset) throw new Error('Al menos un tipo de caracter requerido');

  const array = new Uint32Array(length);
  crypto.getRandomValues(array);

  return Array.from(array, (n) => charset[n % charset.length]).join('');
}

Por qué funciona

crypto.getRandomValues() usa la fuente de entropía del sistema operativo (equivalente a /dev/urandom en Linux). Los valores son impredecibles incluso conociendo los anteriores.

El truco del módulo (n % charset.length) introduce un pequeño sesgo si el tamaño del charset no divide exactamente a 2^32. Para longitudes de charset típicas (62-95 caracteres) el sesgo es despreciable, pero si quieres eliminarlo del todo:

function unbiasedRandom(max, array, index) {
  const limit = Math.floor(0xFFFFFFFF / max) * max;
  if (array[index] > limit) return null; // descartar
  return array[index] % max;
}

Calcular la entropía

function entropy(length, charsetSize) {
  return length * Math.log2(charsetSize);
}

entropy(16, 62);  // 95.3 bits — muy seguro
entropy(12, 62);  // 71.5 bits — aceptable
entropy(8, 62);   // 47.6 bits — débil

A partir de 80 bits de entropía una contraseña es prácticamente infuerectable con hardware actual.

Comprobar la fortaleza

function strength(password) {
  let charset = 0;
  if (/[a-z]/.test(password)) charset += 26;
  if (/[A-Z]/.test(password)) charset += 26;
  if (/[0-9]/.test(password)) charset += 10;
  if (/[^a-zA-Z0-9]/.test(password)) charset += 32;

  const bits = password.length * Math.log2(charset);
  if (bits < 50) return 'débil';
  if (bits < 80) return 'media';
  return 'fuerte';
}

Herramienta lista para usar

Si prefieres no implementarlo y solo necesitas generar contraseñas seguras rápidamente, puedes usar este generador de contraseñas gratuito que funciona íntegramente en el navegador, sin enviar nada a ningún servidor.

Conclusión

Usa siempre crypto.getRandomValues(), nunca Math.random()
16 caracteres con mayúsculas, minúsculas y números dan más de 95 bits de entropía
La Web Crypto API está disponible en todos los navegadores modernos sin instalar nada

Cómo validar NIF, CIF y NIE en JavaScript: el algoritmo explicado

ToolRapido — Sun, 26 Apr 2026 16:46:54 +0000

Si desarrollas software para el mercado español, tarde o temprano necesitas validar documentos fiscales: NIF, CIF o NIE. Aquí explico cómo funciona el algoritmo oficial y cómo implementarlo.

El algoritmo del NIF (y DNI)

El NIF de persona física son 8 dígitos + 1 letra de control. La letra se calcula así:

Toma los 8 dígitos
Divide entre 23
El resto (0-22) selecciona una letra de esta cadena: TRWAGMYFPDXBNJZSQVHLCKE

function validateNIF(nif) {
  const letters = 'TRWAGMYFPDXBNJZSQVHLCKE';
  const cleaned = nif.toUpperCase().trim();
  const num = parseInt(cleaned.slice(0, 8), 10);
  const letter = cleaned.slice(-1);
  return letters[num % 23] === letter;
}

El algoritmo del NIE

El NIE empieza por X, Y o Z. Se sustituye por 0, 1 o 2 respectivamente, y se aplica el mismo algoritmo que el NIF.

function validateNIE(nie) {
  const letters = 'TRWAGMYFPDXBNJZSQVHLCKE';
  const cleaned = nie.toUpperCase().trim();
  const first = { X: '0', Y: '1', Z: '2' }[cleaned[0]];
  if (!first) return false;
  const num = parseInt(first + cleaned.slice(1, 8), 10);
  return letters[num % 23] === cleaned.slice(-1);
}

El algoritmo del CIF (empresas)

El CIF es más complejo: letra de tipo + 7 dígitos + carácter de control.

function validateCIF(cif) {
  const cleaned = cif.toUpperCase().trim();
  const validLetters = 'ABCDEFGHJKLMNPQRSUVW';
  if (!validLetters.includes(cleaned[0])) return false;

  const digits = cleaned.slice(1, 8);
  let oddSum = 0, evenSum = 0;

  for (let i = 0; i < 7; i++) {
    const d = parseInt(digits[i], 10);
    if (i % 2 === 0) {
      const doubled = d * 2;
      oddSum += doubled > 9 ? doubled - 9 : doubled;
    } else {
      evenSum += d;
    }
  }

  const total = oddSum + evenSum;
  const control = (10 - (total % 10)) % 10;
  const lastChar = cleaned.slice(-1);
  const controlLetters = 'JABCDEFGHI';

  return lastChar === String(control) || lastChar === controlLetters[control];
}

Casos de uso habituales

Tests automatizados: generar datos válidos para Jest, Vitest, Cypress
Seeding de bases de datos: poblar entornos de desarrollo sin usar datos reales
Validación de formularios: verificar que el campo NIF funciona en producción

Si no quieres implementarlo tú mismo, hay herramientas online que validan y generan NIF, CIF y NIE aleatorios válidos para pruebas, como este validador y generador gratuito.

Conclusión

El algoritmo es sencillo pero tiene sus matices, especialmente en el CIF. Implementarlo bien y testearlo te ahorra sorpresas en producción con datos reales.