Validar RUT en JavaScript: código completo y explicado

1function calcularDigitoVerificador(rutNumero) {
2  // Convertir a string y asegurar que tenga 8 dígitos
3  let rut = String(rutNumero).padStart(8, '0');
4  
5  // Variables para el cálculo
6  let suma = 0;
7  let multiplicador = 2;
8  
9  // Recorrer de derecha a izquierda
10  for (let i = rut.length - 1; i >= 0; i--) {
11    suma += parseInt(rut[i]) * multiplicador;
12    multiplicador = multiplicador === 7 ? 2 : multiplicador + 1;
13  }
14  
15  // Calcular dígito verificador
16  const resto = suma % 11;
17  const dv = 11 - resto;
18  
19  // Casos especiales
20  if (dv === 11) return '0';
21  if (dv === 10) return 'K';
22  return String(dv);
23}
24
25// Ejemplos de uso
26console.log(calcularDigitoVerificador(12345678)); // 5
27console.log(calcularDigitoVerificador(11111111)); // 1
28console.log(calcularDigitoVerificador(22222222)); // 2

1class RutValidator {
2  /**
3   * Limpia el RUT removiendo puntos, guiones y espacios
4   * @param {string} rut - RUT en cualquier formato
5   * @returns {string} RUT limpio
6   */
7  static limpiar(rut) {
8    return String(rut).replace(/[.-s]/g, '').toUpperCase();
9  }
10
11  /**
12   * Formatea el RUT con puntos y guión
13   * @param {string} rut - RUT sin formato
14   * @returns {string} RUT formateado (ej: 12.345.678-9)
15   */
16  static formatear(rut) {
17    const rutLimpio = this.limpiar(rut);
18    if (rutLimpio.length < 2) return rutLimpio;
19    
20    const cuerpo = rutLimpio.slice(0, -1);
21    const dv = rutLimpio.slice(-1);
22    
23    // Agregar puntos cada 3 dígitos de derecha a izquierda
24    let cuerpoFormateado = '';
25    for (let i = cuerpo.length - 1, j = 0; i >= 0; i--, j++) {
26      if (j > 0 && j % 3 === 0) {
27        cuerpoFormateado = '.' + cuerpoFormateado;
28      }
29      cuerpoFormateado = cuerpo[i] + cuerpoFormateado;
30    }
31    
32    return `${cuerpoFormateado}-${dv}`;
33  }
34
35  /**
36   * Calcula el dígito verificador
37   * @param {string|number} rutNumero - Número del RUT sin DV
38   * @returns {string} Dígito verificador
39   */
40  static calcularDV(rutNumero) {
41    const rut = String(rutNumero).padStart(8, '0');
42    let suma = 0;
43    let multiplicador = 2;
44    
45    for (let i = rut.length - 1; i >= 0; i--) {
46      suma += parseInt(rut[i]) * multiplicador;
47      multiplicador = multiplicador === 7 ? 2 : multiplicador + 1;
48    }
49    
50    const dv = 11 - (suma % 11);
51    if (dv === 11) return '0';
52    if (dv === 10) return 'K';
53    return String(dv);
54  }
55
56  /**
57   * Valida un RUT completo
58   * @param {string} rut - RUT completo con o sin formato
59   * @returns {boolean} true si es válido
60   */
61  static validar(rut) {
62    const rutLimpio = this.limpiar(rut);
63    
64    // Validar largo mínimo
65    if (rutLimpio.length < 2) return false;
66    
67    // Separar número y dígito verificador
68    const numero = rutLimpio.slice(0, -1);
69    const dvIngresado = rutLimpio.slice(-1);
70    
71    // Validar que sea un número
72    if (!/^d+$/.test(numero)) return false;
73    
74    // Calcular DV esperado y comparar
75    const dvCalculado = this.calcularDV(numero);
76    return dvIngresado === dvCalculado;
77  }
78}
79
80// Ejemplos de uso
81console.log(RutValidator.validar('12.345.678-5')); // true
82console.log(RutValidator.validar('12345678-5'));   // true
83console.log(RutValidator.validar('123456785'));    // true
84console.log(RutValidator.validar('12.345.678-9')); // false

