Regular Expressions
Sostituzioni con espressioni regolari

Parametri

Nozioni di base sulla sostituzione

Uno dei modi più comuni e utili per sostituire il testo con espressioni regolari è utilizzando i gruppi di acquisizione .
O anche un Named Capture Group , come riferimento per memorizzare o sostituire i dati.

Ci sono due termini abbastanza simili nei documenti di regex, quindi potrebbe essere importante non mescolare mai le sostituzioni (es. $1 ) con Backreferences (cioè \1 ). I termini di sostituzione sono utilizzati in un testo sostitutivo; Backreferences, nell'espressione pura di Regex. Anche se alcuni linguaggi di programmazione accettano entrambi per le sostituzioni, non è incoraggiante.

Diciamo che abbiamo questo regex: /hello(\s+)world/i . Ogni volta che si fa riferimento al $number (in questo caso, $1 ), gli spazi bianchi corrispondenti a \s+ saranno invece sostituiti.
Lo stesso risultato sarà esposto con la regex: /hello(?<spaces>\s+)world/i . E dato che qui abbiamo un gruppo con nome, possiamo anche usare ${spaces} .

In questo stesso esempio, possiamo anche usare $0 o $& ( Nota: $& può essere usato come $+ invece, il che significa recuperare il gruppo LAST in altri motori regex), a seconda del gusto regex con cui stai lavorando, per ottenere l'intero testo abbinato. (es. $& restituirà hEllo woRld per la stringa: hEllo woRld of Regex! )

---

Dai un'occhiata a questo semplice esempio di sostituzione usando la citazione adattata di John Lennon usando il $number e la sintassi ${name} :

Esempio di gruppo di acquisizione semplice:

Esempio di gruppo di acquisizione con nome:

Sostituzione avanzata

Alcuni linguaggi di programmazione hanno le proprie peculiarità del Regex, ad esempio, il termine $+ (in C #, Perl, VB ecc.) Che sostituisce il testo corrispondente all'ultimo gruppo catturato.

Esempio:

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.

_{Esempio dalla rete di sviluppatori di Microsoft Official ^[1]}

---

Altri termini di sostituzione rari sono $` e $' :

$` = Sostituisce le corrispondenze con il testo prima della stringa corrispondente
$' = Sostituisce le corrispondenze con il testo dopo la stringa corrispondente

A causa di questo fatto, queste stringhe di sostituzione dovrebbero fare il loro lavoro in questo modo:

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

Ecco un esempio di queste sostituzioni che lavorano su un pezzo di 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"

---

C'è anche il termine $_ che recupera invece l'intero testo abbinato:

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

Convertire questo in VB ci darebbe questo:

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

_{Esempio dalla rete di sviluppatori di Microsoft Official ^[2]}

---

E l'ultimo ma non meno importante termine di sostituzione è $$ , che tradotto in un'espressione regolare è lo stesso di \$ (Una versione di escape del valore letterale $ ).

Se si desidera abbinare una stringa come questa: USD: $3.99 per esempio, e si desidera memorizzare il 3.99 , ma sostituirlo come $3.99 con una sola espressione regolare, è possibile utilizzare:

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

Se vuoi testare questo con Javascript, puoi usare il codice:

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

---

Riferimenti

[1]: Sostituendo il gruppo Ultimo catturato
[2]: Sostituzione dell'intera stringa di input