it-swarm.com.de

Wie kann ein langer regulärer Ausdruck in JavaScript in mehrere Zeilen aufgeteilt werden?

Ich habe einen sehr langen regulären Ausdruck, den ich in meinem JavaScript-Code in mehrere Zeilen aufteilen möchte, um jede Zeilenlänge 80 Zeichen gemäß den JSLint-Regeln zu erhalten. Ich denke, es ist einfach besser zum Lesen. Hier ein Musterbeispiel:

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,}))$/;
109
Nik Sumeiko

Sie können es in einen String konvertieren und den Ausdruck erstellen, indem Sie new RegExp() aufrufen:

_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(''));
_

Anmerkungen:

  1. wenn Sie das - Ausdrucksliteral in einen String konvertieren, müssen Sie alle Backslashes maskieren, da Backslashes beim Auswerten eines - Stringliterales verwendet werden. (Siehe Kayos Kommentar für weitere Einzelheiten.)
  2. RegExp akzeptiert Modifikatoren als zweiten Parameter

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

[ Zusatz ES20xx (getaggte Vorlage)]

In ES20xx können Sie mit Tags versehene Vorlagen verwenden. Siehe den Ausschnitt.

Hinweis:

  • Nachteil ist, dass Sie in der Zeichenfolge für reguläre Ausdrücke kein Leerzeichen verwenden können (verwenden Sie immer _\s_, _\s+\s{1,x}_, _\t_, _\n_ usw.) .
_(() => {
  const createRegExp = (str, opts) => 
    new RegExp(str.raw[0].replace(/\s/gm, ""), opts || "");
  const yourRE = createRegExp`
    ^(([^<>()[\]\\.,;:\[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,}))$`;
  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);
})();_
104
KooiInc

Wenn Sie die Antwort @KooiInc erweitern, können Sie vermeiden, dass jedes Sonderzeichen manuell umgangen wird, indem Sie die source-Eigenschaft des RegExp-Objekts verwenden. 

Beispiel:

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
);

oder wenn Sie die .source-Eigenschaft nicht wiederholen möchten, können Sie dies mit der Funktion Array.map() tun:

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(''));

In ES6 kann die Kartenfunktion reduziert werden auf: .map(r => r.source)

89
korun

Die Verwendung von Strings in new RegExp ist umständlich, da alle umgekehrten Schrägstriche entfernt werden müssen. Sie können kleinere Regexe schreiben und diese verketten.

Lassen Sie uns diesen Regex teilen

/^foo(.*)\bar$/

Wir werden später eine Funktion verwenden, um die Dinge schöner zu gestalten

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

Und jetzt lasst uns rocken

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

Da dies mit Kosten verbunden ist, versuchen Sie, den reellen Regex nur einmal zu erstellen, und verwenden Sie ihn dann.

22
Riccardo Galli

Der Regex oben fehlt einige schwarze Schrägstriche, die nicht richtig funktionieren. Also habe ich die Regex bearbeitet. Bitte beachten Sie diesen Regex, der für die E-Mail-Überprüfung zu 99,99% funktioniert.

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(''));
4
Anvesh Reddy

Hier gibt es gute Antworten, aber zur Vollständigkeit sollte jemand die Kernfunktion von Javascript mit der Prototypkette erwähnen. So etwas veranschaulicht die Idee:

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

1
James Donohue

Um das Array join zu vermeiden, können Sie auch die folgende Syntax verwenden:

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,}))$');
1
andreasonny83

Persönlich würde ich für eine weniger komplizierte Regex gehen:

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

Sicher, es ist weniger genau als Ihr aktuelles Muster, aber was möchten Sie erreichen? Versuchen Sie, versehentliche Fehler Ihrer Benutzer zu erkennen, oder haben Sie Angst, dass Ihre Benutzer versuchen, ungültige Adressen einzugeben? Wenn es das erste ist, würde ich mich für ein einfacheres Muster entscheiden. Im letzteren Fall könnte eine Überprüfung durch Beantworten einer an diese Adresse gesendeten E-Mail die bessere Option sein.

Wenn Sie jedoch Ihr aktuelles Muster verwenden möchten, ist es (IMO) einfacher zu lesen (und zu pflegen!), Indem Sie es aus kleineren Teilmustern zusammensetzen, wie beispielsweise

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 + ")$");
1
Bart Kiers

Sie können die Zeichenkettenoperation einfach verwenden.

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);
0
Mubeena