Regular Expressions
Vervangingen met reguliere expressies

parameters

Basisprincipes van vervanging

Een van de meest gebruikelijke en nuttige manieren om tekst te vervangen door regex is met Capture Groups .
Of zelfs een Named Capture Group , als referentie om de gegevens op te slaan of te vervangen.

Er zijn twee termen die redelijk op elkaar lijken in de documenten van regex, dus het kan belangrijk zijn om substituties (dwz $1 ) nooit te verwarren met Backreferences (dwz \1 ). Vervangende termen worden gebruikt in een vervangende tekst; Backreferences, in de pure Regex-expressie. Hoewel sommige programmeertalen beide voor vervangingen accepteren, is het niet bemoedigend.

Laten we zeggen dat we deze regex hebben: /hello(\s+)world/i . Wanneer naar $number wordt verwezen (in dit geval $1 ), worden in plaats daarvan de witruimten die overeenkomen met \s+ vervangen.
Hetzelfde resultaat wordt weergegeven met de regex: /hello(?<spaces>\s+)world/i . En omdat we hier een benoemde groep hebben, kunnen we ook ${spaces} .

In hetzelfde voorbeeld kunnen we ook $0 of $& ( Opmerking: $& kan in plaats daarvan worden gebruikt als $+ , wat betekent dat de LAATSTE opnamegroep in andere regex-engines wordt opgehaald), afhankelijk van de regex-smaak waarmee u werkt, om de hele overeenkomende tekst te krijgen. (dat wil zeggen $& retourneert hEllo woRld voor de tekenreeks: hEllo woRld of Regex! )

---

Bekijk dit eenvoudige voorbeeld van vervanging met behulp van het aangepaste citaat van John Lennon met behulp van het $number en de syntaxis ${name} :

Voorbeeld van een eenvoudige opnamegroep:

Voorbeeld van een vastgelegde groep:

Geavanceerde vervanging

Sommige programmeertalen hebben hun eigen Regex-eigenaardigheden, bijvoorbeeld de term $+ (in C #, Perl, VB etc.) die de overeenkomende tekst vervangt voor de laatst vastgelegde groep.

Voorbeeld:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s\1\b";
      string substitution = "$+";
      string input = "The the dog jumped over the fence fence.";
      Console.WriteLine(Regex.Replace(input, pattern, substitution, 
                        RegexOptions.IgnoreCase));
   }
}
// The example displays the following output:
//      The dog jumped over the fence.

_{Voorbeeld uit het ontwikkelaarsnetwerk van Microsoft Official ^[1]}

---

Andere zeldzame vervangingsvoorwaarden zijn $` en $' :

$` = Vervangt overeenkomsten met de tekst vóór de overeenkomende reeks
$' = Vervangt overeenkomsten naar de tekst na de overeenkomende string

Vanwege dit feit zouden deze vervangingsreeksen hun werk als volgt moeten doen:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$`"
Output: "part1part1part3" //Note that part2 was replaced with part1, due &` term
---------------------------------------------------------------------------------
Regex: /part2/
Input: "part1part2part3"
Replacement: "$'"
Output: "part1part3part3" //Note that part2 was replaced with part3, due &' term

Hier is een voorbeeld van deze vervangingen die werken met een stukje javascript:

var rgx = /middle/;
var text = "Your story must have a beginning, middle, and end"
console.log(text.replace(rgx, "$`")); 
//Logs: "Your story must have a beginning, Your story must have a beginning, , and end"
console.log(text.replace(rgx, "$'"))
//Logs: "Your story must have a beginning, , and end, and end"

---

Er is ook de term $_ die in plaats daarvan de hele overeenkomende tekst ophaalt:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$_"
Output: "part1part1part2part3part3" //Note that part2 was replaced with part1part2part3,
                                                                         // due $_ term

Dit omzetten naar VB zou ons dit geven:

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ABC123DEF456"
      Dim pattern As String = "\d+"
      Dim substitution As String = "$_"
      Console.WriteLine("Original string:          {0}", input)
      Console.WriteLine("String with substitution: {0}", _
                        Regex.Replace(input, pattern, substitution))      
   End Sub
End Module
' The example displays the following output:
'       Original string:          ABC123DEF456
'       String with substitution: ABCABC123DEF456DEFABC123DEF456

_{Voorbeeld uit het ontwikkelaarsnetwerk van Microsoft Official ^[2]}

---

En de laatste maar niet minder belangrijke vervangingsterm is $$ , wat vertaald naar een regex-expressie hetzelfde zou zijn als \$ (een ontsnapte versie van de letterlijke $ ).

Als je een string zoals deze wilt matchen: USD: $3.99 bijvoorbeeld, en de 3.99 wilt opslaan, maar deze als $3.99 wilt vervangen door slechts één regex, kun je het volgende gebruiken:

Regex: /USD:\s+\$([\d.]+)/
Input: "USD: $3.99"
Replacement: "$$$1"
To Store: "$1"
Output: "$3.99"
Stored: "3.99"

Als u dit met Javascript wilt testen, kunt u de code gebruiken:

var rgx = /USD:\s+\$([\d.]+)/;
var text = "USD: $3.99";
var stored = parseFloat(rgx.exec(text)[1]);
console.log(stored); //Logs 3.99
console.log(text.replace(rgx, "$$$1")); //Logs $3.99

---

Referenties

[1]: Vervanging van de laatst vastgelegde groep
[2]: De volledige invoertekenreeks vervangen