Sostituzioni nelle espressioni regolari
Le sostituzioni sono elementi di linguaggio riconosciuti solo all'interno dei criteri di sostituzione. Utilizzano un modello di espressione regolare per definire in tutto o in parte il testo che sostituirà il testo corrispondente nella stringa di input. Il criterio di sostituzione può essere costituito da una o più sostituzioni insieme a caratteri letterali. I criteri di sostituzione vengono forniti agli overload del metodo Regex.Replace che dispongono di un parametro replacement e al metodo Match.Result . I metodi sostituiscono il criterio di ricerca con il criterio definito dal parametro replacement .
.NET definisce gli elementi di sostituzione elencati nella tabella riportata di seguito.
| Sostituzione | Descrizione |
|---|---|
| $ number | Include nella stringa di sostituzione l'ultima sottostringa corrispondente al gruppo di acquisizione identificato da numero dove numero è un valore decimale. Per ulteriori informazioni, vedere Sostituzione di un gruppo numerato. |
| ${ nome } | Include nella stringa di sostituzione l'ultima sottostringa corrispondente al gruppo denominato definito da (?<nome> ) . Per ulteriori informazioni, vedere Sostituzione di un gruppo denominato. |
| $$ | Include un solo simbolo letterale "$" nella stringa di sostituzione. Per ulteriori informazioni, vedere Sostituzione di un simbolo "$". |
| $& | Include una copia dell'intera corrispondenza nella stringa di sostituzione. Per ulteriori informazioni, vedere Sostituzione dell'intera corrispondenza. |
| $` | Include nella stringa di sostituzione tutto il testo della stringa di input precedente alla corrispondenza. Per ulteriori informazioni, vedere Sostituzione del testo prima della corrispondenza. |
| $' | Include nella stringa di sostituzione tutto il testo della stringa di input successivo alla corrispondenza. Per ulteriori informazioni, vedere Sostituzione del testo dopo la corrispondenza. |
| $+ | Include nella stringa di sostituzione l'ultimo gruppo acquisito. Per ulteriori informazioni, vedere Sostituzione dell'ultimo gruppo acquisito. |
| $_ | Include l'intera stringa di input nella stringa di sostituzione. Per ulteriori informazioni, vedere Sostituzione dell'intera stringa di input. |
Elementi di sostituzione e criteri di sostituzione
Le sostituzioni sono gli unici costrutti speciali riconosciuti in un criterio di sostituzione. Nessuno degli altri elementi del linguaggio delle espressioni regolari, compresi i caratteri di escape e il punto (.), che corrispondono a qualsiasi carattere, è supportato. Analogamente, gli elementi del linguaggio di sostituzione sono riconosciuti solo nei criteri di sostituzione e non sono mai validi nei modelli di espressioni regolari.
L'unico carattere che può essere utilizzato in un modello di espressione regolare o in una sostituzione è il carattere $ , anche se presenta un significato diverso in ogni contesto. In un modello di espressione regolare $ è un ancoraggio che corrisponde al termine della stringa. In un criterio di sostituzione, $ indica l'inizio di una sostituzione.
Nota
Per una funzionalità simile a un criterio di sostituzione all'interno di un'espressione regolare, utilizzare un backreference. Per ulteriori informazioni sui backreference, vedere Costrutti di backreference.
Sostituzione di un gruppo numerato
L'elemento di linguaggio $numero include l'ultima sottostringa corrispondente al gruppo di acquisizione numero nella stringa di sostituzione, dove numero è l'indice del gruppo di acquisizione. Ad esempio, il criterio di sostituzione $1 indica che la sottostringa corrispondente deve essere sostituita dal primo gruppo acquisito. Per altre informazioni sui gruppi di acquisizione numerati, vedere Grouping Constructs.
Tutte le cifre che seguono $ vengono interpretate come appartenenti al gruppo numero . Se questa non è la propria intenzione, è possibile sostituire un gruppo denominato invece. Ad esempio, è possibile utilizzare la stringa di sostituzione ${1}1 anziché $11 per definire la stringa di sostituzione come la validità del gruppo innanzitutto acquisito con il numero "1 ". Per ulteriori informazioni, vedere Sostituzione di un gruppo denominato.
I gruppi di acquisizione a cui non sono stati assegnati nomi in modo esplicito tramite la sintassi (?<nome>) vengono numerati da sinistra verso destra a partire da uno. I gruppi denominati sono anche numerati da sinistra a destra, a partire dall'indice dell'ultimo gruppo senza nome più uno. Ad esempio, nell'espressione regolare (\w)(?<digit>\d) l'indice del gruppo denominato digit è 2.
Se numero non specifica un gruppo di acquisizione valido definito nel criterio di espressione regolare, $numero viene interpretato come una sequenza di caratteri letterali usata per sostituire ogni corrispondenza.
Nell'esempio seguente viene usata la sostituzione $numero per rimuovere il simbolo di valuta da un valore decimale. Rimuove i simboli di valuta trovati all'inizio o alla fine di un valore valutario e riconosce i due separatori decimali più comuni ("." e ",").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "$1";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "$1"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
Il criterio di ricerca di espressioni regolari \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\p{Sc}* |
Trovare la corrispondenza con zero o più caratteri di simboli valutari. |
\s? |
Trova la corrispondenza di uno o nessuno spazio vuoto. |
\d+ |
Trova la corrispondenza con una o più cifre decimali. |
[.,]? |
Trova la corrispondenza con zero o con un punto o una virgola. |
\d* |
Ricerca la corrispondenza di zero o di più cifre decimali. |
(\s?\d+[.,]?\d*) |
Corrisponde a uno spazio vuoto seguito da una o più cifre decimali, seguite da zero o un punto o una virgola, seguita da zero o più cifre decimali. Equivale al primo gruppo di acquisizione. Poiché il criterio di sostituzione è $1, la chiamata al metodo Regex.Replace sostituisce la sottostringa corrispondente intera con questo gruppo acquisito. |
Sostituzione di un gruppo denominato
L'elemento di linguaggio ${nome} sostituisce l'ultima sottostringa corrispondente al gruppo di acquisizione nome , dove nome è il nome di un gruppo di acquisizione definito dall'elemento di linguaggio (?<nome>) . Per altre informazioni sui gruppi di acquisizione denominati, vedere Grouping Constructs.
Se nome non specifica un gruppo di acquisizione denominato valido definito nel criterio di espressione regolare ma è costituito dalle cifre, ${nome} viene interpretato come un gruppo numerato.
Se nome non specifica un gruppo di acquisizione denominato valido o un gruppo di acquisizione numerato valido definito nel criterio di espressione regolare, ${nome} viene interpretato come una sequenza di caratteri letterali usata per sostituire ogni corrispondenza.
Nell'esempio seguente viene usata la sostituzione ${nome} per rimuovere il simbolo di valuta da un valore decimale. Rimuove i simboli di valuta trovati all'inizio o alla fine di un valore valutario e riconosce i due separatori decimali più comuni ("." e ",").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "${amount}";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "${amount}"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
Il criterio di ricerca di espressioni regolari \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\p{Sc}* |
Trovare la corrispondenza con zero o più caratteri di simboli valutari. |
\s? |
Trova la corrispondenza di uno o nessuno spazio vuoto. |
\d+ |
Trova la corrispondenza con una o più cifre decimali. |
[.,]? |
Trova la corrispondenza con zero o con un punto o una virgola. |
\d* |
Ricerca la corrispondenza di zero o di più cifre decimali. |
(?<amount>\s?\d[.,]?\d*) |
Corrisponde a uno spazio vuoto seguito da una o più cifre decimali, seguite da zero o un punto o una virgola, seguita da zero o più cifre decimali. Questo è il gruppo di acquisizione denominato amount. Poiché il criterio di sostituzione è ${amount}, la chiamata al metodo Regex.Replace sostituisce la sottostringa corrispondente intera con questo gruppo acquisito. |
Sostituzione di un carattere "$"
La sostituzione $$ inserisce un carattere "$" letterale nella stringa sostituita.
Nell'esempio riportato di seguito viene utilizzato l'oggetto NumberFormatInfo per determinare il simbolo di valuta delle impostazioni cultura correnti e la relativa posizione in una stringa di valuta. Compila quindi in modo dinamico sia un modello di espressione regolare sia un criterio di sostituzione. Se l'esempio viene eseguito in un computer le cui impostazioni cultura correnti sono en-US, tale computer genera il criterio di espressione regolare \b(\d+)(\.(\d+))? e il criterio di sostituzione $$ $1$2. Il criterio di sostituzione sostituisce il testo corrispondente con un simbolo di valuta e uno spazio seguiti dal primo e dal secondo gruppo acquisito.
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Define array of decimal values.
string[] values= { "16.35", "19.72", "1234", "0.99"};
// Determine whether currency precedes (True) or follows (False) number.
bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
// Get decimal separator.
string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
// Get currency symbol.
string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
// If symbol is a "$", add an extra "$".
if (symbol == "$") symbol = "$$";
// Define regular expression pattern and replacement string.
string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?";
string replacement = "$1$2";
replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
foreach (string value in values)
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
}
}
// The example displays the following output:
// 16.35 --> $ 16.35
// 19.72 --> $ 19.72
// 1234 --> $ 1234
// 0.99 --> $ 0.99
Imports System.Globalization
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Define array of decimal values.
Dim values() As String = {"16.35", "19.72", "1234", "0.99"}
' Determine whether currency precedes (True) or follows (False) number.
Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
' Get decimal separator.
Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
' Get currency symbol.
Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
' If symbol is a "$", add an extra "$".
If symbol = "$" Then symbol = "$$"
' Define regular expression pattern and replacement string.
Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?"
Dim replacement As String = "$1$2"
replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
For Each value In values
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' 16.35 --> $ 16.35
' 19.72 --> $ 19.72
' 1234 --> $ 1234
' 0.99 --> $ 0.99
Il criterio di ricerca di espressioni regolari \b(\d+)(\.(\d+))? è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\b |
Inizia la corrispondenza all'inizio di un confine di parola. |
(\d+) |
Trova la corrispondenza con una o più cifre decimali. Equivale al primo gruppo di acquisizione. |
\. |
Trovare la corrispondenza con un punto (ovvero il separatore decimale). |
(\d+) |
Trova la corrispondenza con una o più cifre decimali. Equivale al terzo gruppo di acquisizione. |
(\.(\d+))? |
Trovare la corrispondenza con zero o una occorrenza di un punto seguito da una o più cifre decimali. Equivale al secondo gruppo di acquisizione. |
Sostituzione dell'intera corrispondenza
La sostituzione $& include l'intera corrispondenza nella stringa di sostituzione. Spesso viene utilizzata per aggiungere una sottostringa all'inizio o alla fine della stringa corrispondente. Ad esempio, il criterio di sostituzione ($&) aggiunge parentesi all'inizio e alla fine di ogni corrispondenza. Se non esiste alcuna corrispondenza, la sostituzione $& non ha alcun effetto.
Nell'esempio seguente viene utilizzata la sostituzione $& per aggiungere virgolette all'inizio e alla fine dei titoli di libro archiviati in una matrice di stringhe.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^(\w+\s?)+$";
string[] titles = { "A Tale of Two Cities",
"The Hound of the Baskervilles",
"The Protestant Ethic and the Spirit of Capitalism",
"The Origin of Species" };
string replacement = "\"$&\"";
foreach (string title in titles)
Console.WriteLine(Regex.Replace(title, pattern, replacement));
}
}
// The example displays the following output:
// "A Tale of Two Cities"
// "The Hound of the Baskervilles"
// "The Protestant Ethic and the Spirit of Capitalism"
// "The Origin of Species"
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^(\w+\s?)+$"
Dim titles() As String = {"A Tale of Two Cities", _
"The Hound of the Baskervilles", _
"The Protestant Ethic and the Spirit of Capitalism", _
"The Origin of Species"}
Dim replacement As String = """$&"""
For Each title As String In titles
Console.WriteLine(Regex.Replace(title, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' "A Tale of Two Cities"
' "The Hound of the Baskervilles"
' "The Protestant Ethic and the Spirit of Capitalism"
' "The Origin of Species"
Il criterio di ricerca di espressioni regolari ^(\w+\s?)+$ è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
^ |
Inizia la corrispondenza all'inizio della stringa di input. |
(\w+\s?)+ |
Ottiene una o più volte la corrispondenza con il modello di uno o più caratteri alfanumerici seguiti da zero o da uno spazio vuoto. |
$ |
Trova la corrispondenza con la fine della stringa di input. |
Il criterio di sostituzione "$&" aggiunge le virgolette letterali all'inizio e alla fine di ogni corrispondenza.
Sostituzione del testo prima della corrispondenza
La sostituzione $` sostituisce la stringa corrispondente con l'intera stringa di input prima della corrispondenza. Ovvero, duplica la stringa di input fino alla corrispondenza e rimuove il testo corrispondente. Qualsiasi testo che segue il testo corrispondente resta invariato nella stringa di risultato. Se esistono più corrispondenze in una stringa di input, il testo di sostituzione viene derivato dalla stringa di input originale anziché dalla stringa in cui il testo è stato sostituito dalle corrispondenze precedenti. (Nell'esempio viene illustrata una situazione di questo tipo.) Se non esiste alcuna corrispondenza, la sostituzione $` non ha alcun effetto.
Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per trovare la corrispondenza con una sequenza di una o più cifre decimali nella stringa di input. La stringa di sostituzione $` sostituisce queste cifre con il testo che precede la corrispondenza.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$`";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$`"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
In questo esempio, la stringa di input "aa1bb2cc3dd4ee5" contiene cinque corrispondenze. La tabella seguente illustra come la sostituzione $` fa in modo che il motore delle espressioni regolari sostituisca ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.
| Corrispondenza | Position | Stringa prima della corrispondenza | Stringa di risultato |
|---|---|---|---|
| 1 | 2 | aa | aaaabb2cc3dd4ee5 |
| 2 | 5 | aa1bb | aaaabbaa1bbcc3dd4ee5 |
| 3 | 8 | aa1bb2cc | aaaabbaa1bbccaa1bb2ccdd4ee5 |
| 4 | 11 | aa1bb2cc3dd | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee |
Sostituzione del testo dopo la corrispondenza
La sostituzione $' sostituisce la stringa corrispondente con l'intera stringa di input dopo la corrispondenza. Ovvero, duplica la stringa di input dopo la corrispondenza e rimuove il testo corrispondente. Qualsiasi testo che precede il testo corrispondente resta invariato nella stringa di risultato. Se non esiste alcuna corrispondenza, la sostituzione $' non ha alcun effetto.
Nell'esempio seguente viene usato il criterio di espressione regolare \d+ per trovare la corrispondenza con una sequenza di una o più cifre decimali nella stringa di input. La stringa di sostituzione $' sostituisce queste cifre con il testo che segue la corrispondenza.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$'";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$'"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
In questo esempio, la stringa di input "aa1bb2cc3dd4ee5" contiene cinque corrispondenze. La tabella seguente illustra come la sostituzione $' fa in modo che il motore delle espressioni regolari sostituisca ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.
| Corrispondenza | Position | Stringa dopo la corrispondenza | Stringa di risultato |
|---|---|---|---|
| 1 | 2 | bb2cc3dd4ee5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | cc3dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5 |
| 3 | 8 | dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5 |
| 4 | 11 | ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Sostituzione dell'ultimo gruppo acquisito
La sostituzione $+ sostituisce la stringa corrispondente con l'ultimo gruppo acquisito. Se non esistono gruppi acquisiti o se il valore dell'ultimo gruppo acquisito è String.Empty, la sostituzione $+ non ha effetto.
L'esempio seguente identifica le parole duplicate in una stringa e utilizza la sostituzione $+ per sostituirle con una sola occorrenza della parola. L'opzione RegexOptions.IgnoreCase viene utilizzata per garantire che le parole che differiscono solo in termini di maiuscole e minuscole siano considerate come parole duplicate.
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.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s\1\b"
Dim substitution As String = "$+"
Dim input As String = "The the dog jumped over the fence fence."
Console.WriteLine(Regex.Replace(input, pattern, substitution, _
RegexOptions.IgnoreCase))
End Sub
End Module
' The example displays the following output:
' The dog jumped over the fence.
Il criterio di ricerca di espressioni regolari \b(\w+)\s\1\b è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\b |
Inizia la corrispondenza sul confine di parola. |
(\w+) |
Trova la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione. |
\s |
Trova la corrispondenza con uno spazio vuoto. |
\1 |
Trovare la corrispondenza con il primo gruppo acquisito. |
\b |
Termina la corrispondenza sul confine di parola. |
Sostituzione dell'intera stringa di input
La sostituzione $_ sostituisce la stringa corrispondente con l'intera stringa di input. Ovvero, rimuove il testo corrispondente e lo sostituisce con la stringa intera, compreso il testo corrispondente.
Nell'esempio seguente vengono corrisposte una o più cifre decimali della stringa di input. Utilizza la sostituzione $_ per sostituirli con l'intera stringa di input.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "ABC123DEF456";
string pattern = @"\d+";
string substitution = "$_";
Console.WriteLine("Original string: {0}", input);
Console.WriteLine("String with substitution: {0}",
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Original string: ABC123DEF456
// String with substitution: ABCABC123DEF456DEFABC123DEF456
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
In questo esempio, la stringa di input "ABC123DEF456" contiene due corrispondenze. La tabella seguente illustra come la sostituzione $_ fa in modo che il motore delle espressioni regolari sostituisca ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.
| Corrispondenza | Position | Corrispondenza | Stringa di risultato |
|---|---|---|---|
| 1 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEFABC123DEF456 |
