Sustituciones en expresiones regularesSubstitutions in Regular Expressions

Las sustituciones son elementos del lenguaje que se reconocen solo dentro de patrones de reemplazo.Substitutions are language elements that are recognized only within replacement patterns. 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.They use a regular expression pattern to define all or part of the text that is to replace matched text in the input string. El patrón de reemplazo puede estar compuesto de una o más sustituciones junto con caracteres literales.The replacement pattern can consist of one or more substitutions along with literal characters. 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 .Replacement patterns are provided to overloads of the Regex.Replace method that have a replacement parameter and to the Match.Result method. Los métodos reemplazan el patrón que coincide con el patrón que define el parámetro replacement .The methods replace the matched pattern with the pattern that is defined by the replacement parameter.

.NET Framework define los elementos de sustitución que se enumeran en la siguiente tabla.The .NET Framework defines the substitution elements listed in the following table.

SustituciónSubstitution DescripciónDescription
$ number$ number Incluye la última subcadena coincidente por el grupo capturado que identifica number, donde number es un valor decimal, en la cadena de reemplazo.Includes the last substring matched by the capturing group that is identified by number, where number is a decimal value, in the replacement string. Para obtener más información, vea Sustituir un grupo numerado.For more information, see Substituting a Numbered Group.
${ name }${ name } Incluye la última subcadena coincidente por el grupo con nombre que designa (?<name> ) en la cadena de reemplazo.Includes the last substring matched by the named group that is designated by (?<name> ) in the replacement string. Para obtener más información, vea Sustituir un grupo con nombre.For more information, see Substituting a Named Group.
$$ Incluye un literal "$" único en la cadena de reemplazo.Includes a single "$" literal in the replacement string. Para obtener más información, vea Sustituir un símbolo "$".For more information, see Substituting a "$" Symbol.
$& Incluye una copia de la coincidencia completa en la cadena de reemplazo.Includes a copy of the entire match in the replacement string. Para obtener más información, vea Sustituir toda la coincidencia.For more information, see Substituting the Entire Match.
$` Incluye todo el texto de la cadena de entrada delante de la coincidencia en la cadena de reemplazo.Includes all the text of the input string before the match in the replacement string. Para obtener más información, vea Sustituir el texto delante de la coincidencia.For more information, see Substituting the Text before the Match.
$'$' Incluye todo el texto de la cadena de entrada detrás de la coincidencia en la cadena de reemplazo.Includes all the text of the input string after the match in the replacement string. Para obtener más información, vea Sustituir el texto detrás de la coincidencia.For more information, see Substituting the Text after the Match.
$+ Incluye el último grupo capturado en la cadena de reemplazo.Includes the last group captured in the replacement string. Para obtener más información, vea Sustituir el último grupo capturado.For more information, see Substituting the Last Captured Group.
$_ Incluye la cadena de entrada completa en la cadena de reemplazo.Includes the entire input string in the replacement string. Para obtener más información, vea Sustituir toda la cadena de entrada.For more information, see Substituting the Entire Input String.

Elementos de sustitución y patrones de reemplazoSubstitution Elements and Replacement Patterns

Las sustituciones son las únicas construcciones especiales reconocidas en un patrón de reemplazo.Substitutions are the only special constructs recognized in a replacement pattern. No se admiten otros elementos de lenguaje de expresiones regulares, incluidos los escapes de caracteres y el punto (.), que coincidan con cualquier carácter.None of the other regular expression language elements, including character escapes and the period (.), which matches any character, are supported. 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.Similarly, substitution language elements are recognized only in replacement patterns and are never valid in regular expression patterns.

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.The only character that can appear either in a regular expression pattern or in a substitution is the $ character, although it has a different meaning in each context. En un patrón de expresión regular, $ es un delimitador que coincide con el final de la cadena.In a regular expression pattern, $ is an anchor that matches the end of the string. En un patrón de reemplazo, $ indica el principio de una sustitución.In a replacement pattern, $ indicates the beginning of a substitution.

Nota

Para obtener una funcionalidad similar a la de un patrón de reemplazo dentro de una expresión regular, use una referencia inversa.For functionality similar to a replacement pattern within a regular expression, use a backreference. Para obtener más información acerca de las referencias inversas, vea Construcciones de referencia inversa.For more information about backreferences, see Backreference Constructs.

Sustituir un grupo numeradoSubstituting a Numbered Group

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.The $number language element includes the last substring matched by the number capturing group in the replacement string, where number is the index of the capturing group. Por ejemplo, el patrón de reemplazo $1 indica que el primer grupo capturado reemplazará la subcadena coincidente.For example, the replacement pattern $1 indicates that the matched substring is to be replaced by the first captured group. Para más información sobre los grupos de captura numerados, vea Grouping Constructs.For more information about numbered capturing groups, see Grouping Constructs.

Todos los dígitos después del símbolo $ se interpretan como que pertenecen al grupo number .All digits that follow $ are interpreted as belonging to the number group. Si esto no es lo que pretende, puede sustituir un grupo con nombre en su lugar.If this is not your intent, you can substitute a named group instead. 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".For example, you can use the replacement string ${1}1 instead of $11 to define the replacement string as the value of the first captured group along with the number "1". Para obtener más información, vea Sustituir un grupo con nombre.For more information, see Substituting a Named Group.

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.Capturing groups that are not explicitly assigned names using the (?<name>) syntax are numbered from left to right starting at one. Los grupos con nombre también se numeran de izquierda a derecha, comenzando por uno mayor que el índice del último grupo sin nombre.Named groups are also numbered from left to right, starting at one greater than the index of the last unnamed group. Por ejemplo, en la expresión regular (\w)(?<digit>\d), el índice del grupo con nombre digit es 2.For example, in the regular expression (\w)(?<digit>\d), the index of the digit named group is 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.If number does not specify a valid capturing group defined in the regular expression pattern, $number is interpreted as a literal character sequence that is used to replace each match.

En el ejemplo siguiente se usa la sustitución $number para quitar el símbolo de divisa de un valor decimal.The following example uses the $number substitution to strip the currency symbol from a decimal value. 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 ",").It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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.The regular expression pattern \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* is defined as shown in the following table.

ModeloPattern DescripciónDescription
\p{Sc}* Busca una coincidencia con cero o más caracteres de símbolo de divisa.Match zero or more currency symbol characters.
\s? Busca una coincidencia con cero o un carácter de espacio en blanco.Match zero or one white-space characters.
\d+ Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits.
[.,]? Busca una coincidencia con cero o un punto o una coma.Match zero or one period or comma.
\d* Busca cero o más dígitos decimales.Match zero or more decimal digits.
(\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.Match a white space followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. Este es el primer grupo de captura.This is the first capturing group. Dado que el patrón de reemplazo es $1, la llamada al método Regex.Replace reemplaza la subcadena coincidente completa por este grupo capturado.Because the replacement pattern is $1, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Sustituir un grupo con nombreSubstituting a Named Group

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>) .The ${name} language element substitutes the last substring matched by the name capturing group, where name is the name of a capturing group defined by the (?<name>) language element. Para más información sobre los grupos de captura con nombre, vea Grouping Constructs.For more information about named capturing groups, see 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.If name doesn't specify a valid named capturing group defined in the regular expression pattern but consists of digits, ${name} is interpreted as a numbered group.

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.If name specifies neither a valid named capturing group nor a valid numbered capturing group defined in the regular expression pattern, ${name} is interpreted as a literal character sequence that is used to replace each match.

En el ejemplo siguiente, se usa la sustitución ${name} para quitar el símbolo de divisa de un valor decimal.The following example uses the ${name} substitution to strip the currency symbol from a decimal value. 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 ",").It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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.The regular expression pattern \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* is defined as shown in the following table.

ModeloPattern DescripciónDescription
\p{Sc}* Busca una coincidencia con cero o más caracteres de símbolo de divisa.Match zero or more currency symbol characters.
\s? Busca una coincidencia con cero o un carácter de espacio en blanco.Match zero or one white-space characters.
\d+ Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits.
[.,]? Busca una coincidencia con cero o un punto o una coma.Match zero or one period or comma.
\d* Busca cero o más dígitos decimales.Match zero or more decimal digits.
(?<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.Match a white space, followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. Este es el grupo de captura denominado amount.This is the capturing group named amount. Dado que el patrón de reemplazo es ${amount}, la llamada al método Regex.Replace reemplaza la subcadena coincidente completa por este grupo capturado.Because the replacement pattern is ${amount}, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Sustituir un carácter "$"Substituting a "$" Character

La sustitución $$ inserta un carácter "$" literal en la cadena reemplazada.The $$ substitution inserts a literal "$" character in the replaced string.

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.The following example uses the NumberFormatInfo object to determine the current culture's currency symbol and its placement in a currency string. A continuación, compila dinámicamente un patrón de expresión regular y un patrón de reemplazo.It then builds both a regular expression pattern and a replacement pattern dynamically. 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.If the example is run on a computer whose current culture is en-US, it generates the regular expression pattern \b(\d+)(\.(\d+))? and the replacement pattern $$ $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.The replacement pattern replaces the matched text with a currency symbol and a space followed by the first and second captured groups.

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.The regular expression pattern \b(\d+)(\.(\d+))? is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Comenzar la búsqueda de coincidencias al principio de un límite de palabras.Start the match at the beginning of a word boundary.
(\d+) Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits. Este es el primer grupo de captura.This is the first capturing group.
\. Buscar coincidencias con un punto (el separador decimal).Match a period (the decimal separator).
(\d+) Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits. Éste es el tercer grupo de captura.This is the third capturing group.
(\.(\d+))? Buscar una coincidencia con cero o una aparición de un punto seguido de uno o más dígitos decimales.Match zero or one occurrence of a period followed by one or more decimal digits. Este es el segundo grupo de captura.This is the second capturing group.

Sustituir toda la coincidenciaSubstituting the Entire Match

La sustitución $& incluye toda la coincidencia en la cadena de reemplazo.The $& substitution includes the entire match in the replacement string. A menudo, se usa para agregar una subcadena al principio o final de la cadena coincidente.Often, it is used to add a substring to the beginning or end of the matched string. Por ejemplo, el patrón de reemplazo ($&) agrega un paréntesis al principio y al final de cada coincidencia.For example, the ($&) replacement pattern adds parentheses to the beginning and end of each match. Si no hay ninguna coincidencia, la sustitución $& no tiene ningún efecto.If there is no match, the $& substitution has no effect.

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.The following example uses the $& substitution to add quotation marks at the beginning and end of book titles stored in a string array.

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.The regular expression pattern ^(\w+\s?)+$ is defined as shown in the following table.

ModeloPattern DescripciónDescription
^ Comenzar la búsqueda de coincidencias al principio de la cadena de entrada.Start the match at the beginning of the input string.
(\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.Match the pattern of one or more word characters followed by zero or one white-space characters one or more times.
$ Coincide con el final de la cadena de entrada.Match the end of the input string.

El patrón de reemplazo "$&" agrega una comilla literal al principio y al final de cada coincidencia.The "$&" replacement pattern adds a literal quotation mark to the beginning and end of each match.

Sustituir el texto delante de la coincidenciaSubstituting the Text Before the Match

La sustitución $` reemplaza la cadena coincidente por la cadena de entrada completa delante de la coincidencia.The $` substitution replaces the matched string with the entire input string before the match. Es decir, duplica la cadena de entrada hasta la coincidencia quitando el texto coincidente.That is, it duplicates the input string up to the match while removing the matched text. Cualquier texto que siga al texto coincidente no cambia en la cadena de resultado.Any text that follows the matched text is unchanged in the result string. 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.If there are multiple matches in an input string, the replacement text is derived from the original input string, rather than from the string in which text has been replaced by earlier matches. (En el ejemplo se ofrece una ilustración.) Si no hay ninguna coincidencia, la sustitución $` no tiene ningún efecto.(The example provides an illustration.) If there is no match, the $` substitution has no effect.

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.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. La cadena de reemplazo $` reemplaza estos dígitos por el texto que antecede a la coincidencia.The replacement string $` replaces these digits with the text that precedes the match.

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.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $` substitution causes the regular expression engine to replace each match in the input string. El texto insertado se muestra en negrita en la columna de resultados.Inserted text is shown in bold in the results column.

