Clases de caracteres en expresiones regularesCharacter classes in regular expressions

Una clase de caracteres define un conjunto de caracteres, cualquiera de los cuales puede estar en una cadena de entrada para que se produzca una coincidencia.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. El lenguaje de expresiones regulares de .NET admite las siguientes clases de caracteres:The regular expression language in .NET supports the following character classes:

  • Grupos de caracteres positivos.Positive character groups. Un carácter de la cadena de entrada debe coincidir con uno de los caracteres del conjunto especificado.A character in the input string must match one of a specified set of characters. Para obtener más información, consulte Grupo de caracteres positivos.For more information, see Positive Character Group.

  • Grupos de caracteres negativos.Negative character groups. Ningún carácter de la cadena de entrada debe coincidir con ninguno de los caracteres del conjunto especificado.A character in the input string must not match one of a specified set of characters. Para obtener más información, consulte Grupo de caracteres negativos.For more information, see Negative Character Group.

  • Cualquier carácter.Any character. El carácter . (punto) en una expresión regular es un carácter comodín que coincide con cualquier carácter excepto con \n.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Para obtener más información, consulte Cualquier carácter.For more information, see Any Character.

  • Una categoría general o un bloque con nombre Unicode.A general Unicode category or named block. Para que se produzca una coincidencia, un carácter de la cadena de entrada debe ser miembro de una categoría Unicode determinada o debe estar dentro de un intervalo contiguo de caracteres Unicode.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Para obtener más información, consulte Categoría Unicode o bloque Unicode.For more information, see Unicode Category or Unicode Block.

  • Un bloque con nombre o una categoría general negativa Unicode.A negative general Unicode category or named block. Para que se produzca una coincidencia, un carácter de la cadena de entrada no debe ser miembro de una categoría Unicode determinada o no debe estar dentro de un intervalo contiguo de caracteres Unicode.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Para obtener más información, consulte Categoría Unicode o bloque Unicode negativo.For more information, see Negative Unicode Category or Unicode Block.

  • Un carácter de palabra.A word character. Un carácter de la cadena de entrada puede pertenecer a cualquiera de las categorías Unicode que son adecuadas para los caracteres que se usan para formar palabras.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Para obtener más información, consulte Carácter de palabra.For more information, see Word Character.

  • Un carácter que no se usa en las palabras.A non-word character. Un carácter de la cadena de entrada puede pertenecer a cualquier categoría Unicode que no se usa para formar palabras.A character in the input string can belong to any Unicode category that is not a word character. Para obtener más información, consulte Carácter que no se usa en las palabras.For more information, see Non-Word Character.

  • Un carácter de espacio en blanco.A white-space character. Un carácter de la cadena de entrada puede ser cualquiera de los caracteres separadores Unicode, así como cualquiera de los caracteres de una serie de caracteres de control.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Para obtener más información, consulte Carácter de espacio en blanco.For more information, see White-Space Character.

  • Un carácter que no sea un espacio en blanco.A non-white-space character. Un carácter de la cadena de entrada puede ser cualquier carácter que no sea un espacio en blanco.A character in the input string can be any character that is not a white-space character. Para obtener más información, consulte Carácter que no sea un espacio en blanco.For more information, see Non-White-Space Character.

  • Un dígito decimal.A decimal digit. Un carácter de la cadena de entrada puede ser cualquiera de los caracteres clasificados como dígitos decimales de Unicode.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Para obtener más información, consulte Carácter de dígito decimal.For more information, see Decimal Digit Character.

  • Un carácter que no sea un dígito decimal.A non-decimal digit. Un carácter de la cadena de entrada puede ser cualquier carácter que no sea un dígito decimal de Unicode.A character in the input string can be anything other than a Unicode decimal digit. Para obtener más información, consulte Carácter de dígito decimal.For more information, see Decimal Digit Character.

.NET admite expresiones de sustracción de clases de caracteres, que permiten definir un conjunto de caracteres como el resultado de excluir una clase de caracteres de otra clase de caracteres..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Para obtener más información, consulte Sustracción de clases de caracteres.For more information, see Character Class Subtraction.

Nota

Las clases que coinciden con los caracteres por categoría, como \w para que coincidan con caracteres alfabéticos o \p{} para que coincidan con una categoría Unicode, que se basan en la clase CharUnicodeInfo para proporcionar información sobre las categorías de caracteres.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. A partir de .NET Framework 4.6.2, las categorías de caracteres se basan en el estándar Unicode, versión 8.0.0.Starting with the .NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. Desde .NET Framework 4 hasta .NET Framework 4.6.1, se basan en el estándar Unicode, versión 6.3.0.In the .NET Framework 4 through the .NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Grupo de caracteres positivos: [ ]Positive character group: [ ]

Un grupo de caracteres positivos especifica una lista de caracteres cualquiera de los cuales puede aparecer en una cadena de entrada para que se produzca una coincidencia.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. Los caracteres de la lista se pueden especificar individualmente, como un intervalo o de ambas formas.This list of characters may be specified individually, as a range, or both.

