Condividi tramite

Sostituzioni nelle espressioni regolari

Le sostituzioni sono elementi del linguaggio riconosciuti solo all'interno dei modelli di sostituzione. Usano un criterio di espressione regolare per definire tutto o parte del testo che sostituisce il testo corrispondente nella stringa di input. Il modello di sostituzione può essere costituito da una o più sostituzioni insieme ai caratteri letterali. I modelli di sostituzione vengono forniti agli overloads del metodo Regex.Replace che hanno un parametro replacement e al metodo Match.Result. I metodi sostituiscono il modello corrispondente con il modello definito dal replacement parametro .

.NET definisce gli elementi di sostituzione elencati nella tabella seguente.

Sostituzione Descrizione
$ numero Include l'ultima sottostringa corrispondente al gruppo di acquisizione identificato dal numero, dove number è un valore decimale, nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione di un gruppo numerato.
${ name } Include l'ultima sottostringa corrispondente al gruppo denominato designato per (?<nome> ) nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione di un gruppo denominato.
$$ Include un singolo valore letterale "$" nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione di un simbolo "$".
$& Includi una copia dell'intera corrispondenza nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione dell'intera corrispondenza.
$` Include tutto il testo della stringa di input prima della corrispondenza nella stringa di sostituzione. Per ulteriori informazioni, vedere Sostituzione del testo precedente alla corrispondenza.
$' Includere tutto il testo della stringa di input dopo la corrispondenza nella stringa da sostituire. Per altre informazioni, vedere Sostituzione del testo dopo la corrispondenza.
$+ Include l'ultimo gruppo acquisito nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione dell'ultimo gruppo acquisito.
$_ Include l'intera stringa di input nella stringa di sostituzione. Per altre informazioni, vedere Sostituzione dell'intera stringa di input.

Elementi di sostituzione e modelli di sostituzione

Gli unici costrutti speciali riconosciuti in un modello di sostituzione sono le sostituzioni. Nessuno degli altri elementi del linguaggio delle espressioni regolari, inclusi i caratteri di escape e il punto (.) che corrisponde a qualsiasi carattere, non è supportato. Analogamente, gli elementi del linguaggio di sostituzione vengono riconosciuti solo nei modelli di sostituzione e non sono mai validi nei modelli di espressione regolare.

L'unico carattere $ che può comparire sia in un modello di espressione regolare che in una sostituzione, sebbene abbia un significato diverso in ogni contesto. In un criterio di espressione regolare, $ è un ancoraggio che corrisponde alla fine della stringa. In un modello di sostituzione indica $ l'inizio di una sostituzione.

Annotazioni

Per funzionalità simili a un modello di sostituzione all'interno di un'espressione regolare, usare un "backreference". Per ulteriori informazioni sui riferimenti retroattivi, vedere Costrutti di riferimenti retroattivi.

Sostituzione di un gruppo numerato

L'elemento linguistico $number include l'ultima sottostringa corrispondente al gruppo di cattura number nella stringa di sostituzione, dove number è l'indice del gruppo di cattura. Ad esempio, il modello $1 di sostituzione indica che la sottostringa corrispondente deve essere sostituita dal primo gruppo acquisito. Per altre informazioni sui gruppi di acquisizione numerati, vedere Costrutti di raggruppamento.

Tutte le cifre che seguono $ vengono interpretate come appartenenti al gruppo di numeri . Se questo non è il tuo intento, puoi sostituire un gruppo nominato. Ad esempio, è possibile utilizzare la stringa di sostituzione ${1}1 invece di $11 per definire la stringa di sostituzione come il valore del primo gruppo acquisito insieme al numero "1". Per altre informazioni, vedere Sostituzione di un gruppo denominato.

I gruppi di acquisizione non assegnati in modo esplicito tramite la sintassi del (?<nome>) vengono numerati da sinistra a destra a partire da uno. I gruppi denominati vengono numerati anche da sinistra a destra, a partire da uno maggiore dell'indice dell'ultimo gruppo senza nome. Nell'espressione (\w)(?<digit>\d)regolare, ad esempio, l'indice del digit gruppo denominato è 2.

Se number non specifica un gruppo di acquisizione valido definito nel pattern di espressione regolare, $number viene interpretato come una sequenza di caratteri letterali utilizzata per sostituire ogni corrispondenza.

Nell'esempio seguente viene utilizzata la sostituzione dei $numeri per rimuovere il simbolo di valuta da un valore decimale. Rimuove i simboli di valuta trovati all'inizio o alla fine di un valore monetario 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 modello di espressioni regolari \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* è definito come mostrato nella tabella seguente.

Modello Descrizione
\p{Sc}* Trova la corrispondenza con zero o più caratteri di simbolo di valuta.
\s? Trova la corrispondenza di zero o uno spazi bianchi.
\d+ Trova la corrispondenza con una o più cifre decimali.
[.,]? Abbina zero o un punto o una virgola.
\d* Ricerca la corrispondenza di zero o di più cifre decimali.
(\s?\d+[.,]?\d*) Trova la corrispondenza con uno spazio vuoto seguito da una o più cifre decimali, seguite da zero o da un punto o una virgola, seguita da zero o più cifre decimali. Questo è il primo gruppo di cattura. Poiché il modello di sostituzione è $1, la chiamata al Regex.Replace metodo sostituisce l'intera sottostringa corrispondente con questo gruppo acquisito.

Sostituzione di un gruppo denominato

L'elemento del linguaggio ${name} sostituisce l'ultima sottostringa corrispondente al gruppo di acquisizione name, dove name è il nome di un gruppo di acquisizione definito dall'elemento del linguaggio (?<name>). Per altre informazioni sui gruppi di acquisizione denominati, vedere Costrutti di raggruppamento.

Se name non specifica un gruppo di acquisizione denominato valido definito nel modello di espressione regolare ma è costituito da cifre, ${il nome} viene interpretato come un gruppo numerato.

Se name non specifica né un gruppo di acquisizione denominato valido né un gruppo di acquisizione numerato valido definito nel modello di espressione regolare, ${name} viene interpretato come una sequenza di caratteri letterale usata per sostituire ogni corrispondenza.

Nell'esempio seguente viene utilizzata la sostituzione del ${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 monetario 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 modello di espressioni regolari \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* è definito come mostrato nella tabella seguente.

Modello Descrizione
\p{Sc}* Trova la corrispondenza con zero o più caratteri di simbolo di valuta.
\s? Trova la corrispondenza di zero o uno spazi bianchi.
\d+ Trova la corrispondenza con una o più cifre decimali.
[.,]? Abbina zero o un punto o una virgola.
\d* Ricerca la corrispondenza di zero o di più cifre decimali.
(?<amount>\s?\d[.,]?\d*) Trova la corrispondenza con uno spazio bianco, seguito da una o più cifre decimali, seguite da zero o da un punto o una virgola, seguite da zero o più cifre decimali. Si tratta del gruppo di acquisizione denominato amount. Poiché il modello di sostituzione è ${amount}, la chiamata al Regex.Replace metodo sostituisce l'intera sottostringa corrispondente con questo gruppo acquisito.

Sostituzione di un carattere "$"

La $$ sostituzione inserisce un carattere letterale "$" nella stringa sostituita.

Nell'esempio seguente viene utilizzato l'oggetto NumberFormatInfo per determinare il simbolo di valuta della cultura corrente e la sua posizione in una stringa di valuta. Compila quindi in modo dinamico sia un criterio di espressione regolare che un criterio di sostituzione. Se l'esempio viene eseguito su un computer la cui cultura attuale è en-US, genera il pattern di espressione regolare \b(\d+)(\.(\d+))? e il pattern di sostituzione $$ $1$2. Il modello di sostituzione sostituisce il testo corrispondente con un simbolo di valuta e uno spazio seguito dai primi e dai secondi gruppi acquisiti.

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($"{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 modello di espressioni regolari \b(\d+)(\.(\d+))? è definito come mostrato nella tabella seguente.

Modello Descrizione
\b Avviare la corrispondenza all'inizio di un limite di parola.
(\d+) Trova la corrispondenza con una o più cifre decimali. Questo è il primo gruppo di cattura.
\. Riconosci un punto (il separatore decimale).
(\d+) Trova la corrispondenza con una o più cifre decimali. Questo è il terzo gruppo di cattura.
(\.(\d+))? Trova la corrispondenza con zero o una occorrenza di un punto seguito da una o più cifre decimali. Questo è il secondo gruppo di cattura.

Sostituzione dell'intera corrispondenza

La $& sostituzione include l'intera corrispondenza nella stringa di sostituzione. Spesso viene usato per aggiungere una sottostringa all'inizio o alla fine della stringa corrispondente. Ad esempio, lo schema di sostituzione ($&) aggiunge parentesi all'inizio e alla fine di ogni occorrenza. 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 dei libri 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 modello di espressioni regolari ^(\w+\s?)+$ è definito come mostrato nella tabella seguente.

Modello Descrizione
^ Inizia la corrispondenza dall'inizio della stringa di input.
(\w+\s?)+ Trova la corrispondenza con il modello di uno o più caratteri di parola seguiti da zero o uno spazio bianco una o più volte.
$ Trova la corrispondenza con la fine della stringa di input.

Il modello di sostituzione "$&" aggiunge una virgoletta letterale 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. Vale a dire, duplica la stringa di input fino alla corrispondenza, rimuovendo il testo che corrisponde. Qualsiasi testo che segue il testo corrispondente rimane invariato nella stringa di risultato. Se sono presenti 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 da corrispondenze precedenti. L'esempio fornisce un'illustrazione. Se non esiste alcuna corrispondenza, la $` sostituzione non ha alcun effetto.

