Escapes de carácter en expresiones regularesCharacter Escapes in Regular Expressions

La barra diagonal inversa (\) en una expresión regular indica una de las siguientes situaciones:The backslash (\) in a regular expression indicates one of the following:

  • El carácter que va detrás de ella es un carácter especial, como se muestra en la tabla de la sección siguiente.The character that follows it is a special character, as shown in the table in the following section. Por ejemplo, \b es un delimitador que indica que una coincidencia de expresión regular debería comenzar en un límite de palabras, \t representa un carácter de tabulación y \x020 representa un espacio.For example, \b is an anchor that indicates that a regular expression match should begin on a word boundary, \t represents a tab, and \x020 represents a space.

  • Un carácter que de otro modo se interpretaría como una construcción de lenguaje sin escape, se debe interpretar literalmente.A character that otherwise would be interpreted as an unescaped language construct should be interpreted literally. Por ejemplo, una llave ({) inicia la definición de un cuantificador, pero una barra diagonal inversa seguida de una llave (\{) indica que el motor de expresiones regulares debería coincidir con la llave.For example, a brace ({) begins the definition of a quantifier, but a backslash followed by a brace (\{) indicates that the regular expression engine should match the brace. De igual forma, una sola barra diagonal inversa marca el principio de una construcción de lenguaje con escape, pero dos barras diagonales inversas (\\) indican que el motor de expresiones regulares debería coincidir con la barra diagonal inversa.Similarly, a single backslash marks the beginning of an escaped language construct, but two backslashes (\\) indicate that the regular expression engine should match the backslash.

Nota

Los escapes de caracteres se reconocen en los patrones de expresiones regulares, pero no en los patrones de reemplazo.Character escapes are recognized in regular expression patterns but not in replacement patterns.

Escapes de carácter en .NETCharacter Escapes in .NET

En la tabla siguiente se enumeran los escapes de caracteres admitidos en las expresiones regulares de .NET.The following table lists the character escapes supported by regular expressions in .NET.

Carácter o secuenciaCharacter or sequence DescripciónDescription
Todos los caracteres excepto los siguientes:All characters except for the following:

.. $ ^ { [ ( | ) * + ?$ ^ { [ ( | ) * + ? \
Los caracteres que no aparecen en la columna Carácter o secuencia no tienen ningún significado especial en las expresiones regulares, sino que equivalen a sí mismos.Characters other than those listed in the Character or sequence column have no special meaning in regular expressions; they match themselves.

Los caracteres incluidos en la columna Carácter o secuencia son elementos del lenguaje especial de expresiones regulares.The characters included in the Character or sequence column are special regular expression language elements. Para que coincidan en una expresión regular, deben escribirse entre secuencias de escape o incluirse en un grupo de caracteres positivos.To match them in a regular expression, they must be escaped or included in a positive character group. Por ejemplo, las expresiones regulares \$\d+ o [$]\d+ coinciden con "$1200".For example, the regular expression \$\d+ or [$]\d+ matches "$1200".
\a Coincide con un carácter de campana (alarma), \u0007.Matches a bell (alarm) character, \u0007.
\b En una clase de caracteres [grupo_caracteres], coincide con un retroceso, \u0008.In a [character_group] character class, matches a backspace, \u0008. (Consulte Clases de caracteres). Fuera de una clase de caracteres, \b es un delimitador que coincide con un límite de palabras.(See Character Classes.) Outside a character class, \b is an anchor that matches a word boundary. (Consulte Delimitadores).(See Anchors.)
\t Coincide con un carácter de tabulación, \u0009.Matches a tab, \u0009.
\r Coincide con un retorno de carro, \u000D.Matches a carriage return, \u000D. Observe que \r no es equivalente al carácter de nueva línea, \n.Note that \r is not equivalent to the newline character, \n.
\v Coincide con una tabulación vertical, \u000B.Matches a vertical tab, \u000B.
\f Coincide con un avance de página, \u000C.Matches a form feed, \u000C.
\n Coincide con una nueva línea, \u000A.Matches a new line, \u000A.
\e Coincide con un escape, \u001B.Matches an escape, \u001B.
\ nnn\ nnn Coincide con un carácter ASCII, donde nnn está compuesto de dos o tres dígitos que representan el código de carácter octal.Matches an ASCII character, where nnn consists of two or three digits that represent the octal character code. Por ejemplo, \040 representa un carácter de espacio.For example, \040 represents a space character. Esta construcción se interpreta como una referencia inversa si tiene un solo dígito (por ejemplo, \2) o si se corresponde con el número de un grupo de captura.This construct is interpreted as a backreference if it has only one digit (for example, \2) or if it corresponds to the number of a capturing group. (Consulte Construcciones de referencia inversa).(See Backreference Constructs.)
\x nn\x nn Coincide con un carácter ASCII, donde nn es un código de carácter hexadecimal de dos dígitos.Matches an ASCII character, where nn is a two-digit hexadecimal character code.
\c X\c X Coincide con un carácter de control ASCII, donde X es la letra del carácter de control.Matches an ASCII control character, where X is the letter of the control character. Por ejemplo, \cC es CTRL-C.For example, \cC is CTRL-C.
\u nnnn\u nnnn Coincide con una unidad de código UTF-16 cuyo valor hexadecimal es nnnn.Matches a UTF-16 code unit whose value is nnnn hexadecimal. Nota: .NET no admite el escape de caracteres de Perl 5 usado para especificar Unicode.Note: The Perl 5 character escape that is used to specify Unicode is not supported by .NET. El escape de caracteres de Perl 5 tiene el formato \x{ #### …}, donde #### es una serie de dígitos hexadecimales.The Perl 5 character escape has the form \x{####…}, where #### is a series of hexadecimal digits. En su lugar, use \unnnn.Instead, use \unnnn.
\ Si va seguido de un carácter que no se reconoce como carácter de escape, coincide con ese carácter.When followed by a character that is not recognized as an escaped character, matches that character. Por ejemplo, \* coincide con un asterisco (*) y es igual que \x2A.For example, \* matches an asterisk (*) and is the same as \x2A.

Un ejemploAn Example

En el ejemplo siguiente se muestra el uso de escapes de carácter en una expresión regular.The following example illustrates the use of character escapes in a regular expression. Analiza una cadena que contiene los nombres de las ciudades más grandes del mundo y sus poblaciones en 2009.It parses a string that contains the names of the world's largest cities and their populations in 2009. Cada nombre de ciudad se separa de su población por un carácter de tabulación (\t) o una barra vertical (| o \u007c).Each city name is separated from its population by a tab (\t) or a vertical bar (| or \u007c). Cada ciudad y su población está separada de la siguiente por un retorno de carro y un avance de línea.Individual cities and their populations are separated from each other by a carriage return and line feed.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string delimited = @"\G(.+)[\t\u007c](.+)\r?\n";
      string input = "Mumbai, India|13,922,125\t\n" +
                            "Shanghai, China\t13,831,900\n" +
                            "Karachi, Pakistan|12,991,000\n" +
                            "Delhi, India\t12,259,230\n" +
                            "Istanbul, Turkey|11,372,613\n";
      Console.WriteLine("Population of the World's Largest Cities, 2009");
      Console.WriteLine();
      Console.WriteLine("{0,-20} {1,10}", "City", "Population");
      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, delimited))
         Console.WriteLine("{0,-20} {1,10}", match.Groups[1].Value,
                                            match.Groups[2].Value);
   }
}
// The example displays the following output:
//       Population of the World's Largest Cities, 2009
//
//       City                 Population
//
//       Mumbai, India        13,922,125
//       Shanghai, China      13,831,900
//       Karachi, Pakistan    12,991,000
//       Delhi, India         12,259,230
//       Istanbul, Turkey     11,372,613
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim delimited As String = "\G(.+)[\t\u007c](.+)\r?\n"
        Dim input As String = "Mumbai, India|13,922,125" + vbCrLf + _
                              "Shanghai, China" + vbTab + "13,831,900" + vbCrLf + _
                              "Karachi, Pakistan|12,991,000" + vbCrLf + _
                              "Delhi, India" + vbTab + "12,259,230" + vbCrLf + _
                              "Istanbul, Turkey|11,372,613" + vbCrLf
        Console.WriteLine("Population of the World's Largest Cities, 2009")
        Console.WriteLine()
        Console.WriteLine("{0,-20} {1,10}", "City", "Population")
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, delimited)
            Console.WriteLine("{0,-20} {1,10}", match.Groups(1).Value, _
                                               match.Groups(2).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       Population of the World's Largest Cities, 2009
'       
'       City                 Population
'       
'       Mumbai, India        13,922,125
'       Shanghai, China      13,831,900
'       Karachi, Pakistan    12,991,000
'       Delhi, India         12,259,230
'       Istanbul, Turkey     11,372,613

La expresión regular \G(.+)[\t\u007c](.+)\r?\n se interpreta como se muestra en la tabla siguiente.The regular expression \G(.+)[\t\u007c](.+)\r?\n is interpreted as shown in the following table.

ModeloPattern DescripciónDescription
\G Comienza la búsqueda de coincidencias donde finalizó la última coincidencia.Begin the match where the last match ended.
(.+) Buscar cualquier carácter coincidente una o más veces.Match any character one or more times. Este es el primer grupo de captura.This is the first capturing group.
[\t\u007c] Coincide con un carácter de tabulación (\t) o una barra vertical (|).Match a tab (\t) or a vertical bar (|).
(.+) Buscar cualquier carácter coincidente una o más veces.Match any character one or more times. Este es el segundo grupo de captura.This is the second capturing group.
\r?\n Coincide con cero o un retorno de carro seguido de una nueva línea.Match zero or one occurrence of a carriage return followed by a new line.

Vea tambiénSee also