1const rutUtils = {
2  // Limpiar RUT
3  clean: (rut) => String(rut).replace(/[.-s]/g, '').toUpperCase(),
4  
5  // Calcular dígito verificador
6  calculateDV: (rutNumber) => {
7    const digits = String(rutNumber).padStart(8, '0').split('').reverse();
8    const sum = digits.reduce((acc, digit, index) => {
9      const factor = ((index % 6) + 2);
10      return acc + (parseInt(digit) * factor);
11    }, 0);
12    
13    const dv = 11 - (sum % 11);
14    return dv === 11 ? '0' : dv === 10 ? 'K' : String(dv);
15  },
16  
17  // Validar RUT completo
18  validate: (rut) => {
19    const cleaned = rutUtils.clean(rut);
20    if (cleaned.length < 2) return false;
21    
22    const number = cleaned.slice(0, -1);
23    const dv = cleaned.slice(-1);
24    
25    return /^d+$/.test(number) && dv === rutUtils.calculateDV(number);
26  },
27  
28  // Formatear RUT
29  format: (rut) => {
30    const cleaned = rutUtils.clean(rut);
31    if (cleaned.length < 2) return cleaned;
32    
33    const number = cleaned.slice(0, -1);
34    const dv = cleaned.slice(-1);
35    
36    // Formatear con regex
37    const formatted = number.replace(/B(?=(d{3})+(?!d))/g, '.');
38    return `${formatted}-${dv}`;
39  }
40};
41
42// Uso con destructuring
43const { validate, format, calculateDV } = rutUtils;
44
45console.log(validate('12345678-5'));  // true
46console.log(format('123456785'));     // 12.345.678-5
47console.log(calculateDV(12345678));   // 5

1<!DOCTYPE html>
2<html lang="es">
3<head>
4    <meta charset="UTF-8">
5    <title>Validador de RUT</title>
6    <style>
7        .form-group {
8            margin: 20px 0;
9        }
10        
11        .form-control {
12            padding: 10px;
13            font-size: 16px;
14            border: 2px solid #ddd;
15            border-radius: 4px;
16            width: 300px;
17        }
18        
19        .form-control.is-valid {
20            border-color: #28a745;
21        }
22        
23        .form-control.is-invalid {
24            border-color: #dc3545;
25        }
26        
27        .feedback {
28            margin-top: 5px;
29            font-size: 14px;
30        }
31        
32        .valid-feedback {
33            color: #28a745;
34        }
35        
36        .invalid-feedback {
37            color: #dc3545;
38        }
39    </style>
40</head>
41<body>
42    <div class="form-group">
43        <label for="rut">Ingrese su RUT:</label>
44        <input 
45            type="text" 
46            id="rut" 
47            class="form-control" 
48            placeholder="12.345.678-9"
49            maxlength="12"
50        >
51        <div class="feedback"></div>
52    </div>
53    
54    <div class="form-group">
55        <label for="rut-auto">RUT con formato automático:</label>
56        <input 
57            type="text" 
58            id="rut-auto" 
59            class="form-control" 
60            placeholder="Ingrese RUT sin formato"
61        >
62        <div class="feedback"></div>
63    </div>
64
65    <script>
66        // Clase RutValidator (incluir el código anterior aquí)
67        
68        // Validación en tiempo real
69        document.getElementById('rut').addEventListener('input', function(e) {
70            const rut = e.target.value;
71            const feedback = e.target.nextElementSibling;
72            
73            if (rut.length === 0) {
74                e.target.classList.remove('is-valid', 'is-invalid');
75                feedback.textContent = '';
76                return;
77            }
78            
79            if (RutValidator.validar(rut)) {
80                e.target.classList.remove('is-invalid');
81                e.target.classList.add('is-valid');
82                feedback.className = 'feedback valid-feedback';
83                feedback.textContent = '✓ RUT válido';
84            } else {
85                e.target.classList.remove('is-valid');
86                e.target.classList.add('is-invalid');
87                feedback.className = 'feedback invalid-feedback';
88                feedback.textContent = '✗ RUT inválido';
89            }
90        });
91        
92        // Formato automático mientras escribe
93        document.getElementById('rut-auto').addEventListener('input', function(e) {
94            const valor = e.target.value;
95            const limpio = RutValidator.limpiar(valor);
96            
97            // Solo números y K
98            if (!/^[dkK]*$/.test(limpio)) {
99                e.target.value = e.target.value.slice(0, -1);
100                return;
101            }
102            
103            // Formatear automáticamente
104            if (limpio.length > 1) {
105                e.target.value = RutValidator.formatear(limpio);
106            }
107            
108            // Validar
109            const feedback = e.target.nextElementSibling;
110            if (limpio.length >= 8) {
111                if (RutValidator.validar(limpio)) {
112                    e.target.classList.remove('is-invalid');
113                    e.target.classList.add('is-valid');
114                    feedback.className = 'feedback valid-feedback';
115                    feedback.textContent = '✓ RUT válido';
116                } else {
117                    e.target.classList.remove('is-valid');
118                    e.target.classList.add('is-invalid');
119                    feedback.className = 'feedback invalid-feedback';
120                    feedback.textContent = '✗ RUT inválido';
121                }
122            } else {
123                e.target.classList.remove('is-valid', 'is-invalid');
124                feedback.textContent = '';
125            }
126        });
127    </script>
128</body>
129</html>

