Validar RUT en programación: JavaScript, PHP y Python

El algoritmo en resumen

Validar un RUT consiste en recalcular su dígito verificador a partir del cuerpo y compararlo con el que trae el número. Se usa el algoritmo módulo 11: se multiplican los dígitos del cuerpo, de derecha a izquierda, por la serie 2, 3, 4, 5, 6, 7 (repitiendo desde el 2 al llegar al 7); se suman los productos; se obtiene el resto de dividir por 11; y se resta a 11, con dos casos especiales: si da 11 → 0, si da 10 → K. Si el dígito calculado coincide con el ingresado, el RUT es válido. El detalle matemático está en la guía del dígito verificador.

Toda implementación, en cualquier lenguaje, sigue tres pasos: limpiar la entrada (quitar puntos, guion y espacios, y pasar la K a mayúscula), separar cuerpo y dígito, y calcular y comparar. Veamos cada lenguaje.

Validar RUT en JavaScript

function validarRut(rut) {
  const limpio = rut.replace(/[^0-9kK]/g, '').toUpperCase();
  if (limpio.length < 2) return false;
  const cuerpo = limpio.slice(0, -1);
  const dv = limpio.slice(-1);
  if (!/^[0-9]+$/.test(cuerpo)) return false;
  let suma = 0, mul = 2;
  for (let i = cuerpo.length - 1; i >= 0; i--) {
    suma += parseInt(cuerpo[i], 10) * mul;
    mul = mul === 7 ? 2 : mul + 1;
  }
  const res = 11 - (suma % 11);
  const dvCalc = res === 11 ? '0' : res === 10 ? 'K' : String(res);
  return dvCalc === dv;
}

// Ejemplos
validarRut('12.345.678-5'); // true
validarRut('12345678-9');   // false
validarRut('6-K');          // true

Validar RUT en PHP

function validarRut($rut) {
  $limpio = strtoupper(preg_replace('/[^0-9kK]/', '', $rut));
  if (strlen($limpio) < 2) return false;
  $cuerpo = substr($limpio, 0, -1);
  $dv = substr($limpio, -1);
  if (!ctype_digit($cuerpo)) return false;
  $suma = 0; $mul = 2;
  for ($i = strlen($cuerpo) - 1; $i >= 0; $i--) {
    $suma += intval($cuerpo[$i]) * $mul;
    $mul = $mul === 7 ? 2 : $mul + 1;
  }
  $res = 11 - ($suma % 11);
  $dvCalc = $res === 11 ? '0' : ($res === 10 ? 'K' : strval($res));
  return $dvCalc === $dv;
}

Validar RUT en Python

import re

def validar_rut(rut: str) -> bool:
    limpio = re.sub(r'[^0-9kK]', '', rut).upper()
    if len(limpio) < 2:
        return False
    cuerpo, dv = limpio[:-1], limpio[-1]
    if not cuerpo.isdigit():
        return False
    suma, mul = 0, 2
    for c in reversed(cuerpo):
        suma += int(c) * mul
        mul = 2 if mul == 7 else mul + 1
    res = 11 - (suma % 11)
    dv_calc = '0' if res == 11 else 'K' if res == 10 else str(res)
    return dv_calc == dv

Las tres funciones son equivalentes: misma lógica, distinta sintaxis. Nota que todas limpian primero y validan que el cuerpo sea solo dígitos antes de calcular. Ese detalle evita que entradas raras rompan la función.

Formatear el RUT

Validar es una mitad; presentar bien el RUT es la otra. Formatear consiste en agregar los puntos como separadores de miles y el guion antes del dígito verificador. En JavaScript:

function formatearRut(rut) {
  const limpio = rut.replace(/[^0-9kK]/g, '').toUpperCase();
  if (limpio.length < 2) return limpio;
  const cuerpo = limpio.slice(0, -1);
  const dv = limpio.slice(-1);
  const conPuntos = cuerpo.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
  return conPuntos + '-' + dv;
}

formatearRut('123456785'); // "12.345.678-5"

La expresión regular del medio inserta un punto cada tres dígitos contando desde la derecha. El resto es unir el cuerpo con puntos y el dígito verificador con un guion. Los formatos válidos y cuándo usar cada uno están en la guía de formato del RUT.

Validar el formato con una regex

Una expresión regular no reemplaza al algoritmo, pero sirve como primer filtro rápido para descartar entradas con formato imposible antes de calcular. Por ejemplo, para aceptar el RUT con o sin puntos y con guion:

