Compartir a través de

Sustituciones

  • Artículo

Las sustituciones son elementos del lenguaje que se reconocen solo dentro de modelos de reemplazo. Usan un modelo de expresión regular para definir todo o parte del texto que reemplazará el texto coincidente en la cadena de entrada. El modelo del reemplazo puede estar compuesto de una o más substituciones junto con caracteres literales. Los modelos de reemplazo se proporcionan a las sobrecargas del método Regex.Replace que tiene un parámetro replacement y al método Match.Result. Los métodos reemplazan el modelo que coincide con el modelo que definen los parámetros replacement.

.NET Framework define los elementos de sustitución que se enumeran en la siguiente tabla.

Sustitución

Descripción

$number

Incluye la última subcadena emparejada por el grupo capturador que identifica number, donde number es un valor decimal, en la cadena de reemplazo. Para obtener más información, vea Sustitución de un grupo numerado.

${name}

Incluye la última subcadena emparejada por el grupo con nombre que designa (?<name> ) en la cadena de reemplazo. Para obtener más información, vea Sustitución de un grupo con nombre.

$$

Incluye un literal "$" único en la cadena de reemplazo. Para obtener más información, vea Sustitución de un símbolo "$".

$&

Incluye una copia de la coincidencia completa en la cadena de reemplazo. Para obtener más información, vea Sustitución de toda la coincidencia.