1// rut-validator.js
2module.exports = {
3  /**
4   * Valida un RUT chileno
5   * @param {string} rut - RUT a validar
6   * @returns {object} Resultado de la validación
7   */
8  validate: function(rut) {
9    try {
10      const cleaned = this.clean(rut);
11      
12      if (!cleaned || cleaned.length < 2) {
13        return {
14          isValid: false,
15          error: 'RUT muy corto'
16        };
17      }
18      
19      const number = cleaned.slice(0, -1);
20      const dv = cleaned.slice(-1);
21      
22      if (!/^d+$/.test(number)) {
23        return {
24          isValid: false,
25          error: 'RUT contiene caracteres inválidos'
26        };
27      }
28      
29      const calculatedDv = this.calculateDv(number);
30      const isValid = dv === calculatedDv;
31      
32      return {
33        isValid,
34        formatted: isValid ? this.format(cleaned) : null,
35        error: isValid ? null : 'Dígito verificador incorrecto'
36      };
37    } catch (error) {
38      return {
39        isValid: false,
40        error: error.message
41      };
42    }
43  },
44  
45  clean: function(rut) {
46    return String(rut).replace(/[.-s]/g, '').toUpperCase();
47  },
48  
49  calculateDv: function(rutNumber) {
50    const rut = String(rutNumber).padStart(8, '0');
51    let sum = 0;
52    let multiplier = 2;
53    
54    for (let i = rut.length - 1; i >= 0; i--) {
55      sum += parseInt(rut[i]) * multiplier;
56      multiplier = multiplier === 7 ? 2 : multiplier + 1;
57    }
58    
59    const dv = 11 - (sum % 11);
60    if (dv === 11) return '0';
61    if (dv === 10) return 'K';
62    return String(dv);
63  },
64  
65  format: function(rut) {
66    const cleaned = this.clean(rut);
67    if (cleaned.length < 2) return cleaned;
68    
69    const number = cleaned.slice(0, -1);
70    const dv = cleaned.slice(-1);
71    
72    let formatted = '';
73    for (let i = number.length - 1, j = 0; i >= 0; i--, j++) {
74      if (j > 0 && j % 3 === 0) {
75        formatted = '.' + formatted;
76      }
77      formatted = number[i] + formatted;
78    }
79    
80    return formatted + '-' + dv;
81  }
82};

1// rut-validator.mjs
2export class ChileanRutValidator {
3  static #factors = [2, 3, 4, 5, 6, 7];
4  
5  static clean(rut) {
6    return String(rut).replace(/[.-s]/g, '').toUpperCase();
7  }
8  
9  static calculateCheckDigit(rutNumber) {
10    const digits = String(rutNumber)
11      .padStart(8, '0')
12      .split('')
13      .reverse()
14      .map(Number);
15    
16    const sum = digits.reduce((acc, digit, index) => {
17      const factor = this.#factors[index % 6];
18      return acc + (digit * factor);
19    }, 0);
20    
21    const checkDigit = 11 - (sum % 11);
22    
23    switch (checkDigit) {
24      case 11: return '0';
25      case 10: return 'K';
26      default: return String(checkDigit);
27    }
28  }
29  
30  static validate(rut) {
31    const cleaned = this.clean(rut);
32    
33    if (cleaned.length < 2) {
34      throw new Error('RUT demasiado corto');
35    }
36    
37    const [number, checkDigit] = [
38      cleaned.slice(0, -1),
39      cleaned.slice(-1)
40    ];
41    
42    if (!/^d+$/.test(number)) {
43      throw new Error('RUT contiene caracteres no numéricos');
44    }
45    
46    return checkDigit === this.calculateCheckDigit(number);
47  }
48  
49  static format(rut) {
50    const cleaned = this.clean(rut);
51    if (cleaned.length < 2) return cleaned;
52    
53    const [number, checkDigit] = [
54      cleaned.slice(0, -1),
55      cleaned.slice(-1)
56    ];
57    
58    const formatted = number
59      .split('')
60      .reverse()
61      .reduce((acc, digit, index) => {
62        if (index > 0 && index % 3 === 0) {
63          acc = '.' + acc;
64        }
65        return digit + acc;
66      }, '');
67    
68    return `${formatted}-${checkDigit}`;
69  }
70}
71
72// Uso
73import { ChileanRutValidator } from './rut-validator.mjs';
74
75console.log(ChileanRutValidator.validate('12345678-5')); // true
76console.log(ChileanRutValidator.format('123456785'));    // 12.345.678-5