Coincidir conMatch PosiciónPosition Cadena antes de la coincidenciaString before match Cadena de resultadoResult string
11 22 aaaa aaaabb2cc3dd4ee5aaaabb2cc3dd4ee5
22 55 aa1bbaa1bb aaaabbaa1bbcc3dd4ee5aaaabbaa1bbcc3dd4ee5
33 88 aa1bb2ccaa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5aaaabbaa1bbccaa1bb2ccdd4ee5
44 1111 aa1bb2cc3ddaa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
55 1414 aa1bb2cc3dd4eeaa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4eeaaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Sustituir el texto detrás de la coincidenciaSubstituting the Text After the Match

La sustitución $' reemplaza la cadena coincidente por la cadena de entrada completa después de la coincidencia.The $' substitution replaces the matched string with the entire input string after the match. Es decir, duplica la cadena de entrada después de la coincidencia quitando el texto coincidente.That is, it duplicates the input string after the match while removing the matched text. Cualquier texto que anteceda al texto coincidente no cambia en la cadena de resultado.Any text that precedes the matched text is unchanged in the result string. Si no hay ninguna coincidencia, la sustitución $' no tiene ningún efecto.If there is no match, the $' substitution has no effect.

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.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. La cadena de reemplazo $' reemplaza estos dígitos por el texto que sigue a la coincidencia.The replacement string $' replaces these digits with the text that follows the match.

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.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $' substitution causes the regular expression engine to replace each match in the input string. El texto insertado se muestra en negrita en la columna de resultados.Inserted text is shown in bold in the results column.