La sintaxis para especificar la lista de caracteres individuales es la siguiente:The syntax for specifying a list of individual characters is as follows:

[*character_group*]

donde grupo_caracteres es una lista de cada uno de los caracteres que pueden aparecer en la cadena de entrada para que se produzca una coincidencia.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. grupo_caracteres puede estar formado por cualquier combinación de uno o varios caracteres literales, caracteres de escape o clases de caracteres.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

La sintaxis para especificar un intervalo de caracteres es la siguiente:The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]

donde firstCharacter es el carácter que comienza el intervalo y lastCharacter es el carácter final del intervalo.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Un intervalo de caracteres es una serie contigua de caracteres que se define especificando el primer carácter de la serie, un guion (-) y, a continuación, el último carácter de la serie.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter debe ser el carácter con el punto de código inferior y lastCharacter debe ser el carácter con el punto de código superior.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Nota

Dado que un grupo de caracteres positivos puede incluir un conjunto de caracteres y un rango de caracteres, un carácter de guión (-) siempre se interpreta como el separador de rango, a menos que sea el primer carácter del grupo o el último.Because a positive character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

En la tabla siguiente se recogen algunos de los patrones de expresiones regulares comunes que contienen clases de caracteres positivos.Some common regular expression patterns that contain positive character classes are listed in the following table.

ModeloPattern DESCRIPCIÓNDescription
[aeiou] Coincide con todas las vocales.Match all vowels.
[\p{P}\d] Coincide con todos los caracteres de puntuación y de dígitos decimales.Match all punctuation and decimal digit characters.
[\s\p{P}] Coincide con todos los caracteres de espacio en blanco y de puntuación.Match all white space and punctuation.

En el ejemplo siguiente se define un grupo de caracteres positivos que contiene los caracteres "a" y "e" de manera que la cadena de entrada deba contener las palabras "grey" o "gray" seguidas de cualquier otra palabra para que se produzca una coincidencia.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
      Dim input As String = "The gray wolf jumped over the grey wall."
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine($"'{match.Value}'")
      Next
   End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

La expresión regular gr[ae]y\s\S+?[\s|\p{P}] se define de la siguiente manera:The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

ModeloPattern DESCRIPCIÓNDescription
gr Coincide con los caracteres literales "gr".Match the literal characters "gr".
[ae] Coincide con una "a" o una "e".Match either an "a" or an "e".
y\s Coincide con el carácter literal "y" seguido de un carácter de espacio en blanco.Match the literal character "y" followed by a white-space character.
\S+? Coincide con uno o varios caracteres que no sean un espacio en blanco, pero con la menor cantidad posible de caracteres.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Coincide con un carácter de espacio en blanco o un signo de puntuación.Match either a white-space character or a punctuation mark.

En el ejemplo siguiente se buscan palabras que comienzan por cualquier letra mayúscula.The following example matches words that begin with any capital letter. Utiliza la subexpresión [A-Z] para representar el intervalo de letras mayúsculas de la A a la Z.It uses the subexpression [A-Z] to represent the range of capital letters from A to Z.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]\w*\b"
      Dim input As String = "A city Albany Zulu maritime Marseilles"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module

La expresión regular \b[A-Z]\w*\b se define como se muestra en la tabla siguiente.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

ModeloPattern DESCRIPCIÓNDescription
\b Empieza en un límite de palabras.Start at a word boundary.
[A-Z] Coincide con cualquier letra mayúscula de la A a la Z.Match any uppercase character from A to Z.
\w* Buscar una coincidencia con cero o más caracteres alfabéticos.Match zero or more word characters.
\b Coincide con un límite de palabras.Match a word boundary.

Grupo de caracteres negativos: [^]Negative character group: [^]

Un grupo de caracteres negativos especifica una lista de caracteres que no deben aparecer en una cadena de entrada para que se produzca una coincidencia.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. Los caracteres de la lista se pueden especificar individualmente, como un intervalo o de ambas formas.The list of characters may be specified individually, as a range, or both.

La sintaxis para especificar la lista de caracteres individuales es la siguiente:The syntax for specifying a list of individual characters is as follows:

[*^character_group*]

donde grupo_caracteres es una lista de cada uno de los caracteres que no pueden aparecer en la cadena de entrada para que se produzca una coincidencia.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. grupo_caracteres puede estar formado por cualquier combinación de uno o varios caracteres literales, caracteres de escape o clases de caracteres.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

La sintaxis para especificar un intervalo de caracteres es la siguiente:The syntax for specifying a range of characters is as follows:

[^*firstCharacter*-*lastCharacter*]

donde firstCharacter es el carácter que comienza el intervalo y lastCharacter es el carácter final del intervalo.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Un intervalo de caracteres es una serie contigua de caracteres que se define especificando el primer carácter de la serie, un guion (-) y, a continuación, el último carácter de la serie.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter debe ser el carácter con el punto de código inferior y lastCharacter debe ser el carácter con el punto de código superior.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Nota