$`

Incluye todo el texto de la cadena de entrada delante de la coincidencia en la cadena de reemplazo. Para obtener más información, vea Sustitución del texto delante de la coincidencia.

$'

Incluye todo el texto de la cadena de entrada detrás de la coincidencia en la cadena de reemplazo. Para obtener más información, vea Sustitución del texto detrás de la coincidencia.

$+

Incluye el último grupo capturado en la cadena de reemplazo. Para obtener más información, vea Sustitución del último grupo capturado.

$_

Incluye la cadena de entrada completa en la cadena de reemplazo. Para obtener más información, vea Sustitución de toda la cadena de entrada.

Elementos de substitución y modelos del reemplazo

Las sustituciones son las únicas construcciones especiales reconocidas en un modelo de reemplazo. No se admite ninguno de los otros elementos del lenguaje de la expresión regular, incluidos los escapes de carácter y el punto (.), que coinciden con cualquier carácter. De igual forma, los elementos del lenguaje de sustitución se reconocen únicamente en modelos de reemplazo y nunca son válidos en modelos de expresiones regulares.

El único carácter que puede aparecer en un modelo de expresión regular o en una substitución es el carácter $, aunque tiene un significado diferente en cada contexto. En un modelo de expresión regular, $ es un delimitador que coincide con el final de la cadena. En un modelo del reemplazo, $ indica el principio de una substitución.

NotaNota

Para obtener una funcionalidad similar a un modelo de reemplazo dentro de una expresión regular, use una referencia inversa.Para obtener más información acerca de las referencias inversas, vea Construcciones de referencia inversa.

Sustituir un grupo numerado

El elemento del lenguaje $número incluye la última subcadena coincidente por el grupo de captura número en la cadena de reemplazo, donde número es el índice del grupo de captura. Por ejemplo, el modelo de reemplazo $1 indica que el primer grupo capturado reemplazará la subcadena coincidente. Para obtener más información sobre los grupos de capturas con número, vea Construcciones de agrupamiento.

Los grupos de captura que no tienen asignados explícitamente los nombres mediante la sintaxis (?<nombre>) se enumeran de izquierda a derecha a partir de uno. Los grupos con nombre también se numeran de izquierda a derecha, comenzando por uno mayor que el índice del último grupo sin nombre. Por ejemplo, en la expresión regular digit, el índice del grupo (\w)(?<digit>\d) denominado es 2.

Si number no especifica un nombre válido de un grupo capturando definido en el modelo de expresión regular, $number se interpreta como una secuencia del carácter literal que se usa para reemplazar cada coincidencia.

En el ejemplo siguiente se usa la sustitución $número para quitar el símbolo de divisa de un valor decimal. Quita los símbolos de divisa encontrados al principio o al final de un valor monetario y reconoce los dos separadores decimales mas comunes ("." y ",").

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

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

El modelo de expresión regular \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* se define como se muestra en la tabla siguiente.

Modelo

Descripción

\p{Sc}*

Buscar una coincidencia con cero o más caracteres de símbolo de divisa.

\s?

Busca cero o una coincidencia con un carácter de espacio en blanco.

\d+

Buscar coincidencias con uno o más dígitos decimales.

[.,]?

Buscar una coincidencia con cero o un punto o una coma.

\d*

Busca cero o más dígitos decimales.

(\s? \d+[.,]? \d*)

Busca un espacio en blanco seguido de uno o más dígitos decimales, seguido de cero o un punto o una coma, seguido de cero o más dígitos decimales. Éste es el primer grupo de captura. Dado que el modelo del reemplazo es $1, la llamada al método Regex.Replace reemplaza la subcadena coincidente completa con este grupo capturado.

Volver al principio

Sustituir un grupo con nombre

El elemento del lenguaje ${nombre} sustituye a la última subcadena coincidente por el grupo de captura nombre, donde nombre es el nombre del grupo de captura definido por el elemento del lenguaje (?<nombre>). Para obtener más información sobre los grupos de capturas con nombre, vea Construcciones de agrupamiento.

Si name no especifica un nombre válido de un grupo capturando definido en el modelo de expresión regular, ${name} se interpreta como una secuencia del carácter literal que se usa para reemplazar cada coincidencia.

En el ejemplo siguiente se usa la sustitución ${nombre} para quitar el símbolo de divisa de un valor decimal. Quita los símbolos de divisa encontrados al principio o al final de un valor monetario y reconoce los dos separadores decimales mas comunes ("." y ",").

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

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

El modelo de expresión regular \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* se define como se muestra en la tabla siguiente.

Modelo

Descripción

\p{Sc}*

Buscar una coincidencia con cero o más caracteres de símbolo de divisa.

\s?

Busca cero o una coincidencia con un carácter de espacio en blanco.

\d+

Buscar coincidencias con uno o más dígitos decimales.

[.,]?

Buscar una coincidencia con cero o un punto o una coma.

\d*

Busca cero o más dígitos decimales.

(?<amount>\s? \d[.,]? \d*)

Busca un espacio en blanco, seguido de uno o más dígitos decimales, seguido de cero o un punto o una coma, seguido de cero o más dígitos decimales. Este es el grupo de captura denominado amount. Dado que el modelo del reemplazo es ${amount}, la llamada al método Regex.Replace reemplaza la subcadena coincidente completa con este grupo capturado.

Volver al principio

Sustituir un carácter "$"

La substitución $$ inserta un carácter "$" literal en la cadena reemplazada.

En el ejemplo siguiente se usa el objeto NumberFormatInfo para determinar el símbolo de divisa de la referencia cultural actual y su posición en una cadena de divisa. A continuación, compila dinámicamente un modelo de expresión regular y un modelo del reemplazo. Si el ejemplo se ejecuta en un equipo cuya referencia cultural actual es en-US, genera el modelo de expresión regular \b(\d+)(\.(\d+))? y el modelo de reemplazo $$ $1$2. El modelo del reemplazo reemplaza el texto coincidente con un símbolo de divisa y un espacio seguido de los primeros y segundos grupos capturados.

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

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

El modelo de expresión regular \b(\d+)(\.(\d+))? se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Comience la búsqueda de coincidencias al principio de un límite de palabras.

(\d+)

Buscar coincidencias con uno o más dígitos decimales. Éste es el primer grupo de captura.

\.

Buscar una coincidencia con un período (el separador decimal).

(\d+)

Buscar coincidencias con uno o más dígitos decimales. Éste es el tercer grupo de captura.

(\.(\d+))?

Buscar una coincidencia con cero o una aparición de un punto seguido por uno o más dígitos decimales. Éste es el segundo grupo de captura.

Sustituir la coincidencia completa

La sustitución $& incluye la coincidencia completa en la cadena reemplazada. A menudo, se usa para agregar una subcadena al principio o final de la cadena coincidente. Por ejemplo, el modelo de reemplazo ($&) agrega paréntesis al principio y al final de cada coincidencia. Si no hay ninguna coincidencia, la substitución $& no tiene ningún efecto.

En el ejemplo siguiente se usa la substitución $& para agregar comillas al principio y al final de los títulos de los libros almacenados en una matriz de cadena.

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"

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"

El modelo de expresión regular ^(\w+\s?)+$ se define como se muestra en la tabla siguiente.

Modelo

Descripción

^

Comience la búsqueda de coincidencias al principio de la cadena de entrada.

(\w+\s?)+

Busca una o varias coincidencias con el modelo de uno varios caracteres de palabra seguidos de cero o un carácter de espacio en blanco.

$

Buscar coincidencias con el final de la cadena de entrada.

El modelo de reemplazo "$&" agrega una comilla literal al principio y al final de cada coincidencia.

Volver al principio

Sustituir el texto antes de la coincidencia

La substitución $` reemplaza la cadena coincidente con la cadena de entrada completa antes de la coincidencia. Es decir, duplica la cadena de entrada hasta la coincidencia quitando el texto coincidente. Cualquier texto que sigue al texto coincidente no cambia en la cadena de resultado. Si hay varias coincidencias en una cadena de entrada, el texto de sustitución se deriva de la cadena de entrada original, en lugar de derivarse de la cadena en la que coincidencias anteriores han reemplazado el texto. (El ejemplo lo ilustra). Si no hay ninguna coincidencia, la substitución $` no tiene ningún efecto.

En el ejemplo siguiente se usa el modelo de expresión regular \d+ para que coincida con una secuencia de uno o más dígitos decimales en la cadena de entrada. La cadena de reemplazo $` reemplaza estos dígitos con el texto que antecede a la coincidencia.

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

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

