probar - ¿Cómo dividir una expresión regular larga en varias líneas en JavaScript?

probar expresiones regulares

Question

Tengo una expresión regular muy larga, que deseo dividir en varias líneas en mi código JavaScript para mantener cada longitud de línea de 80 caracteres según las reglas de JSLint. Es mejor para leer, creo. Aquí hay una muestra de patrón:

var pattern = /^(([^<>()[/]//.,;:/s@/"]+(/.[^<>()[/]//.,;:/s@/"]+)*)|(/".+/"))@((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/])|(([a-zA-Z/-0-9]+/.)+[a-zA-Z]{2,}))$/;

Answer 1

A la expresión regular anterior le faltan algunas barras negras que no funcionan correctamente. Entonces, edité la expresión regular. Considere esta expresión regular que funciona 99,99% para la validación de correo electrónico.

let EMAIL_REGEXP = 
new RegExp ([''^(([^<>()[//]///.,;://s@/"]+(//.[^<>()//[//]///.,;://s@/"]+)*)'',
                    ''|(".+"))@((//[[0-9]{1,3}//.[0-9]{1,3}//.[0-9]{1,3}//.'',
                    ''[0-9]{1,3}/])|(([a-zA-Z//-0-9]+//.)+'',
                    ''[a-zA-Z]{2,}))$''].join(''''));

Answer 2

Al extender la respuesta de @KooiInc, puede evitar escaparse manualmente de cada carácter especial utilizando la propiedad de origen RegExp objeto RegExp .

Ejemplo:

var urlRegex= new RegExp(''''
  + /(?:(?:(https?|ftp):)?////)/.source     // protocol
  + /(?:([^:/n/r]+):([^@/n/r]+)@)?/.source  // user:pass
  + /(?:(?:www/.)?([^///n/r]+))/.source     // domain
  + /(//[^?/n/r]+)?/.source                 // request
  + /(/?[^#/n/r]*)?/.source                 // query
  + /(#?[^/n/r]*)?/.source                  // anchor
);

o si desea evitar repetir la propiedad .source , puede hacerlo utilizando la función Array.map() :

var urlRegex= new RegExp([
  /(?:(?:(https?|ftp):)?////)/      // protocol
  ,/(?:([^:/n/r]+):([^@/n/r]+)@)?/  // user:pass
  ,/(?:(?:www/.)?([^///n/r]+))/     // domain
  ,/(//[^?/n/r]+)?/                 // request
  ,/(/?[^#/n/r]*)?/                 // query
  ,/(#?[^/n/r]*)?/                  // anchor
].map(function(r) {return r.source}).join(''''));

En ES6, la función del mapa se puede reducir a: .map(r => r.source)

Answer 3

Para evitar la join matriz, también puede usar la siguiente sintaxis:

var pattern = new RegExp(''^(([^<>()[/]//.,;:/s@/"]+'' +
  ''(/.[^<>()[/]//.,;:/s@/"]+)*)|(/".+/"))@'' +
  ''((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/])|'' +
  ''(([a-zA-Z/-0-9]+/.)+[a-zA-Z]{2,}))$'');

Answer 4

Personalmente, buscaría una expresión regular menos complicada:

//S+@/S+/./S+/

Claro, es menos preciso que tu patrón actual, pero ¿qué estás tratando de lograr? ¿Está tratando de detectar errores accidentales que sus usuarios pueden ingresar o le preocupa que sus usuarios intenten ingresar direcciones no válidas? Si es el primero, buscaría un patrón más fácil. Si es el último, una mejor opción podría ser una verificación respondiendo a un correo electrónico enviado a esa dirección.

Sin embargo, si desea utilizar su patrón actual, sería (IMO) más fácil de leer (y mantener) construyéndolo a partir de subpatrones más pequeños, como este:

var box1 = "([^<>()[/]////.,;:/s@/"]+(//.[^<>()[//]////.,;:/s@/"]+)*)";
var box2 = "(/".+/")";
var host1 = "(//[[0-9]{1,3}//.[0-9]{1,3}//.[0-9]{1,3}//.[0-9]{1,3}//])";
var host2 = "(([a-zA-Z/-0-9]+//.)+[a-zA-Z]{2,})";

var regex = new RexExp("^(" + box1 + "|" + box2 + ")@(" + host1 + "|" + host2 + ")$");

Answer 5

Puede convertirlo en una cadena y crear la expresión llamando a new RegExp() :

var myRE = new RegExp ([''^(([^<>()[/]//.,;://s@/"]+(//.[^<>(),[/]//.,;://s@/"]+)*)'',
                        ''|(//".+//"))@((//[[0-9]{1,3}//.[0-9]{1,3}//.[0-9]{1,3}//.'',
                        ''[0-9]{1,3}/])|(([a-zA-Z/-0-9]+//.)+'',
                        ''[a-zA-Z]{2,}))$''].join(''''));

Nota:

1. Al convertir la expresión literal a una cadena, debe escapar de todas las barras invertidas, ya que las barras invertidas se consumen al evaluar una cadena literal . (Ver el comentario de Kayo para más detalles).

2. RegExp acepta modificadores como un segundo parámetro

   /regex/g => new RegExp(''regex'', ''g'')

Answer 6

Usar cadenas en new RegExp es incómodo porque debes escapar de todas las barras diagonales inversas. Puede escribir expresiones regulares más pequeñas y concatenarlas.

Vamos a dividir esta expresión regular

/^foo(.*)/bar$/

Usaremos una función para hacer las cosas más bellas después

function multilineRegExp(regs, options) {
    return new RegExp(regs.map(
        function(reg){ return reg.source; }
    ).join(''''), options);
}

Y ahora vamos a rockear

var r = multilineRegExp([
     /^foo/,  // we can add comments too
     /(.*)/,
     //bar$/
]);

Como tiene un costo, intente construir la expresión regular real solo una vez y luego usar eso.