Dado que un grupo de caracteres negativos puede incluir un conjunto de caracteres y un rango de caracteres, un carácter de guión (-) siempre se interpreta como el separador de rango, a menos que sea el primer carácter del grupo o el último.Because a negative character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Es posible concatenar dos o más intervalos de caracteres.Two or more character ranges can be concatenated. Por ejemplo, para especificar el intervalo de dígitos decimales del "0" al "9", el intervalo de letras minúsculas de la "a" a la "f" y el intervalo de letras mayúsculas de la "A" a la "F", utilice [0-9a-fA-F].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].

El carácter inicial de acento circunflejo (^) de un grupo de caracteres negativos es obligatorio e indica que el grupo de caracteres es un grupo de caracteres negativos en lugar de un grupo de caracteres positivos.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Importante

Un grupo de caracteres negativos dentro de un patrón de expresión regular más grande no es una aserción de ancho cero.A negative character group in a larger regular expression pattern is not a zero-width assertion. Es decir, después de evaluar el grupo de caracteres negativos, el motor de expresiones regulares avanza un carácter en la cadena de entrada.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

En la tabla siguiente se recogen algunos de los patrones de expresiones regulares comunes que contienen grupos de caracteres negativos.Some common regular expression patterns that contain negative character groups are listed in the following table.

ModeloPattern DESCRIPCIÓNDescription
[^aeiou] Coincide con todos los caracteres excepto las vocales.Match all characters except vowels.
[^\p{P}\d] Coincide con todos los caracteres excepto los caracteres de puntuación y de dígitos decimales.Match all characters except punctuation and decimal digit characters.

En el ejemplo siguiente se busca cualquier palabra que comience por los caracteres "th" y no vaya seguida de una "o".The following example matches any word that begins with the characters "th" and is not followed by an "o".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bth[^o]\w+\b"
      Dim input As String = "thought thing though them through thus " + _
                            "thorough this"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

La expresión regular \bth[^o]\w+\b se define como se muestra en la tabla siguiente.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

ModeloPattern DESCRIPCIÓNDescription
\b Empieza en un límite de palabras.Start at a word boundary.
th Coincide con los caracteres literales "th".Match the literal characters "th".
[^o] Coincide con cualquier carácter que no sea una "o".Match any character that is not an "o".
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
\b Finaliza en un límite de palabras.End at a word boundary.

Cualquier carácter: .Any character: .

El carácter de punto (.) coincide con cualquier carácter excepto con \n (carácter de nueva línea, \u000A), con los dos requisitos siguientes:The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • Si la opción RegexOptions.Singleline modifica un patrón de expresión regular o si la opción . modifica la parte del patrón que contiene la clase de caracteres s, . coincide con cualquier carácter.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Para obtener más información, consulte Opciones de expresiones regulares.For more information, see Regular Expression Options.

    El ejemplo siguiente muestra el comportamiento predeterminado de la clase de caracteres . y con la opción RegexOptions.Singleline.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. La expresión regular ^.+ comienza en el principio de la cadena y coincide con todos los caracteres.The regular expression ^.+ starts at the beginning of the string and matches every character. De forma predeterminada, la coincidencia termina al final de la primera línea; el patrón de la expresión regular coincide con el carácter de retorno de carro, \r o \u000D, pero no coincide con \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. Dado que la opción RegexOptions.Singleline interpreta la cadena de entrada completa como una sola línea, coincide con cada carácter de la cadena de entrada, incluido \n.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \n.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "^.+";
          string input = "This is one line and" + Environment.NewLine + "this is the second.";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine(Regex.Escape(match.Value));
    
          Console.WriteLine();
          foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
             Console.WriteLine(Regex.Escape(match.Value));
       }
    }
    // The example displays the following output:
    //       This\ is\ one\ line\ and\r
    //       
    //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As String = "^.+"
          Dim input As String = "This is one line and" + vbCrLf + "this is the second."
          For Each match As Match In Regex.Matches(input, pattern)
             Console.WriteLine(Regex.Escape(match.Value))
          Next
          Console.WriteLine()
          For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
             Console.WriteLine(Regex.Escape(match.Value))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       This\ is\ one\ line\ and\r
    '       
    '       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
    

Nota

