Ver el código de «Expresiones Regulares con JavaScript»

Una expresión regular es un objeto que describe un patrón de caracteres. En JavaScript, las expresiones regulares se representan mediante objeto '''RegExp'''. Evidentemente, estos objetos se pueden crear con la constructora '''RegExp()''' pero normalmente se crean utilizando una sintaxis especial. Del mismo modo que los literales de cadena son caracteres especificados entre comillas, los literales de las expresiones regulares se especifican como caracteres dentro de un par de barras inclinadas ('''/'''). Por tanto, nuestro código JavaScript podría contener líneas como esta:
<source lang="javascript">
var patron = /[A-Z]+$/;
</source>

Otro modo de definirla:
<source lang="javascript">
var patron = new RegExp(“[A-Z]+$”);
</source>

La tarea más difícil de definir una expresión regular es, justamente, describir el patrón de caracteres deseado utilizando la sintaxis de las expresiones regulares (puedes ver una pequeña ayuda en el [[Exmpresions_Regulares_en_Linux|siguiente enlace]]).

: '''Para seguir este apartado sobre Expresiones Regulares configura una pequeña web con los siguientes elementos: una caja de texto para introducir la expresión regular, una caja del tipo '''textarea''' para introducir el texto de trabajo, un botón para aplicar el patrón sobre el texto de trabajo y una etiqueta donde se mostrará la salida del programa/función.'''

== Indicadores ==
Además de la gramática de las expresiones regulares, existe un elemento más, '''los indicadores''', que especifican reglas de coincidencia de patrones. Veamos los existentes y qué realizan:
* '''i''' : Ejecuta una coincidencia que no distingue entre minúsculas y mayúsculas.
* '''g''' : Ejecuta una coincidencia global, es decir, encuentra todas las coincidencias en lugar de detenerse tras la primera.
* '''m''' : Modo de múltiples líneas. Recordar que '''^''' coincide con el principio de una línea o de una cadena y '''$''' coincide con el final de una línea o de una cadena.

La expresión regular, con indicadores, se definiría, por ejemplo, del modo que vemos en el siguiente código, donde se define una expresión regular para buscar todas las palabras que empiezan por “'''c'''” y terminan por “'''a'''” en un documento multilínea y buscando todas las coincidencias sin diferenciar entre mayúsculas y minúsculas:
<source lang="javascript">
let strMyReg = “\bc\w*a\b”;
let myRe = new RegExp(expreReg, "gmi");
</source>
Otro modo de hacerlo sería el siguiente:
<source lang="javascript">
let myRe = /\bc\w*a\b/gmi;
</source>

== Métodos de cadena para coincidencia de patrones ==
Los objetos '''String''' admiten cuatro métodos que utilizan expresiones regulares. 
=== search() ===
El más simple es '''search()'''. Este método acepta un argumento de expresión regular y devuelve la posición del carácter inicial de la primera subcadena coincidente, o '''-1''' si no existe ninguna coincidencia. Por ejemplo, la siguiente llamada devuelve 4:
<source lang="javascript">
“JavaScript”.search(/script/i);
</source>

Decir que, '''search()''' no admite búsquedas globales.

=== replace() ===
Otro método que tenemos es [https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/replace replace()], este método ejecuta una operación de búsqueda y reemplazo. Acepta una expresión regular como primer argumento y una cadena de reemplazo como segundo argumento. Si la expresión regular tiene establecido el indicador '''g''', el método '''replace()''' reemplaza todas las coincidencias de la cadena con la cadena de reemplazo; en caso contrario, sólo reemplaza la primera coincidencia que encuentra.
<source lang="javascript">
var texto = `Si quieres hacer en javascript
un texto multilinea y no te acuerdas, 
utiliza las comillas javascript inclinadas`
texto.replace(/javascript/gi, “JavaScript”);
</source>

=== match() ===
El método '''match()''' es el más general de los métodos de expresión regular del objeto '''String'''. Acepta una expresión regular como su único argumento y devuelve una matriz que contiene el resultado de la coincidencia. Si se establece el indicador '''g''', el método devuelve una matriz con todas las coincidencias que aparecen en la cadena.

