Compartir a través de

Sustituciones en expresiones regulares

Las sustituciones son elementos de lenguaje que solo se reconocen dentro de los patrones de reemplazo. Usan un patrón de expresión regular para definir todo o parte del texto que se va a reemplazar por el texto coincidente en la cadena de entrada. El patrón de reemplazo puede constar de una o varias sustituciones junto con caracteres literales. Los patrones de reemplazo se proporcionan a las sobrecargas del método Regex.Replace que tienen un parámetro replacement y al método Match.Result. Los métodos reemplazan el patrón coincidente por el patrón definido por el replacement parámetro .

.NET define los elementos de sustitución enumerados en la tabla siguiente.

Sustitución Descripción
$ número Incluye la última subcadena coincidente con el grupo de captura identificado por número, donde number es un valor decimal, en la cadena de reemplazo. Para obtener más información, vea Sustituir un grupo numerado.
${ name } Incluye la última subcadena coincidente con el grupo con nombre designado por (?<nombre> ) en la cadena de reemplazo. Para obtener más información, vea Sustituir un grupo con nombre.
$$ Incluye un literal "$" único en la cadena de reemplazo. Para obtener más información, vea Sustituir un símbolo "$".
$& Incluye una copia de la coincidencia completa en la cadena de reemplazo. Para obtener más información, vea Sustituir 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 Sustituir el 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 Sustituir el texto detrás de la coincidencia.
$+ Incluye el último grupo capturado en la cadena de reemplazo. Para obtener más información, vea Sustituir el último grupo capturado.
$_ Incluye toda la cadena de entrada en la cadena de reemplazo. Para obtener más información, vea Sustituir toda la cadena de entrada.

Elementos de sustitución y patrones de reemplazo

Las sustituciones son las únicas construcciones especiales reconocidas en un patrón de reemplazo. No se admiten otros elementos de lenguaje de expresiones regulares, incluidos los escapes de caracteres y el punto (.), que coincidan con cualquier carácter. De forma similar, los elementos del lenguaje de sustitución solo se reconocen en patrones de reemplazo y nunca son válidos en los patrones de expresiones regulares.

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

Nota:

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

Sustituir un grupo numerado

El elemento de lenguaje $number incluye la última subcadena coincidente por el grupo de captura number en la cadena de reemplazo, donde number es el índice del grupo de captura. Por ejemplo, el patrón $1 de reemplazo indica que la subcadena coincidente se va a reemplazar por el primer grupo capturado. Para obtener más información sobre los grupos de captura numerados, vea Construcciones de agrupación.

Todos los dígitos siguientes $ se interpretan como pertenecientes al grupo de números . Si no es su intención, puede sustituirlo por un grupo nombrado. Por ejemplo, puede usar la cadena de reemplazo ${1}1 en lugar de $11 para definir la cadena de reemplazo como el valor del primer grupo capturado con el número "1". Para obtener más información, vea Sustituir un grupo con nombre.

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

Si number no especifica un grupo de captura válido definido en el patrón de expresión regular, $number se interpreta como una secuencia de caracteres literal que se usa para reemplazar cada coincidencia.

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

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

El patrón 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}* Busca una coincidencia con cero o más caracteres de símbolo de divisa.
\s? Busca una coincidencia con cero o un carácter de espacio en blanco.
\d+ Buscar coincidencias con uno o más dígitos decimales.
[.,]? Busca 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. Este es el primer grupo de captura. Dado que el patrón de reemplazo es $1, la llamada al Regex.Replace método reemplaza toda la subcadena coincidente con este grupo capturado.

Sustitución de un grupo nombrado

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

Si name no especifica un grupo de captura con nombre válido definido en el patrón de expresión regular, pero consta de dígitos, ${el nombre} se interpreta como un grupo numerado.

Si name no especifica ningún grupo de captura con nombre válido ni un grupo de captura numerado válido definido en el patrón de expresión regular, ${name} se interpreta como una secuencia de caracteres literal que se usa para reemplazar cada coincidencia.

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

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