Dado que coincide con cualquier carácter excepto con \n, la clase de caracteres . también coincide con \r (el carácter de retorno de carro, \u000D).Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • En un grupo de caracteres positivos o negativos, un punto se considera un carácter de punto literal, no una clase de caracteres.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Para más información, consulte las secciones Grupo de caracteres positivos y Grupo de caracteres negativos anteriormente en este tema.For more information, see Positive Character Group and Negative Character Group earlier in this topic. En el ejemplo siguiente se define una expresión regular que incluye el carácter de punto (.) como una clase de caracteres y como un miembro de un grupo de caracteres positivos.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. La expresión regular \b.*[.?!;:](\s|\z) comienza en un límite de palabras, coincide con cualquier carácter hasta que encuentra uno de cinco signos de puntuación, incluido el punto, y después coincide con un carácter de espacio en blanco o con el final de la cadena.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = @"\b.*[.?!;:](\s|\z)";
          string input = "this. what: is? go, thing.";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine(match.Value);
       }
    }
    // The example displays the following output:
    //       this. what: is? go, thing.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
          Dim input As String = "this. what: is? go, thing."
          For Each match As Match In Regex.Matches(input, pattern)
             Console.WriteLine(match.Value)
          Next   
       End Sub
    End Module
    ' The example displays the following output:
    '       this. what: is? go, thing.
    

Nota

Dado que coincide con cualquier carácter, el elemento del lenguaje . se utiliza a menudo con un cuantificador no expansivo si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Para obtener más información, consulte Cuantificadores.For more information, see Quantifiers.

Categoría Unicode o bloque Unicode: \p{}Unicode category or Unicode block: \p{}

