JavaScript
Vanliga uttryck

Syntax

• låt regex = / mönster / [ flaggor ]
• låt regex = new RegExp (' mönster ', [ flaggor ])
• let ismatch = regex.test (' text ')
• låt resultat = regex.exec (' text ')

parametrar

Anmärkningar

Skapa ett RegExp-objekt

Standard skapelse

Det rekommenderas att använda detta formulär endast när du skapar regex från dynamiska variabler.

Används när uttrycket kan ändras eller uttrycket är användargenererat.

var re = new RegExp(".*");

Med flaggor:

var re = new RegExp(".*", "gmi");

Med en backslash: (detta måste undkommas eftersom regexen anges med en sträng)

var re = new RegExp("\\w*");

Statisk initialisering

Använd när du vet att det vanliga uttrycket inte kommer att förändras, och du vet vad uttrycket är före körning.

var re = /.*/;

Med flaggor:

var re = /.*/gmi;

Med ett bakslag: (detta bör inte undkommas eftersom regexen anges i en bokstavlig)

var re = /\w*/;

RegExp-flaggor

Det finns flera flaggor som du kan ange för att ändra RegEx-beteendet. Flaggor kan läggas till i slutet av en regex-bokstav, till exempel att specificera gi in /test/gi , eller de kan anges som det andra argumentet till RegExp konstruktören, som i new RegExp('test', 'gi') .

g - Global. Hitta alla matcher istället för att stoppa efter den första.

i - Ignorera fallet. /[az]/i är ekvivalent med /[a-zA-Z]/ .

m - Multiline. ^ och $ matchar början och slutet på varje rad respektive \n och \r som avgränsare istället för helt enkelt början och slutet av hela strängen.

Matchar med .exec ()

Matcha med .exec()

RegExp.prototype.exec(string) returnerar en matris med fångar, eller null om det inte fanns någon matchning.

var re = /([0-9]+)[a-z]+/;
var match = re.exec("foo123bar");

match.index är 3, match.index (nollbaserade) plats.

match[0] är den fullständiga matchsträngen.

match[1] är texten som motsvarar den första fångade gruppen. match[n] skulle vara värdet för den n. fångade gruppen.

Loop Through Matches med .exec()

var re = /a/g;
var result;
while ((result = re.exec('barbatbaz')) !== null) {
    console.log("found '" + result[0] + "', next exec starts at index '" + re.lastIndex + "'");
}

Förväntad utgång

hittade 'a', nästa exec börjar på index '2'
hittade 'a', nästa exec börjar på index '5'
hittade 'a', nästa exec börjar på index '8'

Kontrollera om strängen innehåller mönster med .test ()

var re = /[a-z]+/;
if (re.test("foo")) {
    console.log("Match exists.");
}

test utför en sökning för att se om ett vanligt uttryck matchar en sträng. Det ordinarie uttrycket [az]+ söker efter en eller flera små bokstäver. Eftersom mönstret matchar strängen kommer "matchning finns" att loggas till konsolen.

Använda RegExp With Strings

Strängobjektet har följande metoder som accepterar regelbundna uttryck som argument.

