JavaScript
Normale uitdrukkingen

Syntaxis

• let regex = / pattern / [ vlaggen ]
• let regex = new RegExp (' patroon ', [ vlaggen ])
• let ismatch = regex.test (' text ')
• let results = regex.exec (' text ')

parameters

Opmerkingen

Een RegExp-object maken

Standaard creatie

Het wordt aanbevolen om dit formulier alleen te gebruiken bij het maken van regex van dynamische variabelen.

Gebruik wanneer de uitdrukking kan veranderen of de uitdrukking door de gebruiker is gegenereerd.

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

Met vlaggen:

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

Met een backslash: (dit moet worden ontsnapt omdat de regex is opgegeven met een tekenreeks)

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

Statische initialisatie

Gebruik wanneer u weet dat de reguliere expressie niet zal veranderen en u weet wat de expressie is vóór runtime.

var re = /.*/;

Met vlaggen:

var re = /.*/gmi;

Met een backslash: (dit moet niet worden ontlopen omdat de regex letterlijk is opgegeven)

var re = /\w*/;

RegExp vlaggen

Er zijn verschillende vlaggen die u kunt opgeven om het RegEx-gedrag te wijzigen. Vlaggen kunnen worden toegevoegd aan het einde van een letterlijke regex, zoals het opgeven van gi in /test/gi , of ze kunnen worden opgegeven als het tweede argument voor de RegExp constructor, zoals in de new RegExp('test', 'gi') .

g - Wereldwijd. Vindt alle wedstrijden in plaats van te stoppen na de eerste.

i - Negeer geval. /[az]/i is equivalent aan /[a-zA-Z]/ .

m - Multiline. ^ en $ overeen met het begin en einde van elke regel en behandelen respectievelijk \n en \r als scheidingstekens in plaats van alleen het begin en het einde van de hele string.

Overeenkomend met .exec ()

.exec() met .exec()

RegExp.prototype.exec(string) retourneert een reeks vastleggingen, of null als er geen overeenkomst was.

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

match.index is 3, de (op nul gebaseerde) locatie van de wedstrijd.

match[0] is de volledige overeenkomstreeks.

match[1] is de tekst die overeenkomt met de eerste vastgelegde groep. match[n] zou de waarde van de n-de vastgelegde groep.

Matches .exec() met .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 + "'");
}

Verwachte resultaten

'a' gevonden, volgende exec begint bij index '2'
'a' gevonden, volgende exec begint bij index '5'
'a' gevonden, volgende exec begint bij index '8'

Controleer of tekenreeks patroon bevat met .test ()

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

De test voert een zoekopdracht uit om te zien of een reguliere expressie overeenkomt met een tekenreeks. De reguliere expressie [az]+ zoekt naar een of meer kleine letters. Omdat het patroon overeenkomt met de tekenreeks, wordt "match bestaat" vastgelegd in de console.

RegExp gebruiken met tekenreeksen

Het String-object heeft de volgende methoden die reguliere expressies als argumenten accepteren.

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

Overeenkomen met RegExp

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

Verwachte resultaten

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

Vervangen door RegExp

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

Verwachte resultaten

strfoog

Splitsen met RegExp

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

Verwachte resultaten

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

Zoeken met RegExp

.search() retourneert de index waarbij een overeenkomst wordt gevonden of -1.

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

Verwachte resultaten

3
-1

Stringovereenkomst vervangen door een callback-functie

String#replace kan een functie als tweede argument hebben, zodat u een vervanging kunt bieden op basis van enige logica.

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

Eén regel sjabloonbibliotheek

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-groepen

JavaScript ondersteunt verschillende soorten groepen in de reguliere expressies, vastleggroepen , niet-vastleggroepen en vooruitzichten . Momenteel is er geen ondersteuning achteraf .

Vastleggen

Soms is de gewenste match afhankelijk van de context. Dit betekent dat een eenvoudige RegExp het stuk van de String dat van belang is, zal over-vinden, dus de oplossing is om een capture-groep (pattern) . Naar de vastgelegde gegevens kan vervolgens worden verwezen als ...

• Stringvervanging "$n" waarbij n de n de vastleggroep is (beginnend bij 1 )
• Het nde argument in een callback-functie
• Als de RegExp niet is gemarkeerd g , het n + 1 e item in een geretourneerde str.match array
• Als de RegExp is gemarkeerd als g , verwijdert str.match vastleggingen, gebruik re.exec plaats daarvan re.exec

Stel dat er een tekenreeks is waarbij alle + tekens moeten worden vervangen door een spatie, maar alleen als ze een letterteken volgen. Dit betekent dat een eenvoudige overeenkomst dat letterteken zou bevatten en ook zou worden verwijderd. Het vastleggen is de oplossing, omdat de overeenkomende letter kan worden bewaard.

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"

Non-Capture

Met behulp van het formulier (?:pattern) werken deze op een vergelijkbare manier om groepen vast te leggen, behalve dat ze de inhoud van de groep na de wedstrijd niet opslaan.

Ze kunnen met name handig zijn als er andere gegevens worden vastgelegd waarvan u de indices niet wilt verplaatsen, maar wat geavanceerde patroonaanpassingen moet uitvoeren, zoals een OK

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

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

Kijk vooruit

Als de gewenste match afhankelijk is van iets dat erop volgt, in plaats van dat te matchen en vast te leggen, is het mogelijk om vooruit te kijken om het te testen, maar het niet in de match op te nemen. Een positieve vooruitblik heeft de vorm (?=pattern) , een negatieve vooruitblik (waarbij de uitdrukkingsovereenkomst alleen gebeurt als het vooruitkijkpatroon niet overeenkomt) heeft de vorm (?!pattern)

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

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

Regex.exec () gebruiken met regex tussen haakjes om overeenkomsten van een tekenreeks te extraheren

Soms wilt u de string niet gewoon vervangen of verwijderen. Soms wilt u overeenkomsten extraheren en verwerken. Hier een voorbeeld van hoe je wedstrijden manipuleert.

Wat is een match? Wanneer een compatibele substring wordt gevonden voor de hele regex in de tekenreeks, produceert de opdracht exec een overeenkomst. Een match is een array die bestaat uit eerst de hele deelreeks die overeenkomt en alle haakjes in de match.

Stel je een HTML-string voor:

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

U wilt uitpakken en je krijgt alle links in een a tag. In eerste instantie, hier de regex die je schrijft:

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

Maar stel je nu voor dat je de href en het anchor van elke link wilt. En jij wilt het samen. Je kunt eenvoudig een nieuwe regex toevoegen voor elke wedstrijd OF je kunt haakjes gebruiken:

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 => ([^<]*)
    });
}

Aan het einde van de lus hebt u een reeks koppelingen met anchor en href en u kunt deze gebruiken om markdown te schrijven, bijvoorbeeld:

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

Om verder te gaan :

• Geneste haakjes