El estándar Unicode asigna una categoría general a cada carácter.The Unicode standard assigns each character a general category. Por ejemplo, un carácter concreto puede ser una letra mayúscula (representada por la categoría Lu), un dígito decimal (categoría Nd), un símbolo matemático (categoría Sm) o un separador de párrafos (categoría Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Determinados juegos de caracteres del estándar Unicode también ocupan un intervalo o bloque específico de puntos de código consecutivos.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Por ejemplo, el juego de caracteres latinos básico se encuentra desde \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

La construcción de expresión regularThe regular expression construct

\p{ nombre }\p{ name }

coincide con cualquier carácter que pertenezca a una categoría general o bloque con nombre de Unicode, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Para obtener una lista de abreviaturas de categorías, consulte la sección Categorías generales Unicode compatibles más adelante en este tema.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Para obtener una lista de bloques con nombre, consulte la sección Bloques con nombre compatibles más adelante en este tema.For a list of named blocks, see the Supported Named Blocks section later in this topic.

En el ejemplo siguiente se usa la construcción \p{nombre} para buscar coincidencias con una categoría general de Unicode (en este caso, Pd o Punctuation, Dash) y un bloque con nombre (los bloques con nombre IsGreek e IsBasicLatin).The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
      Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

      Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
   End Sub
End Module

La expresión regular \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ se define como se muestra en la tabla siguiente.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

ModeloPattern DESCRIPCIÓNDescription
\b Empieza en un límite de palabras.Start at a word boundary.
\p{IsGreek}+ Coincide con uno o varios caracteres griegos.Match one or more Greek characters.
(\s)? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ Coincide una o varias veces con el patrón de uno o varios caracteres griegos seguidos de cero o un carácter de espacio en blanco.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Coincide con un carácter de puntuación, guion.Match a Punctuation, Dash character.
\s Coincide con un carácter de espacio en blanco.Match a white-space character.
\p{IsBasicLatin}+ Coincide con uno o varios caracteres latinos básicos.Match one or more basic Latin characters.
(\s)? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ Coincide una o varias veces con el patrón de uno varios caracteres latinos básicos seguidos de cero o un carácter de espacio en blanco.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Categoría Unicode o bloque Unicode negativo: \P{}Negative Unicode category or Unicode block: \P{}

El estándar Unicode asigna una categoría general a cada carácter.The Unicode standard assigns each character a general category. Por ejemplo, un carácter concreto puede ser una letra mayúscula (representada por la categoría Lu), un dígito decimal (categoría Nd), un símbolo matemático (categoría Sm) o un separador de párrafos (categoría Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Determinados juegos de caracteres del estándar Unicode también ocupan un intervalo o bloque específico de puntos de código consecutivos.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Por ejemplo, el juego de caracteres latinos básico se encuentra desde \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

La construcción de expresión regularThe regular expression construct

\P{ nombre }\P{ name }

coincide con cualquier carácter que no pertenezca a una categoría general o bloque con nombre de Unicode, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Para obtener una lista de abreviaturas de categorías, consulte la sección Categorías generales Unicode compatibles más adelante en este tema.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Para obtener una lista de bloques con nombre, consulte la sección Bloques con nombre compatibles más adelante en este tema.For a list of named blocks, see the Supported Named Blocks section later in this topic.

En el siguiente ejemplo se usa la construcción \P{nombre} para quitar cualquier símbolo de divisa (en este caso, la categoría Sc, o Symbol, Currency) de las cadenas numéricas.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";
      
      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\P{Sc})+"
      
      Dim values() As String = { "$164,091.78", "£1,073,142.68", "73¢", "€120"}
      For Each value As String In values
         Console.WriteLine(Regex.Match(value, pattern).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

El patrón de expresión regular (\P{Sc})+ coincide con uno o varios caracteres que no son símbolos de divisa; quita eficazmente cualquier símbolo de divisa de la cadena de resultado.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Carácter de palabra: \wWord character: \w

\w coincide con cualquier carácter de palabra.\w matches any word character. Un carácter de palabra es un miembro de alguna de las categorías Unicode enumeradas en la tabla siguiente.A word character is a member of any of the Unicode categories listed in the following table.

CategoríaCategory DESCRIPCIÓNDescription
LlLl Letra, minúsculaLetter, Lowercase
LuLu Letra, mayúsculaLetter, Uppercase
LtLt Letra, inicial en mayúsculaLetter, Titlecase
LoLo Letra, otraLetter, Other
LmLm Letra, modificadorLetter, Modifier
MnMn Marca, sin espaciosMark, Nonspacing
NdNd Número, dígito decimalNumber, Decimal Digit
PcPc Puntuación, ConectorPunctuation, Connector. Esta categoría incluye diez caracteres, el más usado de los cuales es el carácter LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Si se especifica un comportamiento conforme a ECMAScript, \w es equivalente a [a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Nota

Dado que coincide con cualquier carácter de palabra, el elemento del lenguaje \w se suele usar con un cuantificador diferido si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter de palabra, seguido de un carácter de palabra específico.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Para obtener más información, consulte Cuantificadores.For more information, see Quantifiers.

En el ejemplo siguiente se usa el elemento del lenguaje \w para buscar coincidencias de caracteres duplicados en una palabra.The following example uses the \w language element to match duplicate characters in a word. El ejemplo define un patrón de expresión regular, (\w)\1, que se puede interpretar de la siguiente manera.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ElementoElement DESCRIPCIÓNDescription
(\w)(\w) Coincide con un carácter de palabra.Match a word character. Este es el primer grupo de captura.This is the first capturing group.
\1\1 Coincide con el valor de la primera captura.Match the value of the first capture.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Carácter que no se usa para formar palabras: \WNon-word character: \W

\W coincide con cualquier carácter que no sea de palabra.\W matches any non-word character. El elemento del lenguaje \W es equivalente a la clase de caracteres siguiente:The \W language element is equivalent to the following character class:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

En otras palabras, coincide con cualquier carácter excepto con los que figuran en las categorías Unicode de la tabla siguiente.In other words, it matches any character except for those in the Unicode categories listed in the following table.

CategoríaCategory DESCRIPCIÓNDescription
LlLl Letra, minúsculaLetter, Lowercase
LuLu Letra, mayúsculaLetter, Uppercase
LtLt Letra, inicial en mayúsculaLetter, Titlecase
LoLo Letra, otraLetter, Other
LmLm Letra, modificadorLetter, Modifier
MnMn Marca, sin espaciosMark, Nonspacing
NdNd Número, dígito decimalNumber, Decimal Digit
PcPc Puntuación, ConectorPunctuation, Connector. Esta categoría incluye diez caracteres, el más usado de los cuales es el carácter LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Si se especifica un comportamiento conforme a ECMAScript, \W es equivalente a [^a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Nota

Dado que coincide con cualquier carácter que no sea de palabra, el elemento del lenguaje \W se suele usar con un cuantificador diferido si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter que no sea de palabra, seguido de un carácter que no sea de palabra específico.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Para obtener más información, consulte Cuantificadores.For more information, see Quantifiers.

En el ejemplo siguiente se ilustra la clase de caracteres \W.The following example illustrates the \W character class. Define un patrón de expresión regular, \b(\w+)(\W){1,2}, que coincide con una palabra seguida de uno o dos caracteres que no son de palabra, como un espacio en blanco o un signo de puntuación.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. La expresión regular se interpreta como se muestra en la tabla siguiente.The regular expression is interpreted as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
\b\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
(\w+)(\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.
(\W){1,2}(\W){1,2} Coincide una o dos veces con un carácter que no se usa para formar palabras.Match a non-word character either one or two times. Este es el segundo grupo de captura.This is the second capturing group.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, 
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), 
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)(\W){1,2}"
      Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         Console.Write("   Non-word character(s):")
         Dim captures As CaptureCollection = match.Groups(2).Captures
         For ctr As Integer = 0 To captures.Count - 1
             Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                           Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                           If(ctr < captures.Count - 1, ", ", ""))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Dado que el objeto Group del segundo grupo de captura contiene solo un carácter que no se usa para formar palabras, el ejemplo recupera todos los caracteres que no se usan para formar palabras capturados del objeto CaptureCollection que devuelve la propiedad Group.Captures.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Carácter de espacio en blanco: \sWhitespace character: \s

\s coincide con cualquier carácter de espacio en blanco.\s matches any whitespace character. Equivale a las secuencias de escape y las categorías Unicode que figuran en la tabla siguiente.It is equivalent to the escape sequences and Unicode categories listed in the following table.

CategoríaCategory DESCRIPCIÓNDescription
\f El carácter de avance de página, \u000C.The form feed character, \u000C.
\n El carácter de nueva línea, \u000A.The newline character, \u000A.
\r El carácter de retorno de carro, \u000D.The carriage return character, \u000D.
\t El carácter de tabulación, \u0009.The tab character, \u0009.
\v El carácter de tabulación vertical, \u000B.The vertical tab character, \u000B.
\x85 Los puntos suspensivos o el carácter de LÍNEA SIGUIENTE (…), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Coincide con cualquier carácter separador.Matches any separator character.

Si se especifica un comportamiento conforme a ECMAScript, \s es equivalente a [ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

En el ejemplo siguiente se ilustra la clase de caracteres \s.The following example illustrates the \s character class. Define un patrón de expresión regular, \b\w+(e)?s(\s|$), que coincide con una palabra que termina por "s" o "es" seguida de un carácter de espacio en blanco o el final de la cadena de entrada.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. La expresión regular se interpreta como se muestra en la tabla siguiente.The regular expression is interpreted as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
\b\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
\w+\w+ Buscar coincidencias con uno o más caracteres alfabéticos.Match one or more word characters.
(e)?(e)? Coincide cero o una vez con una "e".Match an "e" either zero or one time.
ss Coincide con una "s".Match an "s".
(\s|$)(\s|$) Coincide con un carácter de espacio en blanco o el final de la cadena de entrada.Match either a white-space character or the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(e)?s(\s|$)"
      Dim input As String = "matches stores stops leave leaves"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)      
      Next
   End Sub
End Module
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

Carácter que no sea un espacio en blanco: \SNon-whitespace character: \S

\S coincide con cualquier carácter que no sea un espacio en blanco.\S matches any non-white-space character. Equivale al patrón de expresión regular [^\f\n\r\t\v\x85\p{Z}] o es lo contrario del patrón de expresión regular equivalente a \s, que coincide con los caracteres de espacio en blanco.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Para más información, consulte Carácter de espacio en blanco: \s.For more information, see White-Space Character: \s.

Si se especifica un comportamiento conforme a ECMAScript, \S es equivalente a [^ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

En el ejemplo siguiente se ilustra el elemento del lenguaje \S.The following example illustrates the \S language element. El patrón de expresión regular \b(\S+)\s? coincide con cadenas delimitadas por caracteres de espacio en blanco.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. El segundo elemento del objeto GroupCollection de la coincidencia contiene la cadena coincidente.The second element in the match's GroupCollection object contains the matched string. La expresión regular puede interpretarse como se muestra en la tabla siguiente.The regular expression can be interpreted as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
(\S+) Coincide con caracteres que no son espacio en blanco.Match one or more non-white-space characters. Este es el primer grupo de captura.This is the first capturing group.
\s? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s?"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Carácter de dígito decimal: \dDecimal digit character: \d

\d coincide con cualquier dígito decimal.\d matches any decimal digit. Equivale al patrón de expresión regular \p{Nd}, que incluye los dígitos decimales estándar 0-9 así como los dígitos decimales de varios juegos de caracteres.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Si se especifica un comportamiento conforme a ECMAScript, \d es equivalente a [0-9].If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

En el ejemplo siguiente se ilustra el elemento del lenguaje \d.The following example illustrates the \d language element. Comprueba si una cadena de entrada representa un número de teléfono válido de los Estados Unidos y Canadá.It tests whether an input string represents a valid telephone number in the United States and Canada. El patrón de expresión regular ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ se define como se muestra en la tabla siguiente.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
^ Iniciar la búsqueda de coincidencias con el principio de la cadena de entrada.Begin the match at the beginning of the input string.
\(? Coincide con cero o un carácter "(" literal.Match zero or one literal "(" character.
\d{3} Coincide con tres dígitos decimales.Match three decimal digits.
\)? Coincide con cero o un carácter ")" literal.Match zero or one literal ")" character.
[\s-] Coincide con un guion o un carácter de espacio en blanco.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? Coincide cero o una vez con un paréntesis de apertura opcional seguido de tres dígitos decimales, un paréntesis de cierre opcional y un carácter de espacio en blanco o un guion.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Este es el primer grupo de captura.This is the first capturing group.
\d{3}-\d{4} Coincide con tres dígitos decimales seguidos de un guion y otros cuatro dígitos decimales.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Coincide con el final de la cadena de entrada.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444", 
                          "(212) 111-1111", "111-AB1-1111", 
                          "212-111-1111", "01 999-9999" };
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern)) 
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
      Dim inputs() As String = { "111 111-1111", "222-2222", "222 333-444", _
                                 "(212) 111-1111", "111-AB1-1111", _
                                 "212-111-1111", "01 999-9999" }
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then 
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Carácter que no sea un dígito: \DNon-digit character: \D

