Regular Expressions
Podstawienia wyrażeniami regularnymi

Parametry

Podstawy podstawienia

Jednym z najczęstszych i najbardziej przydatnych sposobów zastąpienia tekstu wyrażeniem regularnym jest użycie grup przechwytywania .
Lub nawet Named Capture Group , jako odniesienie do przechowywania lub wymiany danych.

W dokumentach regex istnieją dwa podobne terminy, więc może być ważne, aby nigdy nie mieszać podstawień (tj. $1 ) z odwołaniami wstecznymi (tj. \1 ). Warunki zamiany są używane w tekście zastępczym; Odwołania wsteczne, w czystym wyrażeniu Regex. Chociaż niektóre języki programowania akceptują oba zamienniki, nie jest zachęcające.

Powiedzmy, że mamy to wyrażenie regularne: /hello(\s+)world/i . Ilekroć przywołuje się $number (w tym przypadku $1 ), białe znaki dopasowane przez \s+ zostaną zastąpione.
Ten sam wynik zostanie ujawniony za pomocą wyrażenia regularnego: /hello(?<spaces>\s+)world/i . Ponieważ mamy tutaj nazwaną grupę, możemy również użyć ${spaces} .

W tym samym przykładzie możemy również użyć $0 lub $& ( Uwaga: $& może być zamiast tego użyte jako $+ , co oznacza, że można odzyskać OSTATNĄ grupę przechwytywania w innych silnikach wyrażeń regularnych), w zależności od smaku wyrażenia regularnego, z którym pracujesz, aby uzyskać cały dopasowany tekst. (tzn. $& zwróci hEllo woRld dla ciągu: hEllo woRld of Regex! )

---

Spójrz na ten prosty przykład podstawienia z wykorzystaniem dostosowanego cytatu Johna Lennona, używając składni $number i składni ${name} :

Prosty przykład grupy przechwytywania:

Przykład nazwanej grupy przechwytywania:

Zaawansowana wymiana

Niektóre języki programowania mają swoje osobliwości Regex, na przykład $+ term (w C #, Perl, VB itp.), Który zastępuje dopasowany tekst do ostatniej przechwyconej grupy.

Przykład:

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.

_{Przykład z sieci programistów Microsoft Official ^[1]}

---

Inne rzadkie warunki zastępowania to $` i $' :

$` = Zamienia dopasowania do tekstu przed pasującym ciągiem
$' = Zamienia dopasowania do tekstu po dopasowanym ciągu

Z tego powodu ciągi zastępujące powinny wykonywać swoją pracę w następujący sposób:

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

Oto przykład tych podstawień działających na kawałku 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"

---

Istnieje również termin $_ który zamiast tego pobiera cały dopasowany tekst:

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

Konwersja tego na VB dałaby nam to:

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

_{Przykład z sieci programistów Microsoft Official ^[2]}

---

Ostatnim, ale nie mniej ważnym terminem podstawienia jest $$ , które przetłumaczone na wyrażenie regularne byłoby takie samo jak \$ (uciekająca wersja dosłownego $ ).

Jeśli chcesz dopasować ciąg taki jak na przykład: USD: $3.99 i chcesz zapisać 3.99 , ale zastąp go jako $3.99 tylko jednym wyrażeniem regularnym, możesz użyć:

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

Jeśli chcesz to przetestować za pomocą Javascript, możesz użyć kodu:

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

---

Bibliografia

[1]: Zastępowanie ostatniej schwytanej grupy
[2]: Podstawianie całego ciągu wejściowego