Nell'esempio seguente viene usato il criterio \d+ di espressione regolare per trovare una 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($"   {match.Value} at position {match.Index}");

      Console.WriteLine($"Input string:  {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 "aa1bb2cc3dd4ee5" di input contiene cinque corrispondenze. Nella tabella seguente è illustrato come la sostituzione tramite $` induca il motore delle espressioni regolari a sostituire ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.

Partita Posizione Stringa prima della corrispondenza Stringa di risultato
1 2 Aa aa aabb2cc3dd4ee5
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 il testo corrispondente eliminando il testo corrispondente. Qualsiasi testo che precede il testo corrispondente rimane invariato nella stringa di risultato. Se non esiste alcuna corrispondenza, la $' sostituzione non ha alcun effetto.

Nell'esempio seguente viene usato il criterio \d+ di espressione regolare per trovare una 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($"   {match.Value} at position {match.Index}");
      Console.WriteLine($"Input string:  {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 "aa1bb2cc3dd4ee5" di input contiene cinque corrispondenze. Nella tabella seguente è illustrato come la sostituzione tramite $' induca il motore delle espressioni regolari a sostituire ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.

Partita Posizione Stringa dopo l'abbinamento Stringa di risultato
1 2 bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5
2 5 cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
3 8 dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5 dd4ee5
4 11 ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5 ee5
5 14 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dde5ee

Sostituzione dell'ultimo gruppo catturato

La $+ sostituzione sostituisce la stringa corrispondente con l'ultimo gruppo acquisito. Se non sono presenti gruppi acquisiti o se il valore dell'ultimo gruppo acquisito è String.Empty, la $+ sostituzione non ha alcun effetto.

Nell'esempio seguente vengono identificate parole duplicate in una stringa e viene utilizzata la $+ sostituzione per sostituirle con una singola occorrenza della parola. L'opzione RegexOptions.IgnoreCase viene usata per garantire che le parole che differiscono nel caso, ma che altrimenti identiche siano considerate duplicati.

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 modello di espressioni regolari \b(\w+)\s\1\b è definito come mostrato nella tabella seguente.

Modello Descrizione
\b Inizia la corrispondenza al limite di una parola.
(\w+) Trova la corrispondenza di uno o più caratteri di parola. Questo è il primo gruppo di cattura.
\s Trova un carattere di spazio bianco.
\1 Abbina il primo gruppo acquisito.
\b Termina la partita al confine di una parola.

Sostituzione dell'intera stringa di input

La $_ sostituzione rimpiazza la stringa corrispondente con l'intera stringa di input. Ovvero rimuove il testo corrispondente e lo sostituisce con l'intera stringa, incluso il testo corrispondente.

L'esempio seguente corrisponde a una o più cifre decimali nella stringa di input. Usa 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:          {input}");
      Console.WriteLine($"String with substitution: {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 "ABC123DEF456" di input contiene due corrispondenze. Nella tabella seguente è illustrato come la sostituzione tramite $_ induca il motore delle espressioni regolari a sostituire ogni corrispondenza nella stringa di input. Il testo inserito viene visualizzato in grassetto nella colonna dei risultati.

Partita Posizione Partita Stringa di risultato
1 3 123 ABCABC123DEF456DEF456
2 5 456 ABCABC123DEF456DEFABC123DEF456

Vedere anche

  • Last updated on