\D coincide con cualquier carácter que no sea un dígito.\D matches any non-digit character. Equivale al patrón de expresión regular \P{Nd}.It is equivalent to the \P{Nd} regular expression pattern.

Si se especifica un comportamiento conforme a ECMAScript, \D es equivalente a [^0-9].If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

En el ejemplo siguiente se muestra el elemento del lenguaje \D.The following example illustrates the \D language element. Comprueba si una cadena, como un número de pieza, consta de la combinación adecuada de caracteres decimales y no decimales.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. El patrón de expresión regular ^\D\d{1,5}\D*$ se define como se muestra en la tabla siguiente.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
^ Iniciar la búsqueda de coincidencias con el principio de la cadena de entrada.Begin the match at the beginning of the input string.
\D Coincide con un carácter que no sea un dígito.Match a non-digit character.
\d{1,5} Coincide con entre uno y cinco dígitos decimales.Match from one to five decimal digits.
\D* Coincide con cero, uno o más caracteres no decimales.Match zero, one, or more non-decimal characters.
$ Coincide con el final de la cadena de entrada.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$"; 
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; 
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^\D\d{1,5}\D*$" 
      Dim inputs() As String = { "A1039C", "AA0001", "C18A", "Y938518" } 
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:

Categorías generales Unicode compatiblesSupported Unicode general categories