En este ejemplo, la cadena de entrada "aa1bb2cc3dd4ee5" contiene cinco coincidencias. La siguiente tabla muestra cómo la substitución $` hace que el motor de expresiones regulares reemplace cada coincidencia en la cadena de entrada. El texto insertado se muestra en negrita en la columna de resultados.

Match

Posición

String antes de la coincidencia

Cadena de resultado

1

2

aa

aaaabb2cc3dd4ee5

2

5

aa1bb

aaaabbaa1bbcc3dd4ee5

3

8

aa1bb2cc

aaaabbaa1bbccaa1bb2ccdd4ee5

4

11

aa1bb2cc3dd

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5

5

14

aa1bb2cc3dd4ee

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee aa1bb2cc3dd4ee

Volver al principio

Sustituir el texto después de la coincidencia

La substitución $' reemplaza la cadena coincidente con la cadena de entrada completa después de la coincidencia. Es decir, duplica la cadena de entrada después de la coincidencia quitando el texto coincidente. Cualquier texto que antecede al texto coincidente no cambia en la cadena de resultado. Si no hay ninguna coincidencia, la substitución $' no tiene ningún efecto.

En el ejemplo siguiente se usa el modelo de expresión regular \d+ para que coincida con una secuencia de uno o más dígitos decimales en la cadena de entrada. La cadena de reemplazo $' reemplaza estos dígitos con el texto que sigue a la coincidencia.

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

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

En este ejemplo, la cadena de entrada "aa1bb2cc3dd4ee5" contiene cinco coincidencias. La siguiente tabla muestra cómo la substitución $' hace que el motor de expresiones regulares reemplace cada coincidencia en la cadena de entrada. El texto insertado se muestra en negrita en la columna de resultados.

Match

Posición

String después de la coincidencia

Cadena de resultado

1

2

bb2cc3dd4ee5

aabb2cc3dd4ee5bb2cc3dd4ee5

2

5

cc3dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5

3

8

dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5

4

11

ee5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5

5

14

String.Empty

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Volver al principio

Sustituir el último grupo capturado

La substitución $+ reemplaza la cadena coincidente por el último grupo capturado. Si no hay ningún grupo capturado o si el valor del último grupo capturado es String.Empty, la substitución $+ no tiene ningún efecto.

En el ejemplo siguiente se identifican las palabras repetidas en una cadena y usa la substitución $+ para reemplazarlas con una aparición única de la palabra. La opción RegexOptions.IgnoreCase se usa para garantizar que palabras que difieren en mayúsculas y minúsculas, pero que de lo contrario son idénticas, se consideren duplicadas.

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.

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.

El modelo de expresión regular \b(\w+)\s\1\b se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(\w+)

Buscar coincidencias con uno o más caracteres de palabra. Éste es el primer grupo de captura.

\s

Hacer coincidir con un carácter que sea un espacio en blanco.

\1

Buscar una coincidencia con el primer grupo capturado.

\b

Finalizar la búsqueda de coincidencias en un límite de palabras.

Volver al principio

Sustitución de toda la cadena de entrada

La substitución $_ reemplaza la cadena coincidente con la cadena de entrada completa. Es decir, quita el texto coincidente y lo reemplaza con la cadena completa, incluyendo el texto coincidente.

En el ejemplo siguiente coinciden uno o más dígitos decimales en la cadena de entrada. Usa la substitución $_ para reemplazarlos con la cadena de entrada completa.

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

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

En este ejemplo, la cadena de entrada "ABC123DEF456" contiene dos coincidencias. La siguiente tabla muestra cómo la substitución $_ hace que el motor de expresiones regulares reemplace cada coincidencia en la cadena de entrada. El texto insertado se muestra en negrita en la columna de resultados.

Match

Posición

Match

Cadena de resultado

1

3

123

ABCABC123DEF456DEF456

2

5

456

ABCABC123DEF456DEFABC123DEF456

Volver al principio

Vea también

Conceptos

Elementos del lenguaje de expresiones regulares