1// useRutValidator.js
2import { useState, useCallback } from 'react';
3
4const useRutValidator = () => {
5  const [rut, setRut] = useState('');
6  const [isValid, setIsValid] = useState(null);
7  const [formatted, setFormatted] = useState('');
8  
9  const clean = useCallback((value) => {
10    return String(value).replace(/[.-s]/g, '').toUpperCase();
11  }, []);
12  
13  const calculateDv = useCallback((rutNumber) => {
14    const rut = String(rutNumber).padStart(8, '0');
15    let sum = 0;
16    let multiplier = 2;
17    
18    for (let i = rut.length - 1; i >= 0; i--) {
19      sum += parseInt(rut[i]) * multiplier;
20      multiplier = multiplier === 7 ? 2 : multiplier + 1;
21    }
22    
23    const dv = 11 - (sum % 11);
24    if (dv === 11) return '0';
25    if (dv === 10) return 'K';
26    return String(dv);
27  }, []);
28  
29  const format = useCallback((value) => {
30    const cleaned = clean(value);
31    if (cleaned.length < 2) return cleaned;
32    
33    const number = cleaned.slice(0, -1);
34    const dv = cleaned.slice(-1);
35    
36    const formatted = number.replace(/B(?=(d{3})+(?!d))/g, '.');
37    return `${formatted}-${dv}`;
38  }, [clean]);
39  
40  const validate = useCallback((value) => {
41    const cleaned = clean(value);
42    
43    if (cleaned.length < 2) return false;
44    
45    const number = cleaned.slice(0, -1);
46    const dv = cleaned.slice(-1);
47    
48    if (!/^d+$/.test(number)) return false;
49    
50    return dv === calculateDv(number);
51  }, [clean, calculateDv]);
52  
53  const handleChange = useCallback((value) => {
54    setRut(value);
55    
56    const cleaned = clean(value);
57    if (cleaned.length >= 8) {
58      const valid = validate(value);
59      setIsValid(valid);
60      setFormatted(valid ? format(value) : '');
61    } else {
62      setIsValid(null);
63      setFormatted('');
64    }
65  }, [clean, validate, format]);
66  
67  return {
68    rut,
69    isValid,
70    formatted,
71    handleChange,
72    validate,
73    format,
74    clean
75  };
76};
77
78// Componente React de ejemplo
79const RutInput = () => {
80  const { rut, isValid, formatted, handleChange } = useRutValidator();
81  
82  return (
83    <div>
84      <input
85        type="text"
86        value={rut}
87        onChange={(e) => handleChange(e.target.value)}
88        placeholder="Ingrese RUT"
89        className={isValid === null ? '' : isValid ? 'valid' : 'invalid'}
90      />
91      {isValid !== null && (
92        <p>{isValid ? `✓ RUT válido: ${formatted}` : '✗ RUT inválido'}</p>
93      )}
94    </div>
95  );
96};

1// useRutValidator.js
2import { ref, computed } from 'vue';
3
4export function useRutValidator() {
5  const rut = ref('');
6  
7  const clean = (value) => {
8    return String(value).replace(/[.-s]/g, '').toUpperCase();
9  };
10  
11  const calculateDv = (rutNumber) => {
12    const rutStr = String(rutNumber).padStart(8, '0');
13    let sum = 0;
14    let multiplier = 2;
15    
16    for (let i = rutStr.length - 1; i >= 0; i--) {
17      sum += parseInt(rutStr[i]) * multiplier;
18      multiplier = multiplier === 7 ? 2 : multiplier + 1;
19    }
20    
21    const dv = 11 - (sum % 11);
22    if (dv === 11) return '0';
23    if (dv === 10) return 'K';
24    return String(dv);
25  };
26  
27  const isValid = computed(() => {
28    const cleaned = clean(rut.value);
29    if (cleaned.length < 8) return null;
30    
31    const number = cleaned.slice(0, -1);
32    const dv = cleaned.slice(-1);
33    
34    if (!/^d+$/.test(number)) return false;
35    
36    return dv === calculateDv(number);
37  });
38  
39  const formatted = computed(() => {
40    if (!isValid.value) return '';
41    
42    const cleaned = clean(rut.value);
43    const number = cleaned.slice(0, -1);
44    const dv = cleaned.slice(-1);
45    
46    const formattedNumber = number.replace(/B(?=(d{3})+(?!d))/g, '.');
47    return `${formattedNumber}-${dv}`;
48  });
49  
50  return {
51    rut,
52    isValid,
53    formatted,
54    clean,
55    calculateDv
56  };
57}