Unicode define las categorías generales que se muestran en la tabla siguiente.Unicode defines the general categories listed in the following table. Para obtener más información, consulte las secciones sobre el "formato de archivo UCD" y los "valores de categorías generales" en la base de datos de caracteres Unicode.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

CategoríaCategory DESCRIPCIÓNDescription
Lu Letra, mayúsculaLetter, Uppercase
Ll Letra, minúsculaLetter, Lowercase
Lt Letra, inicial en mayúsculaLetter, Titlecase
Lm Letra, modificadorLetter, Modifier
Lo Letra, otraLetter, Other
L Todos los caracteres de letras.All letter characters. Esto incluye los caracteres Lu, Ll, Lt, Lm y Lo.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Marca, sin espaciosMark, Nonspacing
Mc Marca, con espacios y combinaciónMark, Spacing Combining
Me Marca, inclusiónMark, Enclosing
M Todas las marcas diacríticas.All diacritic marks. Esto incluye las categorías Mn, Mc y Me.This includes the Mn, Mc, and Me categories.
Nd Número, dígito decimalNumber, Decimal Digit
Nl Número, letraNumber, Letter
No Número, otroNumber, Other
N Todos los números.All numbers. Esto incluye las categorías Nd, Nl y No.This includes the Nd, Nl, and No categories.
Pc Puntuación, conectorPunctuation, Connector
Pd Puntuación, rayaPunctuation, Dash
Ps Puntuación, abrirPunctuation, Open
Pe Puntuación, cerrarPunctuation, Close
Pi Puntuación, comilla de apertura (puede comportarse como Ps o Pe, en función del uso)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Puntuación, comilla de cierre (puede comportarse como Ps o Pe, en función del uso)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Puntuación, otroPunctuation, Other
P Todos los signos de puntuación.All punctuation characters. Esto incluye las categorías Pc, Pd, Ps, Pe, Pi, Pf y Po.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Símbolo, matemáticoSymbol, Math
Sc Símbolo, divisaSymbol, Currency
Sk Símbolo, modificadorSymbol, Modifier
So Símbolo, otroSymbol, Other
S Todos los símbolos.All symbols. Esto incluye las categorías Sm, Sc, Sk y So.This includes the Sm, Sc, Sk, and So categories.
Zs Separador, espacioSeparator, Space
Zl Separador, líneaSeparator, Line
Zp Separador, párrafoSeparator, Paragraph
Z Todos los caracteres separadores.All separator characters. Esto incluye las categorías Zs, Zl y Zp.This includes the Zs, Zl, and Zp categories.
Cc Otro, controlOther, Control
Cf Otro, formatoOther, Format
Cs Otro, suplenteOther, Surrogate
Co Otro, uso privadoOther, Private Use
Cn Otro, no asignado (ningún carácter tiene esta propiedad)Other, Not Assigned (no characters have this property)
C Todos los caracteres de control.All control characters. Esto incluye las categorías Cc, Cf, Cs, Co y Cn.This includes the Cc, Cf, Cs, Co, and Cn categories.

Puede determinar la categoría Unicode de cualquier carácter concreto pasando dicho carácter al método GetUnicodeCategory.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. En el ejemplo siguiente se utiliza el método GetUnicodeCategory para determinar la categoría de cada elemento de una matriz que contiene determinados caracteres latinos.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
      
      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), 
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }
      
      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Bloques con nombre compatiblesSupported named blocks

.NET proporciona los bloques con nombre que se muestran en la tabla siguiente..NET provides the named blocks listed in the following table. El conjunto de bloques con nombre compatibles está basado en Unicode 4.0 y Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6. Para una expresión regular que utiliza bloques con nombre, consulte la sección Categoría Unicode o bloque Unicode: \p{}.For a regular expression that uses named blocks, see the Unicode category or Unicode block: \p{} section.