En el siguiente ejemplo se guardan en un ''array'' los tres números existentes en el texto:
<source lang="javascript">
var texto = `El número 1,
o el número 20, o, como no
el número 323.`
console.log(texto.match(/\d+/g));     //[“1”, “20”, “323”]
</source>

Recordar agregar el indicador '''g''' para que se realice una búsqueda global y, así, cada elemento de la matriz será una coincidencia total. Si no se añade ese indicador '''g''', el primer elemento de la matriz será la coincidencia completa y, los demás elementos de la matriz serán resultados de las subexpresiones entre paréntesis de la completa.

=== split() ===
El último método de expresión regular del objeto '''String''' es '''split()''', ya conocido por nosotros. Este método desglosa la cadena en una matriz de subcadenas, utilizando el argumento como separador. Por ejemplo:
<source lang="javascript">
“123, 456, 789”.split(“,”); //Devuelve [“123”, “456”, “789”]
</source>

El método '''split()''' también acepta una expresión regular como argumento. Así es mucho más eficaz. En el siguiente ejemplo se especifica una “''','''” por separador con un número arbitrario de espacios en blanco en ambos lados:
<source lang="javascript">
“1, 2,  3, 4,   5”.split(/\s*,\s*/); 
//Devuelve [“1”,”2”,”3”,”4”,”5”]
</source>

== Objeto RegExp ==
Como sabemos, las expresiones regulares se representan como objetos '''RegExp'''. Así, tenemos, la función constructora '''RegExp()''', tres métodos y diversas propiedades que veremos ahora.