1// rut-validator.test.js
2const RutValidator = require('./rut-validator');
3
4describe('RutValidator', () => {
5  describe('clean', () => {
6    test('removes dots, dashes and spaces', () => {
7      expect(RutValidator.clean('12.345.678-9')).toBe('123456789');
8      expect(RutValidator.clean('12 345 678-9')).toBe('123456789');
9      expect(RutValidator.clean('12345678-k')).toBe('12345678K');
10    });
11  });
12  
13  describe('calculateDv', () => {
14    test('calculates correct check digit', () => {
15      expect(RutValidator.calculateDv(12345678)).toBe('5');
16      expect(RutValidator.calculateDv(11111111)).toBe('1');
17      expect(RutValidator.calculateDv(22222222)).toBe('2');
18    });
19    
20    test('returns 0 when result is 11', () => {
21      expect(RutValidator.calculateDv(15834660)).toBe('0');
22    });
23    
24    test('returns K when result is 10', () => {
25      expect(RutValidator.calculateDv(15834661)).toBe('K');
26    });
27  });
28  
29  describe('validate', () => {
30    test('validates correct RUTs', () => {
31      expect(RutValidator.validate('12.345.678-5')).toBe(true);
32      expect(RutValidator.validate('11111111-1')).toBe(true);
33      expect(RutValidator.validate('5.126.663-3')).toBe(true);
34    });
35    
36    test('rejects incorrect RUTs', () => {
37      expect(RutValidator.validate('12.345.678-9')).toBe(false);
38      expect(RutValidator.validate('11111111-2')).toBe(false);
39    });
40    
41    test('handles edge cases', () => {
42      expect(RutValidator.validate('')).toBe(false);
43      expect(RutValidator.validate('1')).toBe(false);
44      expect(RutValidator.validate('abc')).toBe(false);
45    });
46  });
47  
48  describe('format', () => {
49    test('formats RUT correctly', () => {
50      expect(RutValidator.format('123456785')).toBe('12.345.678-5');
51      expect(RutValidator.format('11111111')).toBe('1.111.111-1');
52      expect(RutValidator.format('51266633')).toBe('5.126.663-3');
53    });
54  });
55});

1class OptimizedRutValidator {
2  static #cache = new Map();
3  static #maxCacheSize = 1000;
4  
5  static validate(rut) {
6    const cleaned = this.clean(rut);
7    
8    // Verificar cache
9    if (this.#cache.has(cleaned)) {
10      return this.#cache.get(cleaned);
11    }
12    
13    // Validar
14    const result = this.#performValidation(cleaned);
15    
16    // Guardar en cache con límite
17    if (this.#cache.size >= this.#maxCacheSize) {
18      const firstKey = this.#cache.keys().next().value;
19      this.#cache.delete(firstKey);
20    }
21    this.#cache.set(cleaned, result);
22    
23    return result;
24  }
25  
26  static #performValidation(cleaned) {
27    if (cleaned.length < 2) return false;
28    
29    const number = cleaned.slice(0, -1);
30    const dv = cleaned.slice(-1);
31    
32    if (!/^d+$/.test(number)) return false;
33    
34    // Optimización: usar lookup table para factores
35    const factors = [2, 3, 4, 5, 6, 7];
36    let sum = 0;
37    
38    for (let i = number.length - 1, j = 0; i >= 0; i--, j++) {
39      sum += parseInt(number[i]) * factors[j % 6];
40    }
41    
42    const calculatedDv = 11 - (sum % 11);
43    const expectedDv = calculatedDv === 11 ? '0' : 
44                      calculatedDv === 10 ? 'K' : 
45                      String(calculatedDv);
46    
47    return dv === expectedDv;
48  }
49  
50  static clean(rut) {
51    return String(rut).replace(/[.-s]/g, '').toUpperCase();
52  }
53  
54  static clearCache() {
55    this.#cache.clear();
56  }
57}