const formatoValido = /^\d{1,3}(\.?\d{3})*-[0-9kK]$/;

formatoValido.test('12.345.678-5'); // true (formato ok)
formatoValido.test('12345678-5');   // true
formatoValido.test('hola');         // false

Ojo: que el formato sea válido no significa que el RUT lo sea. La regex acepta «12.345.678-9» porque el formato es correcto, aunque su dígito verificador esté mal. Por eso el orden correcto es: primero la regex para el formato, y solo si pasa, el algoritmo módulo 11 para la validez real.

En React, Laravel y Django

En un proyecto real, la validación no vive suelta sino dentro de un framework. La idea es siempre la misma: reutilizar la función pura de validación dentro de la validación del formulario o del modelo.

React (validación en un formulario)

function CampoRut() {
  const [rut, setRut] = useState('');
  const [valido, setValido] = useState(null);

  const onBlur = () => setValido(validarRut(rut));

  return (
    <>
      <input value={rut} onChange={e => setRut(e.target.value)} onBlur={onBlur} />
      {valido === false && <span>RUT no válido</span>}
    </>
  );
}

Laravel (regla de validación)

// En un Form Request o con Validator::extend
Validator::extend('rut', function ($attribute, $value) {
    return validarRut($value); // tu función PHP de arriba
});

// Uso:  'rut' => 'required|rut'

Django (validator de modelo)

from django.core.exceptions import ValidationError

def validar_rut_field(value):
    if not validar_rut(value):   # tu función Python de arriba
        raise ValidationError('RUT no válido')

# En el modelo:  rut = models.CharField(validators=[validar_rut_field])

En los tres casos, la lógica del módulo 11 es la misma función pura de más arriba; el framework solo la envuelve para conectarla con sus formularios o modelos.

Escribir pruebas para no equivocarse

La validación de RUT es un candidato ideal para pruebas automatizadas: la entrada es simple y los casos límite son conocidos. Un buen conjunto de tests cubre al menos: un RUT normal válido, uno inválido, uno terminado en K, uno terminado en 0, y una entrada basura. En JavaScript con un runner cualquiera:

test('valida RUT correctos', () => {
  expect(validarRut('12.345.678-5')).toBe(true);
  expect(validarRut('6-K')).toBe(true);
  expect(validarRut('15.834.900-0')).toBe(true);
});

test('rechaza RUT incorrectos', () => {
  expect(validarRut('12.345.678-9')).toBe(false);
  expect(validarRut('hola')).toBe(false);
  expect(validarRut('')).toBe(false);
});

Para generar RUT válidos de prueba sin usar datos reales, puedes apoyarte en nuestro generador de RUT, que produce números que cumplen el módulo 11 pero no corresponden a ninguna persona.

Errores comunes al implementar la validación

Aunque el algoritmo es corto, hay tropiezos que se repiten en muchas implementaciones. Conocerlos ahorra horas de depuración:

• No limpiar la entrada: si validas el RUT tal como llega, con puntos y guion, el cálculo falla. Siempre hay que limpiar primero.
• Olvidar la K: tratar el dígito verificador solo como número deja fuera todos los RUT terminados en K. Hay que contemplar el valor 10 → K y el 11 → 0.
• Comparar sin normalizar mayúsculas: «k» y «K» deben tratarse igual; conviene pasar todo a mayúscula al limpiar.
• Recorrer el número al revés mal: la serie 2-7 se aplica de derecha a izquierda. Si multiplicas de izquierda a derecha, el resultado es incorrecto.
• Confiar solo en la validación del navegador: un usuario puede desactivar JavaScript o manipular el formulario. La validación del servidor es la que realmente protege.

La mayoría de estos errores se detectan de inmediato con los tests de la sección anterior. Por eso vale la pena escribirlos aunque la función parezca trivial: cubren justo los casos límite donde suele fallar.

Buenas prácticas

• Limpia siempre la entrada antes de validar: quita puntos, guion y espacios, y pasa la K a mayúscula.
• Guarda el RUT normalizado (sin formato) en la base de datos; aplica el formato solo al mostrarlo.
• Valida en el servidor, no solo en el navegador. La validación en el front mejora la experiencia, pero un usuario puede saltársela; la del backend es la que protege tus datos.
• No confundas válido con real. El algoritmo comprueba el formato, no la existencia de la persona.
• Usa RUT generados para pruebas, nunca RUT de personas reales.

Y si solo necesitas comprobar un RUT suelto sin escribir código, el validador de RUT aplica exactamente este algoritmo al instante.