• "string".match(...
• "string".replace(...
• "string".split(...
• "string".search(...

Matcha med RegExp

console.log("string".match(/[i-n]+/));
console.log("string".match(/(r)[i-n]+/));

Förväntad utgång

Array ["in"]
Array ["rin", "r"]

Byt ut med RegExp

console.log("string".replace(/[i-n]+/, "foo"));

Förväntad utgång

strfoog

Dela med RegExp

console.log("stringstring".split(/[i-n]+/));

Förväntad utgång

Array ["str", "gstr", "g"]

Sök med RegExp

.search() returnerar indexet där en matchning hittas eller -1.

console.log("string".search(/[i-n]+/));
console.log("string".search(/[o-q]+/));

Förväntad utgång

3
-1

Ersätter strängmatchning med en återuppringningsfunktion

String#replace kan ha en funktion som dess andra argument så att du kan tillhandahålla en ersättning baserad på viss logik.

"Some string Some".replace(/Some/g, (match, startIndex, wholeString) => {
  if(startIndex == 0){
    return 'Start';
  } else {
    return 'End';
  }
});
// will return Start string End

En rad mallbibliotek

let data = {name: 'John', surname: 'Doe'}
"My name is {surname}, {name} {surname}".replace(/(?:{(.+?)})/g, x => data[x.slice(1,-1)]);

// "My name is Doe, John Doe"

RegExp-grupper

JavaScript stöder flera typer av grupper i Regular Expressions, capture-grupper , non-capture-grupper och blickar framåt . För närvarande finns det inget bakgrundsstöd .

Fånga

Ibland beror den önskade matchen på dess sammanhang. Detta innebär att en enkel RegExp kommer att hitta över strängen som är av intresse, så lösningen är att skriva en fångstgrupp (pattern) . Den fångade informationen kan sedan refereras till ...

• Strängersättning "$n" där n är den n: e fångstgruppen (från 1 )
• Det första argumentet i en återuppringningsfunktion
• Om RegExp inte är flaggad g , är det n + 1: e objektet i en returnerad str.match Array
• Om RegExp markeras g , str.match tagningar, använd re.exec istället

Säg att det finns en sträng där alla + -tecken behöver ersättas med ett mellanslag, men bara om de följer en bokstavstecken. Detta innebär att en enkel matchning skulle inkludera det bokstavstecknet och att det också skulle tas bort. Att fånga det är lösningen eftersom det betyder att det matchade brevet kan bevaras.

let str = "aa+b+cc+1+2",
    re = /([a-z])\+/g;

// String replacement
str.replace(re, '$1 '); // "aa b cc 1+2"
// Function replacement
str.replace(re, (m, $1) => $1 + ' '); // "aa b cc 1+2"

Icke-Capture

Med hjälp av formuläret (?:pattern) fungerar dessa på liknande sätt som att fånga grupper, förutom att de inte lagrar innehållet i gruppen efter matchen.

De kan vara särskilt användbara om andra data fångas in som du inte vill flytta index på, men behöver göra några avancerade mönstermatchningar som t.ex. en ELLER

let str = "aa+b+cc+1+2",
    re = /(?:\b|c)([a-z])\+/g;

str.replace(re, '$1 '); // "aa+b c 1+2"

Se framåt

Om den önskade matchen förlitar sig på något som följer den, snarare än att matcha den och fånga den, är det möjligt att använda en blick framåt för att testa det men inte inkludera den i matchen. Ett positivt blick framåt har formen (?=pattern) , ett negativt blick framåt (där uttrycket matchar bara händer om blicken framåt mönstret inte matchade) har formen (?!pattern)

let str = "aa+b+cc+1+2",
    re = /\+(?=[a-z])/g;

str.replace(re, ' '); // "aa b cc+1+2"

Med Regex.exec () med parenteser regex för att extrahera matchningar i en sträng

Ibland vill du inte bara byta ut eller ta bort strängen. Ibland vill du extrahera och bearbeta matchningar. Här är ett exempel på hur du manipulerar tändstickor.

Vad är en match? När en kompatibel substring hittas för hela regexet i strängen producerar exec-kommandot en matchning. En match är en matris som komponeras genom att för det första hela substansen som matchade och alla parenteser i matchen.

Föreställ dig en html-sträng:

<html>
<head></head>
<body>
  <h1>Example</h1>
  <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>
  Copyright <a href="https://stackoverflow.com">Stackoverflow</a>
</body>

Du vill extrahera och få alla länkarna i a tagg. Till att börja med, här regexen du skriver:

var re = /<a[^>]*href="https?:\/\/.*"[^>]*>[^<]*<\/a>/g;

Men föreställ dig nu att du vill ha href och anchor för varje länk. Och du vill ha det tillsammans. Du kan helt enkelt lägga till ett nytt regex i för varje match ELLER du kan använda parenteser:

var re = /<a[^>]*href="(https?:\/\/.*)"[^>]*>([^<]*)<\/a>/g; 
var str = '<html>\n    <head></head>\n    <body>\n        <h1>Example</h1>\n        <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>\n\n        Copyright <a href="https://stackoverflow.com">Stackoverflow</a>\n    </body>\';\n';
var m;
var links = [];

while ((m = re.exec(str)) !== null) {
    if (m.index === re.lastIndex) {
        re.lastIndex++;
    }
    console.log(m[0]); // The all substring
    console.log(m[1]); // The href subpart
    console.log(m[2]); // The anchor subpart

    links.push({
      match : m[0],   // the entire match
      href : m[1],    // the first parenthesis => (https?:\/\/.*)
      anchor : m[2],  // the second one => ([^<]*)
    });
}

I slutet av slingan har du en rad länk med anchor och href och du kan använda den för att skriva nedslagning till exempel:

links.forEach(function(link) {
  console.log('[%s](%s)', link.anchor, link.href);
});

Att gå längre :

• Kapslade parentes