Intervalo de puntos de códigoCode point range Nombre del bloqueBlock name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

O bien-or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

O bien-or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse o IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

Sustracción de clases de caracteres: [grupo_base - [grupo_excluido]]Character class subtraction: [base_group - [excluded_group]]

Una clase de caracteres define un conjunto de caracteres.A character class defines a set of characters. La sustracción de clases de caracteres genera un conjunto de caracteres que es el resultado de excluir los caracteres de una clase de caracteres de otra clase de caracteres.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

Una expresión de sustracción de clases de caracteres tiene el formato siguiente:A character class subtraction expression has the following form:

[grupo_base -[ grupo_excluido]][ base_group -[ excluded_group ]]

Los corchetes ([]) y el guion (-) son obligatorios.The square brackets ([]) and hyphen (-) are mandatory. El grupo_base es un grupo de caracteres positivos o un grupo de caracteres negativos.The base_group is a positive character group or a negative character group. El componente grupo_excluido es otro grupo de caracteres positivos o negativos, u otra expresión de sustracción de clases de caracteres (es decir, pueden anidarse expresiones de sustracción de clases de caracteres).The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Por ejemplo, supongamos que tiene un grupo base formado por el intervalo de caracteres de "a" a "z".For example, suppose you have a base group that consists of the character range from "a" through "z". Para definir el conjunto de caracteres formado por el grupo base, salvo el carácter "m", utilice [a-z-[m]].To define the set of characters that consists of the base group except for the character "m", use [a-z-[m]]. Para definir el conjunto de caracteres formado por el grupo base, salvo el conjunto de caracteres "d", "j" y "p", utilice [a-z-[djp]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [a-z-[djp]]. Para definir el conjunto de caracteres formado por el grupo base, salvo el intervalo de caracteres de "m" a "p", utilice [a-z-[m-p]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Considere la expresión de sustracción de clases de caracteres anidada [a-z-[d-w-[m-o]]].Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. La expresión se evalúa desde el intervalo de caracteres más profundo hacia el exterior.The expression is evaluated from the innermost character range outward. Primero, el intervalo de caracteres de "m" a "o" se resta del intervalo de caracteres de "d" a "w", lo que da como resultado el conjunto de caracteres de "d" a "l" y de "p" a "w".First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". A continuación, ese conjunto se resta del intervalo de caracteres de "a" a "z", lo que da lugar al conjunto de caracteres [abcmnoxyz].That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

Puede utilizar cualquier clase de caracteres con la sustracción de clases de caracteres.You can use any character class with character class subtraction. Para definir el conjunto de caracteres formado por todos los caracteres Unicode desde \u0000 hasta \uFFFF, a excepción de los caracteres de espacio en blanco (\s), los caracteres de la categoría general de puntuación (\p{P}), los caracteres del bloque con nombre IsGreek (\p{IsGreek}) y el carácter de control Unicode NEXT LINE (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Elija las clases de caracteres para que una expresión de sustracción de clases de caracteres produzca resultados satisfactorios.Choose character classes for a character class subtraction expression that will yield useful results. Evite el uso de expresiones que produzcan un conjunto vacío de caracteres, que no coincidan con nada, o expresiones equivalentes al grupo base original.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. Por ejemplo, el conjunto vacío es el resultado de la expresión [\p{IsBasicLatin}-[\x00-\x7F]], que resta todos los caracteres del intervalo de caracteres IsBasicLatin de la categoría general IsBasicLatin.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. Ocurre lo mismo con el grupo base original, que es el resultado de la expresión [a-z-[0-9]].Similarly, the original base group is the result of the expression [a-z-[0-9]]. Esto se debe a que el grupo base, que está formado por el intervalo de caracteres comprendido entre las letras de la "a" a la "z", no contiene ningún carácter del grupo excluido, que es el intervalo de caracteres formado por los dígitos decimales del "0" al "9".This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

En el ejemplo siguiente se define una expresión regular, ^[0-9-[2468]]+$, que coincide con cero y con los dígitos impares de una cadena de entrada.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. La expresión regular se interpreta como se muestra en la tabla siguiente.The regular expression is interpreted as shown in the following table.

ElementoElement DESCRIPCIÓNDescription
^ Comienza la búsqueda de coincidencias al principio de la cadena de entrada.Begin the match at the start of the input string.
[0-9-[2468]]+ Coincide con una o varias apariciones de cualquier carácter del 0 al 9, salvo con el 2, 4, 6 y 8.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. En otras palabras, busca una o varias coincidencias con cero o un dígito impar.In other words, match one or more occurrences of zero or an odd digit.
$ Finalizar la búsqueda de coincidencias al final de la cadena de entrada.End the match at the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";
      
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success) 
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       13579753
//       335599901
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "123", "13579753", "3557798", "335599901" }
      Dim pattern As String = "^[0-9-[2468]]+$"
      
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

Vea tambiénSee also