Tengo un muy largo expresión regular, que quiero dividir en varias líneas, en mi código JavaScript para mantener la longitud de cada línea de 80 caracteres, de acuerdo a JSLint reglas. Es mejor para la lectura, creo.
Aquí está el patrón de la muestra:

var pattern = /^(([^<>()[\]\.,;:\[email protected]\"]+(\.[^<>()[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@((\[[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,}))$/;
  • Parece que está (intentar) validar direcciones de correo electrónico. ¿Por qué no simplemente hacer /\[email protected]\S+\.\S+/ ?
  • Probablemente, usted debe buscar para encontrar una manera de hacerlo sin una expresión regular, o con pequeños múltiples expresiones regulares. Eso sería mucho más legible que una expresión regular que largo. Si la expresión regular es de más de 20 caracteres, probablemente hay una forma mejor de hacerlo.
  • No es de los 80 caracteres tipo de obsoleto hoy en día con los monitores de ancho?
  • No. Una persona puede estar usando división de windows en vim, un terminal virtual en una sala de servidores. Es incorrecto asumir que todo el mundo estará de codificación en la misma ventanilla como usted. Además, la limitación de sus líneas de 80 caracteres obliga a romper su código en pequeñas funciones.
  • Bien, veo claramente su motivación para querer hacer esto aquí – una vez que esta expresión se divide en varias líneas, como se demuestra por Koolilnc, de inmediato se convierte en un perfecto ejemplo de la lectura, la auto-documentar el código. _
  • Mira XRegExp.
  • todavía puede ser conveniente ser capaz de dividir un gran monitor en varias ventanas. Por ejemplo, en una ventana de tu editor de texto, en otra unidad de ejecución de pruebas de

InformationsquelleAutor Nik Sumeiko | 2012-09-07

8 Comentarios

  1. 108

    Se puede convertir en una cadena y crear la expresión llamando new RegExp():

    var myRE = new RegExp (['^(([^<>()[\]\.,;:\[email protected]\"]+(\.[^<>(),[\]\.,;:\[email protected]\"]+)*)',
                            '|(\".+\"))@((\[[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(''));

    Notas:

    1. cuando la conversión de la expresión literal a una cadena que necesita para escapar de todas las barras invertidas como barras diagonales inversas son consumidos cuando se evalúa un literal de cadena. (Ver Kayo comentario para más detalle).
    2. RegExp acepta modificadores como un segundo parámetro

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

    [Además ES20xx (etiquetado plantilla)]

    En ES20xx puede utilizar etiquetado de plantillas. Ver el fragmento de código.

    Nota:

    • Desventaja aquí es que usted no puede utilizar texto en blanco en la expresión regular de la cadena (siempre uso \s, \s+, \s{1,x}, \t, \n etc).

    JS:

    (() => {
      const createRegExp = (str, opts) => 
        new RegExp(str.raw[0].replace(/\s/gm, ""), opts || "");
      const yourRE = createRegExp`
        ^(([^<>()[\]\.,;:\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,}))$`;
      console.log(yourRE);
      const anotherLongRE = createRegExp`
        (\byyyy\b)|(\bm\b)|(\bd\b)|(\bh\b)|(\bmi\b)|(\bs\b)|(\bms\b)|
        (\bwd\b)|(\bmm\b)|(\bdd\b)|(\bhh\b)|(\bMI\b)|(\bS\b)|(\bMS\b)|
        (\bM\b)|(\bMM\b)|(\bdow\b)|(\bDOW\b)
        ${"gi"}`;
      console.log(anotherLongRE);
    })();

    • Un new RegExp es una gran manera para varias líneas de expresiones regulares. En lugar de unirse a las matrices, sólo se puede utilizar un operador de concatenación de cadenas: var reg = new RegExp('^([a-' + 'z]+)$','i');
    • Precaución: mucho regular la expresión literal podría dividirse en varias líneas con la respuesta anterior. Sin embargo, las necesidades de cuidado, porque usted no puede simplemente copiar la expresión regular literal (que se define con //) y pegarlo como el argumento de cadena para la RegExp constructor. Esto es porque los caracteres de barra diagonal inversa se consumen cuando se evalúa la literal de cadena. Ejemplo: /Hey\sthere/ no puede ser reemplazado por new RegExp("Hey\sthere"). Por el contrario, debe ser reemplazado por new RegExp("Hey\\sthere") Nota el extra de barra diagonal inversa! Por lo tanto prefiero acaba de salir de una larga regex literal en una línea larga
    • Aún más clara manera de hacer esto es crear variables de retención significativa subsecciones, y unirse a los como cadenas o en una matriz. Que le permite construir el RegExp de una manera que es mucho más fácil de entender.
  2. 101

    Extender @KooiInc respuesta, usted puede evitar de forma manual para escapar de cada carácter especial mediante el source propiedad de la RegExp objeto.

    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 la repetición de los .source propiedad que usted puede hacer uso de la Array.map() función:

    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 de mapa puede ser reducido a:
    .map(r => r.source)

    • Exactamente lo que estaba buscando, super limpio. Gracias!
    • Esto debe ser aceptado respuesta, muy limpio
    • Esto es muy conveniente para agregar comentarios a un largo regexp. Sin embargo, está limitada por haber coincidencia entre paréntesis en la misma línea.
    • Sin duda, este! Super bonito, con la posibilidad de comentar cada uno de los sub-regex.
  3. 24

    El uso de cadenas en new RegExp es incómodo porque debe escapar de todas las barras diagonales inversas. Usted puede escribir más pequeños, expresiones regulares y concatenarlas.

    Vamos a dividir esta expresión

    /^foo(.*)\bar$/

    Vamos a utilizar una función para hacer las cosas más bellas, más tarde

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

    Y ahora vamos a la roca

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

    Ya que tiene un costo, tratar de construir la verdadera regex sólo una vez y, a continuación, utilizar ese.

  4. 4

    La expresión anterior es que falta un poco de negro barras que no está funcionando correctamente. Así que, he editado el regex. Por favor considere esta expresión que funciona el 99,99% para el correo electrónico de validación.

    let EMAIL_REGEXP = 
    new RegExp (['^(([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()\[\]\\.,;:\[email protected]\"]+)*)',
                        '|(".+"))@((\[[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(''));
  5. 3

    Hay buenas respuestas aquí, pero para la integridad alguien debe mencionar Javascript característica esencial de la herencia con el cadena de prototipos. Algo como esto ilustra la idea:

    JS:

    RegExp.prototype.append = function(re) {
      return new RegExp(this.source + re.source, this.flags);
    };
    
    let regex = /[a-z]/g
    .append(/[A-Z]/)
    .append(/[0-9]/);
    
    console.log(regex); //=> /[a-z][A-Z][0-9]/g

  6. 1

    Para evitar la Matriz join, también puede utilizar la sintaxis siguiente:

    var pattern = new RegExp('^(([^<>()[\]\.,;:\[email protected]\"]+' +
      '(\.[^<>()[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@' +
      '((\[[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,}))$');
  7. 0

    Personalmente, me iría a por una menos complicada regex:

    /\[email protected]\S+\.\S+/

    Seguro, es menos precisa de su actual patrón, pero, ¿qué estás tratando de lograr? Estás tratando de atrapar errores accidentales que sus usuarios pueden entrar, o le preocupa que los usuarios podrían tratar de introducir las direcciones no válidas? Si es la primera, yo iría a por una más fácil de patrón. Si es esto último, algunos de verificación por responder a un correo electrónico enviado a esa dirección podría ser una mejor opción.

    Sin embargo, si usted desea utilizar su actual patrón, sería (OMI) fácil de leer (y mantener!) mediante la construcción de pequeños sub-patrones, como este:

    var box1 = "([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()[\]\\.,;:\[email protected]\"]+)*)";
    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 RegExp("^(" + box1 + "|" + box2 + ")@(" + host1 + "|" + host2 + ")$");
    • Downvoting – a Pesar de sus comentarios acerca de la reducción de la expresión de la complejidad son válidos, OP específicamente se pregunta cómo «split largo regex a través de varias líneas». Así que, a pesar de que su consejo es válido, ha sido dada por las razones equivocadas. por ejemplo, el cambio de la lógica de negocio para trabajar en torno a un lenguaje de programación. Además, el código de ejemplo que usted le dio es bastante feo.
    • Creo que Bart ha respondido a la pregunta. Consulte la última sección de su respuesta. Él ha contestado la pregunta así como una alternativa.
  8. 0

    Usted puede simplemente utilizar la cadena de operación.

    var pattenString = "^(([^<>()[\]\.,;:\[email protected]\"]+(\.[^<>()[\]\.,;:\[email protected]\"]+)*)|"+
    "(\".+\"))@((\[[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,}))$";
    var patten = new RegExp(pattenString);

Dejar respuesta

Please enter your comment!
Please enter your name here