Podemos ver un ejemplo de la constructora '''RegExp()''', donde se buscan los números de cinco dígitos en una cadena. Tener en cuenta que las cadenas y las expresiones regulares utilizan el carácter '''\''' para secuencias de escape por lo que, cuando se pasa una expresión regular a '''RegExp()''' como literal de cadena, hay que reemplazar cada carácter '''\''' por '''\\'''.
<source lang="javascript">
let patron = new RegExp(“\\d{5}”, “g”);
</source>
¡Ojo!, porque si la expresión regular viene de una variable no hará falta esa doble '''\\'''. Ese detalle es interesante si leemos la expresión regular de una caja de texto o similar.
<source lang="javascript">
let regex = "\d{5}";
let patron = new RegExp(regex, “g”);
</source>

=== Métodos '''RegExp''' para coincidencia de patrones ===
Los objetos '''RegExp''' definen dos métodos que ejecutan operaciones de coincidencia de patrones.

==== exec() ====
El método principal de coincidencia de patrones de '''RegExp''' es '''exec()''', que es similar al método '''match()''' de '''String'''. En este caso, si no existe ninguna coincidencia, devuelve '''null'''. Si encuentra alguna coincidencia, devuelve un array con un comportamiento igual al método '''match()''' de '''String'''.

Así y todo, para recuperar con '''exec()''' todas las coincidencias tal y como se realizó con '''match()''' tendríamos que hacer del siguiente modo:
<source lang="javascript">
let texto = `El número 1,
o el número 20, o, como no
el número 323`;
let patron = new RegExp("\\d+", "g");
let arraySal = new Array();
let arrayMatch = new Array(); //Este array tendrá todas las coincidencias
let sal = "";

while ((arraySal = patron.exec(texto)) != null) {
    arrayMatch.push(arraySal[0]); //Vamos creando el array con todas las coincidencias
	sal +=
		" - Coincidencia : " +
		arraySal[0] +
		" --> en posición : " +
		arraySal.index +
		"\n";
}
console.log(sal);
console.log(arrayMatch);
</source>

==== test() ====
El otro método de '''RegExp()''' es '''test()'''. Este método acepta una cadena y devuelve '''true''' si ésta contiene una coincidencia para la expresión regular. Podemos aquí ver un ejemplo:
<source lang="javascript">
salida = patron.test(texto);
</source>

Con '''test()''' podemos ir recorriendo todo el '''String''' a estudiar tal y como vimos para el método '''exec()'''. 

Tanto para '''test()''' como para '''exec()''' tener en cuenta que existe la propiedad '''lastIndex''' que nos indica dónde se encuentra la siguiente coincidencia de la encontrada en esos momentos. Así que, si en algún momento queremos “volver a empezar” tendremos que configurar esa propiedad a '''0'''.

=== Propiedades de los objetos '''RegExp''' ===
Los objetos '''RegExp''' tienen cinco propiedades:
* '''Source''' - cadena de sólo lectura que contiene el texto de la expresión regular.
* '''Global''' - valor booleano de sólo lectura que especifica si la expresión regular tiene el indicador '''g'''.
* '''IgnoreCase''' - valor booleano de sólo lectura que especifica si la expresión regular tiene el indicador '''i'''.
* '''Multiline''' - valor booleano de sólo lectura que especifica si la expresión regular tiene el indicador '''m'''.
* '''lastIndex''' - entero de lectura/escritura. En patrones con el indicador '''g''', esta propiedad guarda la posición de la cadena en la que se inicia la siguiente búsqueda.

== Patrones complejos ==
A partir de los patrones sencillos ya conocidos, se pueden crear expresiones regulares mucho más complejas. Estos patrones están formados por grupos, referencias inversas, búsquedas directas y otras funciones complejas.

=== Agrupar ===
Las agrupaciones se usan mediante la inclusión entre paréntesis de un conjunto de caracteres. Por ejemplo, si deseamos buscar la cadena “toctoc”, podemos hacerlo del siguiente modo:
<source lang="javascript">
var expReg = /toctoc/g;
</source>

Para modificar este patrón empleando agrupaciones lo haremos del siguiente modo:
<source lang="javascript">
var expReg = /(toc){2}/g;
</source>

Los paréntesis hacen una agrupación y, a continuación, entre llaves, indicamos el número de veces que queremos se repita (en este caso 2).

Sin embargo, no estamos limitados al uso de llaves con grupos, existen otros cuantificadores:
<source lang="javascript">
var expReg1 = /(toc)?/g; // 0 o 1 instancias de “toc”
var expReg2 = /(toc)*/g; // 0 o más instancias de “toc”
var expReg3 = /(toc)+/g; // 1 o más instancias de “toc”
</source>

'''Anexo cuantificadores''' donde vemos la diferencia entre utilizar o no el símbolo ‘'''?'''’ después de ‘'''*'''’ y ‘'''+'''’ :
<source lang="javascript">
var texto = "tocxtocxxtocxxxxtoc";
var expreReg1 = new RegExp(".*toc", "g");
var expreReg2 = new RegExp(".*?toc", "g");
var expreReg3 = new RegExp(".+toc", "g");
var expreReg4 = new RegExp(".+?toc", "g");

console.log("Texto : " + texto);
console.log("Patrón : '.*toc'->Salida : " + texto.match(expreReg1));
console.log("Patrón : '.*?toc'->Salida : " + texto.match(expreReg2));
console.log("Patrón : '.+toc'->Salida : " + texto.match(expreReg3));
console.log("Patrón : '.+?toc'->Salida : " + texto.match(expreReg4));

/* Salida:
Texto : tocxtocxxtocxxxxtoc
Patrón : '.*toc'->Salida : tocxtocxxtocxxxxtoc
Patrón : '.*?toc'->Salida : toc,xtoc,xxtoc,xxxxtoc
Patrón : '.+toc'->Salida : tocxtocxxtocxxxxtoc
Patrón : '.+?toc'->Salida : tocxtoc,xxtoc,xxxxtoc
*/
</source>

Incluso podemos crear grupos más complicados:
<source lang="javascript">
//1 o más instancias de “ba”, “da”, “bad”, “dad”
var expReg = /([bd]ad?)+/g;
</source>

Podemos incluir grupos dentro de otros grupos:
<source lang="javascript">
//comparar “mamá” o “mamá y papá”
var expReg = /(mamá( y papá)?)/g;
</source>

Con expresiones regulares podremos crear un método '''trim()''' para cadenas (implementado ya en JavaScript como '''texto.trim()''').
<source lang="javascript">
var expEspExtra = /^\s+(.*?)\s+$/;
</source>

Al utilizar esta expresión junto al método '''replace()''' del objeto '''String''' y empleando la técnica de referencias inversas, que veremos en el siguiente punto, podemos definir nuestro propio método '''trim()''':
<source lang="javascript">
String.prototype.miTrim = function() {
    let expEspExtra = /^\s+(.*?)\s+$/;
    return this.replace(expEspExtra, "$1");
};
// Como veremos a continuación “$1”
//es la primera referencia inversa
let texto ="    cosa   ";
console.log(texto);
console.log(texto.miTrim());
</source>

: '''Esta técnica, de modificar los objetos predefinidos en JavaScript, se denomina [https://www.audero.it/blog/2016/12/05/monkey-patching-javascript/ Monkey patching] y no es muy recomendable realizarla.'''

=== Referencias inversas ===
Cuando se evalúa una expresión regular con los métodos '''test()''', '''match()''' o '''search()''' (también con el método '''replace()''' de los objetos '''String()'''), se obtiene un grupo de coincidencias que se almacena en una ubicación especial para su posterior utilización. Este grupo de coincidencias tienen como nombre “referencias inversas”.

Podemos realizar el siguiente ejemplo para entender como funcionan las referencias inversas:
<source lang="javascript">
//Definimos la expresión regular
const expEspExtra = /^\s+(\w+)\s+$/;
//Texto con el que vamos a trabajar
const texto = "   cosa   ";
//Aplicamos patrón al texto para buscar coincidencias
let coincidencias = texto.match(expEspExtra);
//Analizamos el objeto de salida
console.log("Contenido del objeto: ");
console.log(coincidencias);
console.log("Tipo de objeto: " + typeof(coincidencias));
console.log("Número de elementos: " + coincidencias.length);
console.log("Iteramos en cada uno de los elementos:");
console.log("\tClave --> Valor");
for(let i in coincidencias) {
    console.log("\t" + i + " --> " + coincidencias[i]);
}
/*Salida:
Contenido del objeto:
Array [ "   cosa   ", "cosa" ]
Tipo de objeto: object
Número de elementos: 2
Iteramos en cada uno de los elementos:
	Clave --> Valor
	0 -->    cosa  
	1 --> cosa
	index --> 0
	input -->    cosa  
	groups --> undefined
*/
</source>
: '''Como se comentó antes: al agregar el indicador ''g'' se realiza una búsqueda global y, así, cada elemento de la matriz será una coincidencia total. Si no se añade ese indicador ''g'', el primer elemento de la matriz será la coincidencia completa y, los demás elementos de la matriz serán resultados de las subexpresiones entre paréntesis de la completa.'''

Vemos que podemos acceder a las referencias inversas del siguiente modo:
* Primera referencia inversa : coincidencias[1]
* Segunda referencia inversa : coincidencias[2]
* ...
Otro modo de acceder a ellas será utilizando el objeto '''RegExp''':
* Primera referencia inversa : RegExp.$1
* Segunda referencia inversa : RegExp.$2
* ...

Por último, las referencias inversas pueden utilizarse con el método '''replace()''' de '''String''' con las secuencias de caracteres especiales '''$1''', '''$2''', etc. El mejor ejemplo para ilustrarlo cosiste en invertir el orden de dos elementos de una cadena. Imagina que deseas cambiar la cadena "1234 5678" por "5678 1234". Podríamos hacerlo del siguiente modo:
<source lang="javascript">
const textoBase = `Esta es una secuencia
 de números 1234 5678 muy interesante.`
const patron = /(\d{4})\s+(\d{4})/;
let textoNuevo = textoBase.replace(patron, "$2 $1");
//Vemos cómo se realiza el cambio:
console.log("Texto base: ");
console.log(textoBase);
console.log("Coincidencias con el patrón :" + patron);
console.log(textoBase.match(patron));
console.log("Con el método replace() cambiamos de orden")
console.log(`Así $1: ${RegExp.$1} y $2: ${RegExp.$2}`);
console.log("El texto ahora queda así: ");
console.log(textoNuevo);
/*Salida:
Texto base:
Esta es una secuencia
 de números 1234 5678 muy interesante.
Coincidencias con el patrón :/(\d{4})\s+(\d{4})/
Array(3) [ "1234 5678", "1234", "5678" ]
Con el método replace() cambiamos de orden
Así $1: 1234 y $2: 5678
El texto ahora queda así:
Esta es una secuencia
 de números 5678 1234 muy interesante.
*/
</source>

=== Alternar ===
Imagina que quieres buscar en un texto la existencia de las palabras "roja" y "negra"con una única expresión. Estas palabras no tienen caracteres en común, por lo que deberías aplicar el operador '''OR''' en nuestra expresión regular. El modo de hacerlo es utilizando la barra ('''|''') tal y como podemos ver en el siguiente ejemplo. En él se utiliza [https://es.wikipedia.org/wiki/Bandera_de_Albania el texto de la Wikipedia sobre el origen de la bandera de Albania] y buscamos en él la existencia o no de las palabras "negra/o" o "roja/o":
<source lang="javascript">
const texto = `La bandera de Albania es una bandera roja con un águila bicéfala negra en el centro. Tiene su origen en un sello similar de Gjergj Kastriot Skanderbeg, un albanés del siglo XV que condujo la revuelta contra el Imperio otomano, y que acabó en una breve independencia para Albania entre 1443 y 1478.`
const patronRojoNegro = /(roj[oa]|negr[oa])/;
console.log(texto);
console.log(patronRojoNegro.test(texto)); //Devuelve true
</source>

=== Grupos sin captura ===
Los grupos que crean referencias inversas se denominan también "grupos de captura". En expresiones regulares muy extensas, el almacenamiento de referencias inversas ralentiza el proceso de búsqueda. JavaScript permite realizar "grupos sin captura" para no sobrecargar el sistema. Para realizarlo sólo tendremos que acompañar el paréntesis de apertura de un interrogante y dos puntos "'''(?: ... )'''". Como en el siguiente ejemplo:
<source lang="javascript">
const textoBase = `Ésta es una secuencia
 de números 1234 5678 muy interesante.`
const patronCC = /(\d{4})\s+(\d{4})/;
const patronSC = /(?:\d{4})\s+(?:\d{4})/;
//Comprobamos la existencia o no de Referencias inversas
console.log("Con Captura:");
console.log(textoBase.match(patronCC));
console.log("Sin Captura:");
console.log(textoBase.match(patronSC));
/*Salida:
Con Captura:
Array(3) [ "1234 5678", "1234", "5678" ]
Sin Captura:
Array [ "1234 5678" ]
*/
</source>

=== Búsquedas directas ===
En ocasiones es necesario capturar un determinado grupo de caracteres sólo si aparecen antes que otro grupo de caracteres. El uso de búsquedas directas facilita esta operación.

Existen búsquedas directas negativas y positivas. Para crear una '''búsqueda directa positiva''' es necesario incluir un patrón entre '''(?='''  y  ''')'''. Ojo con estos paréntesis, pues no representan un grupo. Para crear una '''búsqueda directa negativa''' es necesario incluir un patrón entre '''(?!'''  y  ''')'''. Podemos ver un ejemplo para que quede más claro el concepto:
<source lang="javascript">
//Texto de trabajo
let texto = `En Compostela se realiza compostaje.`;
//Expresiones Regulares
let rePositiva = /(compos(?=tela))/gmi;
let reNegativa = /(compos(?!taje))/gmi;
//Búsqueda de coincidencias
console.log(texto.search(rePositiva)); 
//Salida: 3  (Posición inicio Compostela)
console.log(texto.search(reNegativa)); 
//Salida: 3  (Posición inicio Compostela)

//Cambiamos las Expresiones Regulares
rePositiva = /(compos(?=taje))/gmi;
reNegativa = /(compos(?!tela))/gmi;
//Búsqueda de coincidencias
console.log(texto.search(rePositiva)); 
//Salida: 25  (Posición inicio compostaje)
console.log(texto.search(reNegativa)); 
//Salida: 25  (Posición inicio compostaje)
</source>

== Patrones comunes ==
En la web las expresiones regulares se suelen utilizar para validar entradas del usuario antes de enviar los datos al servidor. Alguno de los patrones más utilizados en Web son los siguientes:

=== Fechas ===
Formato dd/mm/aaaa genérico y con "grupos con captura" para acceder al día, al mes y al año independientemente:
<source lang="javascript">
let texto = "Naciste el día 14/12/2020, día de Nochebuena";
let reFecha = /(\d{1,2})\/(\d{1,2})\/(\d{4})/g;
let coincidencias = texto.match(reFecha);
console.log(coincidencias);
//Salida: "14/12/2020"
//Prueba cuál sería la salida si no pones el parámetro 'g'
</source>

El problema es que podemos tener días y meses fuera de rango : 55/42/2004

Podemos ir diseñando una mejor RegExp para las fechas:
* Patrón lógico para días:
: <source lang="javascript">
let reDia = /[0-3]?[0-9]/;
</source>

* Así y todo, existen días erróneos como del 32 al 39. Para solucionarlo:
: <source lang="javascript">
let reDia = /0[1-9]|[12][0-9]|3[01]/;
</source>

* El patrón de meses será muy similar:
: <source lang="javascript">
let reMes = /0[1-9]|1[0-2]/;
</source>

* Para el año, podemos centrarnos entre el 1900 y 2099:
: <source lang="javascript">
let reAno = /19|20\d{2}/;
</source>

: Así, podemos combinar todos los patrones y, además, utilizando "grupos sin captura" para cada parte. Aunque también podríamos dejarlos con captura si fuese necesario para algo.
: <source lang="javascript">
let reFecha = /(?:0[1-9]|[12][0-9]|3[01])\/(?:0[1-9]|1[0-2])\/(?:19|20\d{2})/;
</source>

Por último, es mucho más sencillo utilizar una función para comprobar la validez de una fecha, por lo que utilizaremos esta expresión regular para crear la función '''esFechaValida()''':
<source lang="javascript">
//Esta función devuelve 'true' o 'false' dependiendo si el texto es una fecha.
function esFechaValida(texto) {
    let reFecha = /(?:0[1-9]|[12][0-9]|3[01])\/(?:0[1-9]|1[0-2])\/(?:19|20\d{2})/;
    return reFecha.test(texto); }
// -- //
//Sería interesante realizar una función que, dado un texto, 
// devuelva un array con todas las fechas existentes
</source>

=== Tarjetas de crédito ===
Hoy en día, el uso de las [https://es.wikipedia.org/wiki/N%C3%BAmero_de_tarjeta_bancaria tarjetas de crédito] está muy extendido para el pago ''online''. Así que, será necesario la validación de dichos identificadores en muchos formularios.

Para empezar, podemos utilizar un número de '''[https://www.mastercard.es/es-es.html MasterCard]''', que debe tener 16 dígitos. De éstos, los dos primeros números deben estar comprendidos entre 51 y 55. El patrón será el siguiente:
<source lang="javascript">
let reMasterCard = /^5[1-5]\d{14}$/;
</source>

Este patrón es correcto pero los números de '''[https://www.mastercard.es/es-es.html MasterCard]''' se pueden introducir con espacios o guiones entre grupos de cuatro dígitos, como en 5555-5555-5555-5555, algo que también debemos tener en cuenta:
<source lang="javascript">
let reMasterCard = /^5[1-5]\d{2}([\s-]?\d{4}){3}$/;
</source>

La validación real de números de tarjeta de crédito requiere utilizar el '''[https://gist.github.com/DiegoSalazar/4075533 algoritmo de Luhn]'''. Para aplicarle el algoritmo a cada uno de los números, es necesario extraerlos de la entrada del usuario, lo que implica utilizar grupos de captura en la expresión regular:
<source lang="javascript">
let reMasterCard = /^(5[1-5]\d{2})[\s\-]?(\d{4})[\s\-]?(\d{4})[\s\-]?(\d{4})$/;
</source>

Ya podemos empezar a crear una función para validar un número de '''MasterCard'''. El primer paso consiste en probar una determinada cadena en función del patrón. Si la cadena coincide, añadimos los grupos de cuatro dígitos a la misma (por ejemplo : “5432-1234-5678-9012” se convertiría en “5432123456789012”).

Esa secuencia de números es la que le tenemos que pasar a la función que implementa el '''algoritmo de Luhn''' y que podemos bajar de la web.
 
El código de las dos funciones quedaría del siguiente modo:
<source lang="javascript">
//Función implementación algoritmo de Luhn
function valid_credit_card(value) {
    // Accept only digits, dashes or spaces
    if (/[^0-9-\s]+/.test(value)) return false;
    // The Luhn Algorithm. It's so pretty.
    let nCheck = 0, bEven = false;
    value = value.replace(/\D/g, "");

    for (var n = value.length - 1; n >= 0; n--) {
        var cDigit = value.charAt(n), nDigit = parseInt(cDigit, 10);
        if (bEven && (nDigit *= 2) > 9) nDigit -= 9;
        nCheck += nDigit;
        bEven = !bEven;
    }
    return (nCheck % 10) == 0;
}

//Función programada por nosotros que valida
//la Tarjeta de Crédito llamando a la función de Luhn
function esValidaMasterCard(sText) {
    let reMasterCard = /^(5[1-5]\d{2})[\s\-]?(\d{4})[\s\-]?(\d{4})[\s\-]?(\d{4})$/;
    if (reMasterCard.test(sText)) {
        let sNumTar = RegExp.$1 + RegExp.$2 + RegExp.$3 + RegExp.$4; 
        //Comprobamos alguna salida
        console.log("Array salida método match:");
        console.log(sText.match(reMasterCard));
        console.log("Texto que se le pasa a Luhn: " + sNumTar);
        //Realizamos aquí llamada a la función 
        //que implementa el algoritmo de Luhn
        return valid_credit_card(sNumTar); } 
    else { return false; }
}

//Hacemos una comprobación
let numTarjeta = "5432-1234-5678-9012";
let valida = esValidaMasterCard(numTarjeta);
console.log("La tarjeta con número " + numTarjeta + " es válida? " + valida);
</source>

En el caso de otras tarjetas de crédito, como vemos, la comprobación de la validez de su número va a ser similar, pues casi todas se basan en que cumplan el algoritmo de Luhn.

=== Direcciones de correo electrónico ===
La creación de un patrón para comparar todas las direcciones válidas de correo eléctrónico es una labor compleja. Hay que saber que, la especificación que define la validez de una dirección de correo es [https://tools.ietf.org/html/rfc2822 RFC 2822], que considera válidos los siguientes patrones:
* andrea@dominio.com
* andrea.torres@dominio.com
* Andrea Torres  <andrea.torres@dominio.com>
* "andrea.torres"@dominio.com
* andrea@[10.1.3.1]

Está claro que, de todas éstas, los usuarios suelen utilizar las dos primeras en sitios y aplicaciones Web, por lo que nos centraremos en la validación de estos patrones. Así, tendremos en cuenta las siguientes normas:
* Una dirección de correo electrónico está formada por una serie de caracteres (números, letras, guiones, puntos o cualquier otro menos espacios), seguidos por un símbolo '''@''', seguido por más caracteres.
* Por delante del símbolo '''@''' debe haber, al menos, un carácter.
* Por detrás del símbolo '''@''' debe haber, al menos, tres caracteres, el segundo de los cuales ha de ser un punto ('''a@a.b''' es una dirección válida, mientras que '''a@a''' no lo es).
* El texto que aparece por delante y por detrás del símbolo '''@''' nunca puede comenzar ni terminar en punto, y no puede tener dos puntos seguidos.

Así pues, la expresión regular sería la siguiente:
<source lang="javascript">
let reEmail = /^(?:\w+\.?)*\w+@(?:\w+\.)+\w+$/;
</source>

Y así, la función de validación quedaría del siguiente modo:
<source lang="javascript">
function esValidoEmail(sText) {
    let reEmail = /^(?:\w+\.?)*\w+@(?:\w+\.)+\w+$/;
    return reEmail.test(sText);
}
</source>

[[JavaScript|Volver]]