Sustituciones en expresiones regulares

Las sustituciones son elementos del lenguaje que se reconocen solo dentro de patrones de reemplazo. Usan un patrón de expresión regular para definir todo o parte del texto que reemplazará el texto coincidente en la cadena de entrada. El patrón de reemplazo puede estar compuesto de una o más sustituciones junto con caracteres literales. Los patrones 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 patrón que coincide con el patrón que define el parámetro replacement .

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

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 igual forma, los elementos de lenguaje de sustitución se reconocen únicamente en patrones de reemplazo y no son válidos en 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.

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 de reemplazo $1 indica que el primer grupo capturado reemplazará la subcadena coincidente. Para más información sobre los grupos de captura numerados, vea Grouping Constructs.

Todos los dígitos después del símbolo $ se interpretan como que pertenecen al grupo number . Si esto no es lo que pretende, puede sustituir un grupo con nombre en su lugar. Por ejemplo, puede utilizar la cadena de reemplazo ${1}1 en lugar de $11 para definir la cadena de reemplazo como el valor del primer grupo capturado junto 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, comenzando 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 con nombre digit es 2.

Si number no especifica ningún grupo de captura válido en el patrón de expresión regular, $number se interpreta como una secuencia de caracteres literales 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 divisa encontrados 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.

Sustituir un grupo con nombre

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 más información sobre los grupos de captura con nombre, vea Grouping Constructs.

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

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

En el ejemplo siguiente, se usa la sustitución ${name} 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 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.

Sustituir un carácter "$"

La sustitució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 patrón de expresión regular y un patrón de reemplazo. Si el ejemplo se ejecuta en un equipo cuya referencia cultural actual es en-US, genera el patrón de expresión regular \b(\d+)(\.(\d+))? y el patrón de reemplazo $$ $1$2. El patrón de reemplazo sustituye el texto coincidente por un símbolo de divisa y un espacio seguido del primer y del segundo grupo capturado.

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

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

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 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 los libros almacenados en una matriz de cadena.

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.

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 cambia 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 la cadena en la que coincidencias anteriores han reemplazado el texto. (En el ejemplo se ofrece 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 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 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("   {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

En este ejemplo, la cadena de entrada "aa1bb2cc3dd4ee5" 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.

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 anteceda al texto coincidente no cambia 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 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 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("   {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

En este ejemplo, la cadena de entrada "aa1bb2cc3dd4ee5" 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.

Sustituir el último grupo capturado

La sustitució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 sustitución $+ no tiene ningún efecto.

En el ejemplo siguiente se identifican las palabras duplicadas en una cadena y se usa la sustitución $+ para reemplazarlas por una aparición única 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.

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 la cadena completa, incluyendo el texto coincidente.

En el ejemplo siguiente se buscan coincidencias para uno o más 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:          {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

En este ejemplo, la cadena de entrada "ABC123DEF456" 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.

Vea también

• Lenguaje de expresiones regulares: referencia rápida