Coincidir conMatch PosiciónPosition Cadena después de la coincidenciaString after match Cadena de resultadoResult string
11 22 bb2cc3dd4ee5bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5aabb2cc3dd4ee5bb2cc3dd4ee5
22 55 cc3dd4ee5cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
33 88 dd4ee5dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
44 1111 ee5ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
55 1414 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5eeaabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Sustituir el último grupo capturadoSubstituting the Last Captured Group

La sustitución $+ reemplaza la cadena coincidente por el último grupo capturado.The $+ substitution replaces the matched string with the last captured group. 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.If there are no captured groups or if the value of the last captured group is String.Empty, the $+ substitution has no effect.

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.The following example identifies duplicate words in a string and uses the $+ substitution to replace them with a single occurrence of the word. 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.The RegexOptions.IgnoreCase option is used to ensure that words that differ in case but that are otherwise identical are considered duplicates.

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.The regular expression pattern \b(\w+)\s\1\b is defined as shown in the following table.

ModeloPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
(\w+) Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters. Este es el primer grupo de captura.This is the first capturing group.
\s Coincide con un carácter de espacio en blanco.Match a white-space character.
\1 Buscar una coincidencia con el primer grupo capturado.Match the first captured group.
\b Finalizar la búsqueda de coincidencias en un límite de palabras.End the match at a word boundary.

Sustituir toda la cadena de entradaSubstituting the Entire Input String

La sustitución $_ reemplaza la cadena coincidente por la cadena de entrada completa.The $_ substitution replaces the matched string with the entire input string. Es decir, quita el texto coincidente y lo reemplaza por la cadena completa, incluyendo el texto coincidente.That is, it removes the matched text and replaces it with the entire string, including the matched text.

En el ejemplo siguiente se buscan coincidencias para uno o más dígitos decimales en la cadena de entrada.The following example matches one or more decimal digits in the input string. Se usa la sustitución $_ para reemplazarlos por la cadena de entrada completa.It uses the $_ substitution to replace them with the entire input string.

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.In this example, the input string "ABC123DEF456" contains two matches. 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.The following table illustrates how the $_ substitution causes the regular expression engine to replace each match in the input string. El texto insertado se muestra en negrita en la columna de resultados.Inserted text is shown in bold in the results column.

Coincidir conMatch PosiciónPosition Coincidir conMatch Cadena de resultadoResult string
11 33 123123 ABCABC123DEF456DEF456ABCABC123DEF456DEF456
22 55 456456 ABCABC123DEF456DEFABC123DEF456ABCABC123DEF456DEFABC123DEF456

Vea tambiénSee also