El patrón 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}* Busca una coincidencia con cero o más caracteres de símbolo de divisa.
\s? Busca una coincidencia con cero o un carácter de espacio en blanco.
\d+ Buscar coincidencias con uno o más dígitos decimales.
[.,]? Busca 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 patrón de reemplazo es ${amount}, la llamada al Regex.Replace método reemplaza toda la subcadena coincidente con este grupo capturado.

Sustituir un carácter "$"

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

En el siguiente ejemplo, se utiliza el objeto NumberFormatInfo para determinar el símbolo de moneda de la cultura actual y su colocación en una cadena de moneda. A continuación, crea un patrón de expresión regular y un patrón de reemplazo dinámicamente. Si el ejemplo se ejecuta en un ordenador cuya referencia cultural actual es en-US, genera el patrón \b(\d+)(\.(\d+))? de expresión regular y el patrón $$ $1$2 de reemplazo. El patrón de reemplazo reemplaza el texto coincidente por un símbolo de moneda y un espacio seguido de los grupos capturados primero y segundo.

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

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

Modelo Descripción
\b Comenzar la búsqueda de coincidencias al principio de un límite de palabras.
(\d+) Buscar coincidencias con uno o más dígitos decimales. Este es el primer grupo de captura.
\. Buscar coincidencias con un punto (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 de uno o más dígitos decimales. Este es el segundo grupo de captura.

Sustituir toda la coincidencia

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

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

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"

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

Modelo Descripción
^ Comenzar la búsqueda de coincidencias al principio de la cadena de entrada.
(\w+\s?)+ Buscar coincidencias con el patrón de uno o varios caracteres de palabra seguidos de cero o un carácter de espacio en blanco una o varias veces.
$ Coincide con el final de la cadena de entrada.

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

Sustituir el texto delante de la coincidencia

La sustitución $` reemplaza la cadena coincidente por la cadena de entrada completa delante de la coincidencia. Es decir, duplica la cadena de entrada hasta la coincidencia quitando el texto coincidente. Cualquier texto que siga al texto coincidente no se modifica en la cadena de resultado. Si hay varias coincidencias en una cadena de entrada, el texto de reemplazo se deriva de la cadena de entrada original, en lugar de de la cadena en la que el texto se ha reemplazado por coincidencias anteriores. (En el ejemplo se proporciona una ilustración). Si no hay ninguna coincidencia, la $` sustitución no tiene ningún efecto.

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

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

En este ejemplo, la cadena "aa1bb2cc3dd4ee5" de entrada contiene cinco coincidencias. En la siguiente tabla se muestra cómo la sustitució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.

Partido Posición Cadena 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 aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Sustituir el texto detrás de la coincidencia

La sustitución $' reemplaza la cadena coincidente por 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 precede al texto coincidente no se modifica en la cadena de resultado. Si no hay ninguna coincidencia, la $' sustitución no tiene ningún efecto.

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

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

En este ejemplo, la cadena "aa1bb2cc3dd4ee5" de entrada contiene cinco coincidencias. En la siguiente tabla se muestra cómo la sustitució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.

Partido Posición Cadena después de la coincidencia Cadena de resultado
1 2 bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5
2 5 cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
3 8 dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5 dd4ee5dd4ee5
4 11 ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccd4ee5ddee5 ee5 ee5
5 14 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Sustituir el último grupo capturado

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

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

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.

El patrón 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 alfabéticos. Este es el primer grupo de captura.
\s Coincide con un carácter de 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.

Sustituir toda la cadena de entrada

La sustitución $_ reemplaza la cadena coincidente por la cadena de entrada completa. Es decir, quita el texto coincidente y lo reemplaza por toda la cadena, incluido el texto coincidente.

En el ejemplo siguiente se comparan uno o varios dígitos decimales en la cadena de entrada. Se usa la sustitución $_ para reemplazarlos por la cadena de entrada completa.

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

En este ejemplo, la cadena "ABC123DEF456" de entrada contiene dos coincidencias. En la siguiente tabla se muestra cómo la sustitució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.

Partido Posición Partido Cadena de resultado
1 3 123 ABCABC123DEF456DEF456
2 5 456 ABCABC123DEF456DEF ABC123DEF456

Consulte también