Regular Expressions
Substitutioner med regelbundna uttryck

parametrar

Grunderna i substitution

Ett av de vanligaste och användbara sätten att ersätta text med regex är med Capture Groups .
Eller till och med en Named Capture Group , som en referens till att lagra eller ersätta data.

Det finns två termer som ser ganska lika ut i regexs dokument, så det kan vara viktigt att aldrig blanda in substitutioner (dvs. $1 ) med Backreferences (dvs. \1 ). Substitutionstermer används i en ersättande text; Återreferenser, i det rena Regex-uttrycket. Även om vissa programmeringsspråk accepterar båda för ersättningar är det inte uppmuntrande.

Låt oss säga att vi har denna regex: /hello(\s+)world/i . Närhelst $number hänvisas (i detta fall, $1 ) kommer de blanksteg som matchas med \s+ att ersättas.
Samma resultat kommer att exponeras med regex: /hello(?<spaces>\s+)world/i . Och eftersom vi har en namngiven grupp här, kan vi också använda ${spaces} .

I samma exempel kan vi också använda $0 eller $& ( Observera: $& kan användas som $+ istället, vilket betyder att hämta den sista fångstgruppen i andra regex-motorer), beroende på regex-smaken du arbetar med, för att få hela matchad text. (dvs $& ska returnera hEllo woRld för strängen: hEllo woRld of Regex! )

---

Ta en titt på detta enkla exempel på substitution med hjälp av John Lennons anpassade offert genom att använda $number och ${name} -syntaxen:

Enkelt fångargruppsexempel:

Namngivet fångstgruppsexempel:

Avancerad ersättning

Vissa programmeringsspråk har sina egna Regex-särdrag, till exempel $+ -termen (i C #, Perl, VB etc.) som ersätter den matchade texten till den senaste grupp som fångats.

Exempel:

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.

_{Exempel från Microsoft Officials utvecklarnätverk ^[1]}

---

Andra sällsynta ersättningsvillkor är $` och $' :

$` = Ersätter matchningar till texten före matchande sträng
$' = Ersätter matchningar till texten efter matchningssträngen

På grund av detta faktum bör dessa ersättningssträngar göra sitt arbete så här:

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

Här är ett exempel på dessa ersättningar som arbetar med ett 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"

---

Det finns också termen $_ som hämtar hela den matchade texten istället:

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

Att konvertera detta till VB skulle ge oss detta:

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

_{Exempel från Microsoft Officials utvecklarnätverk ^[2]}

---

Och den sista men inte minst substitutionsbeteckningen är $$ , som översatt till ett regex-uttryck skulle vara detsamma som \$ (En rymd version av det bokstavliga $ ).

Om du vill matcha en sträng som denna: USD: $3.99 till exempel och vill lagra 3.99 , men ersätta den som $3.99 med bara en regex, kan du använda:

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

Om du vill testa detta med Javascript kan du använda koden:

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

---

referenser

[1]: Ersätta den sist fångade gruppen
[2]: Ersätta hela ingångssträngen