Valida RUT chileno con JavaScript

valida_rut.js

var Fn = {
	// Valida el rut con su cadena completa "XXXXXXXX-X"
	validaRut : function (rutCompleto) {
		if (!/^[0-9]+[-|‐]{1}[0-9kK]{1}$/.test( rutCompleto ))
			return false;
		var tmp 	= rutCompleto.split('-');
		var digv	= tmp[1]; 
		var rut 	= tmp[0];
		if ( digv == 'K' ) digv = 'k' ;
		return (Fn.dv(rut) == digv );
	},
	dv : function(T){
		var M=0,S=1;
		for(;T;T=Math.floor(T/10))
			S=(S+T%10*(9-M++%6))%11;
		return S?S-1:'k';
	}
}

// Uso de la función
alert( Fn.validaRut('11111111-1') ? 'Valido' : 'inválido');

Se adicionó en la validación de la forma de la expresión regular el caracter 8208 "-" para que tambien admita ese caracter como divisor del rut.

Gracias por el código, lo acabo de encontrar, usare tu regex para mi aplicación php. PD = Quiero poner una idea para discusión...Sera necesario restringir la cantidad de números previos al guion? por que si ingreso por ejemplo 1122334455667788-9 lo toma como válido, y por el momento la cantidad debería ser 9 u 8.

Se podria usar como un plugin en donde se pueda especificar la cantidad máxima de dígitos antes del guion y el regex quedaría así:
^[0-9]{8,9}[-|‐]{1}[0-9kK]{1}$

Gracias!

Gracias por el código, lo acabo de encontrar, usare tu regex para mi aplicación php. PD = Quiero poner una idea para discusión...Sera necesario restringir la cantidad de números previos al guion? por que si ingreso por ejemplo 1122334455667788-9 lo toma como válido, y por el momento la cantidad debería ser 9 u 8.

Se podria usar como un plugin en donde se pueda especificar la cantidad máxima de dígitos antes del guion y el regex quedaría así: ^[0-9]{8,9}[-|‐]{1}[0-9kK]{1}$

value.replace(/^(\d{1,2})(\d{3})(\d{3})(\w{1})$/, '$1.$2.$3-$4'); (junto con maxlength = 10 formatea el rut a xx.xxx.xxx-x)

Buenísimo el aporte @BastianIgn4cio

Hola César González .. Escribo para agradecer Tu Generosidad, cuando uno ya sabes a veces en contra del tiempo..y bajo presion y con la mente nublada lloviendo bajo tormenta las ideas creativas.. se las lleva la lluvia.. gracias por tus código de solidaridad.. colega .. atento aquí..

Gracias por el código, lo acabo de encontrar, usare tu regex para mi aplicación php. PD = Quiero poner una idea para discusion...Sera necesario cambiar la cantidad de numeros anteriores al guion? por que si ingreso por ejemplo 1122334455667788-9 lo toma como válido, y por el momento la cantidad debería ser 9 u 8.
Se podría usar como un plugin en donde se pueda especificar la cantidad máxima de dígitos antes del guion y el regex quedaría así: ^[0-9]{8,9}[-|‐]{1}[0-9kK]{ 1}$

valor.reemplazar(/^(\d{1,2})(\d{3})(\d{3})(\w{1})$/, '$1.$2.$3-$4'); (junto con maxlength = 10 formatea el rut a xx.xxx.xxx-x)

Esto no me funciono, solo con rut de 1 digito primario como 1.111.111-1 pero con dos digitos no funciona, sale asi: 1.111.111-11 en vez de asi: 11.111.111-1

Agradecido con el de arriba

gracias por el aporte, me ayudara mucho para una validacion que necesito hacer.

super buen gist!

para ahorrarme trabajo instalo

npm i -S rut.ts

https://github.com/arrowsw/rut.ts

Gracias por el gist, sigue siendo la referencia que todos copiamos. Después de usarlo un rato encontré tres cosas que vale la pena documentar acá para quien llegue nuevo.

1. El guion Unicode de 2017 no funciona del todo

La regex acepta ‐ (U+2010), pero split('-') solo corta con el guion ASCII. El resultado es que un RUT con ese carácter pasa la validación de formato y después se reporta como inválido:

const rut = '12345678‐5'; // guion Unicode U+2010
/^[0-9]+[-|‐]{1}[0-9kK]{1}$/.test(rut); // true
rut.split('-');                          // ["12345678‐5"]  <- no cortó
Fn.validaRut(rut);                       // false  <- RUT válido rechazado

Como tmp[1] queda undefined, la comparación final siempre falla. Importa porque ese carácter aparece solo cuando alguien copia y pega un RUT desde Word o desde un PDF, que es justo cuando uno no sospecha del guion.

2. El | dentro de la clase de caracteres es literal

En [-|‐] la barra no significa alternancia, es un carácter más. Entonces esto pasa la regex:

/^[0-9]+[-|‐]{1}[0-9kK]{1}$/.test('12345678|5'); // true

No genera un falso positivo porque después el split falla, pero la clase correcta es [-‐] sin la barra.

3. Ojo con el {8,9} sugerido más arriba

La observación de @panconjugo sobre limitar la cantidad de dígitos es correcta, pero el rango deja fuera RUT reales: el cuerpo tiene 7 u 8 dígitos, no 8 o 9 (los 8-9 caracteres son contando el dígito verificador). Con {8,9} un RUT de 7 dígitos se rechaza:

/^[0-9]{8,9}[-|‐]{1}[0-9kK]{1}$/.test('5126663-3'); // false, y es válido

Una versión que cubre los tres casos

Normalizando antes de validar, que además resuelve los puntos:

var Fn = {
  validaRut: function (rutCompleto) {
    if (typeof rutCompleto !== 'string') return false;

    var limpio = rutCompleto
      .replace(/[.\s]/g, '')                              // puntos y espacios
      .replace(/[\u2010\u2011\u2012\u2013\u2014]/g, '-')  // guiones Unicode -> ASCII
      .toLowerCase();

    if (!/^\d{1,8}-[\dk]$/.test(limpio)) return false;

    var tmp = limpio.split('-');
    if (Number(tmp[0]) === 0) return false;

    return String(Fn.dv(tmp[0])) === tmp[1];
  },

  dv: function (T) {
    var M = 0, S = 1;
    for (; T; T = Math.floor(T / 10)) S = (S + T % 10 * (9 - M++ % 6)) % 11;
    return S ? S - 1 : 'k';
  }
};

Dejé \d{1,8} en vez de \d{7,8} a propósito, porque hay RUT antiguos con menos de 7 dígitos y prefiero no rechazarlos. Si en tu caso sabes que eso no va a pasar, {7,8} es más estricto.

Casos con los que lo probé:

Fn.validaRut('12.345.678-5');   // true
Fn.validaRut('12345678‐5');     // true  (guion Unicode)
Fn.validaRut('  12.345.678-5'); // true
Fn.validaRut('5126663-3');      // true  (cuerpo de 7 dígitos)
Fn.validaRut('6-k');            // true
Fn.validaRut('12.345.678-K');   // false
Fn.validaRut('0-0');            // false
Fn.validaRut('12345678|5');     // false
Fn.validaRut(null);             // false

Si a alguien le sirve el desarrollo completo, escribí una guía sobre el dígito verificador del RUT con el paso a paso y los casos que terminan en 0 y en K.