Regex.IsMatch Método

Definición

Indica si la expresión regular encuentra una coincidencia en la cadena de entrada.Indicates whether the regular expression finds a match in the input string.

Sobrecargas

IsMatch(String)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en una cadena de entrada indicada.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en la cadena de entrada especificada, empezando en la posición inicial indicada en la cadena.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String)

Indica si la expresión regular especificada busca una coincidencia en la cadena de entrada indicada.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia especificadas.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se especifiquen.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

IsMatch(String)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en una cadena de entrada indicada.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

public:
 bool IsMatch(System::String ^ input);
public bool IsMatch (string input);
member this.IsMatch : string -> bool
Public Function IsMatch (input As String) As Boolean

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

Devoluciones

true si la expresión regular encuentra una coincidencia; en caso contrario, false.true if the regular expression finds a match; otherwise, false.

Excepciones

input es null.input is null.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se muestra el uso del método IsMatch(String) para determinar si una cadena es un número de pieza válido.The following example illustrates the use of the IsMatch(String) method to determine whether a string is a valid part number. La expresión regular supone que el número de pieza tiene un formato específico que consta de tres conjuntos de caracteres separados por guiones.The regular expression assumes that the part number has a specific format that consists of three sets of characters separated by hyphens. El primer conjunto, que contiene cuatro caracteres, debe constar de un carácter alfanumérico seguido de dos caracteres numéricos seguidos de un carácter alfanumérico.The first set, which contains four characters, must consist of an alphanumeric character followed by two numeric characters followed by an alphanumeric character. El segundo conjunto, que consta de tres caracteres, debe ser numérico.The second set, which consists of three characters, must be numeric. El tercer conjunto, que consta de cuatro caracteres, debe tener tres caracteres numéricos seguidos de un carácter alfanumérico.The third set, which consists of four characters, must have three numeric characters followed by an alphanumeric character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468A", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      Regex rgx = new Regex(@"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           rgx.IsMatch(partNumber) ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim rgx As New Regex("^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(rgx.IsMatch(partNumber), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

El patrón de la expresión regular es:The regular expression pattern is:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$  

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

PatrónPattern DescripciónDescription
^ Comienza la coincidencia al principio de la línea.Begin the match at the beginning of the line.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
\d{2} Coincide con dos caracteres numéricos.Match two numeric characters.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
- Buscar coincidencias con un guion.Match a hyphen.
\d{3} Coincide exactamente con tres caracteres numéricos.Match exactly three numeric characters.
(-\d{3}){2} Busque un guión seguido de tres caracteres numéricos y haga coincidir dos apariciones de este patrón.Find a hyphen followed by three numeric characters, and match two occurrences of this pattern.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
$ Finalizar la coincidencia al final de la línea.End the match at the end of the line.

Comentarios

Normalmente, el método IsMatch se usa para validar una cadena o asegurarse de que una cadena se ajusta a un patrón determinado sin recuperar esa cadena para su manipulación posterior.The IsMatch method is typically used to validate a string or to ensure that a string conforms to a particular pattern without retrieving that string for subsequent manipulation. Si desea determinar si una o más cadenas coinciden con un patrón de expresión regular y, a continuación, recuperarlas para su manipulación posterior, llame al método Match o Matches.If you want to determine whether one or more strings match a regular expression pattern and then retrieve them for subsequent manipulation, call the Match or Matches method.

Se produce la excepción RegexMatchTimeoutException si el tiempo de ejecución de la operación de búsqueda de coincidencias supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto de Regex.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no se define ningún tiempo de espera en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si se Regex.InfiniteMatchTimeoutel valor de tiempo de espera, no se produce ninguna excepción.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Consulte también:

IsMatch(String, Int32)

Indica si la expresión regular especificada en el constructor Regex encuentra una coincidencia en la cadena de entrada especificada, empezando en la posición inicial indicada en la cadena.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

public:
 bool IsMatch(System::String ^ input, int startat);
public bool IsMatch (string input, int startat);
member this.IsMatch : string * int -> bool
Public Function IsMatch (input As String, startat As Integer) As Boolean

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

startat
Int32

Posición de carácter en la que se va a iniciar la búsqueda.The character position at which to start the search.

Devoluciones

true si la expresión regular encuentra una coincidencia; en caso contrario, false.true if the regular expression finds a match; otherwise, false.

Excepciones

input es null.input is null.

startat es menor que cero o mayor que la longitud de input.startat is less than zero or greater than the length of input.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se muestra el uso del método IsMatch(String, Int32) para determinar si una cadena es un número de pieza válido.The following example illustrates the use of the IsMatch(String, Int32) method to determine whether a string is a valid part number. Busca un número de pieza que siga a un signo de dos puntos (:) carácter en una cadena.It searches for a part number that follows a colon (:) character in a string. El método IndexOf(Char) se utiliza para determinar la posición del carácter de dos puntos, que se pasa a continuación al método IsMatch(String, Int32).The IndexOf(Char) method is used to determine the position of the colon character, which is then passed to the IsMatch(String, Int32) method. La expresión regular supone que el número de pieza tiene un formato específico que consta de tres conjuntos de caracteres separados por guiones.The regular expression assumes that the part number has a specific format that consists of three sets of characters separated by hyphens. El primer conjunto, que contiene cuatro caracteres, debe constar de un carácter alfanumérico seguido de dos caracteres numéricos seguidos de un carácter alfanumérico.The first set, which contains four characters, must consist of an alphanumeric character followed by two numeric characters followed by an alphanumeric character. El segundo conjunto, que consta de tres caracteres, debe ser numérico.The second set, which consists of three characters, must be numeric. El tercer conjunto, que consta de cuatro caracteres, debe tener tres caracteres numéricos seguidos de un carácter alfanumérico.The third set, which consists of four characters, must have three numeric characters followed by an alphanumeric character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "Part Number: 1298-673-4192", "Part No: A08Z-931-468A", 
                              "_A90-123-129X", "123K-000-1230", 
                              "SKU: 0919-2893-1256" };
      Regex rgx = new Regex(@"[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
      foreach (string partNumber in partNumbers)
      {
         int start = partNumber.IndexOf(':');
         if (start >= 0)
         {
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, 
                              rgx.IsMatch(partNumber, start) ? "is" : "is not");
         }
         else
         {
            Console.WriteLine("Cannot find starting position in {0}.", partNumber);
         }
      }
   }
}
// The example displays the following output:
//       Part Number: 1298-673-4192 is a valid part number.
//       Part No: A08Z-931-468A is a valid part number.
//       Cannot find starting position in _A90-123-129X.
//       Cannot find starting position in 123K-000-1230.
//       SKU: 0919-2893-1256 is not a valid part number.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "Part Number: 1298-673-4192", "Part No: A08Z-931-468A", _
                                      "_A90-123-129X", "123K-000-1230", _
                                      "SKU: 0919-2893-1256" }
      Dim rgx As New Regex("[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Dim start As Integer = partNumber.IndexOf(":"c)
         If start >= 0 Then 
            Console.WriteLine("{0} {1} a valid part number.", _
                              partNumber, _
                              IIF(rgx.IsMatch(partNumber, start), "is", "is not"))
         Else
            Console.WriteLine("Cannot find starting position in {0}.", partNumber)
         End If                              
      Next
   End Sub
End Module
' The example displays the following output:
'       Part Number: 1298-673-4192 is a valid part number.
'       Part No: A08Z-931-468A is a valid part number.
'       Cannot find starting position in _A90-123-129X.
'       Cannot find starting position in 123K-000-1230.
'       SKU: 0919-2893-1256 is not a valid part number.

El patrón de la expresión regular es:The regular expression pattern is:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$  

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

PatrónPattern DescripciónDescription
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
\d{2} Coincide con dos caracteres numéricos.Match two numeric characters.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
- Buscar coincidencias con un guion.Match a hyphen.
\d{3} Coincide exactamente con tres caracteres numéricos.Match exactly three numeric characters.
(-\d{3}){2} Busque un guión seguido de tres caracteres numéricos y haga coincidir dos apariciones de este patrón.Find a hyphen followed by three numeric characters, and match two occurrences of this pattern.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
$ Finalizar la coincidencia al final de la línea.End the match at the end of the line.

Comentarios

Normalmente, el método IsMatch se usa para validar una cadena o asegurarse de que una cadena se ajusta a un patrón determinado sin recuperar esa cadena para su manipulación posterior.The IsMatch method is typically used to validate a string or to ensure that a string conforms to a particular pattern without retrieving that string for subsequent manipulation. Si desea determinar si una o más cadenas coinciden con un patrón de expresión regular y, a continuación, recuperarlas para su manipulación posterior, llame al método Match o Matches.If you want to determine whether one or more strings match a regular expression pattern and then retrieve them for subsequent manipulation, call the Match or Matches method.

Se produce la excepción RegexMatchTimeoutException si el tiempo de ejecución de la operación de búsqueda de coincidencias supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto de Regex.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no se define ningún tiempo de espera en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si se Regex.InfiniteMatchTimeoutel valor de tiempo de espera, no se produce ninguna excepción.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Consulte también:

IsMatch(String, String)

Indica si la expresión regular especificada busca una coincidencia en la cadena de entrada indicada.Indicates whether the specified regular expression finds a match in the specified input string.

public:
 static bool IsMatch(System::String ^ input, System::String ^ pattern);
public static bool IsMatch (string input, string pattern);
static member IsMatch : string * string -> bool
Public Shared Function IsMatch (input As String, pattern As String) As Boolean

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

El modelo de la expresión regular que debe coincidir.The regular expression pattern to match.

Devoluciones

true si la expresión regular encuentra una coincidencia; en caso contrario, false.true if the regular expression finds a match; otherwise, false.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se muestra el uso del método IsMatch(String, String) para determinar si una cadena es un número de pieza válido.The following example illustrates the use of the IsMatch(String, String) method to determine whether a string is a valid part number. La expresión regular supone que el número de pieza tiene un formato específico que consta de tres conjuntos de caracteres separados por guiones.The regular expression assumes that the part number has a specific format that consists of three sets of characters separated by hyphens. El primer conjunto, que contiene cuatro caracteres, debe constar de un carácter alfanumérico seguido de dos caracteres numéricos seguidos de un carácter alfanumérico.The first set, which contains four characters, must consist of an alphanumeric character followed by two numeric characters followed by an alphanumeric character. El segundo conjunto, que consta de tres caracteres, debe ser numérico.The second set, which consists of three characters, must be numeric. El tercer conjunto, que consta de cuatro caracteres, debe tener tres caracteres numéricos seguidos de un carácter alfanumérico.The third set, which consists of four characters, must have three numeric characters followed by an alphanumeric character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468A", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$";
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           Regex.IsMatch(partNumber, pattern) ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

El patrón de la expresión regular es:The regular expression pattern is:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$  

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

PatrónPattern DescripciónDescription
^ Comienza la coincidencia al principio de la línea.Begin the match at the beginning of the line.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
\d{2} Coincide con dos caracteres numéricos.Match two numeric characters.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
- Buscar coincidencias con un guion.Match a hyphen.
\d{3} Coincide exactamente con tres caracteres numéricos.Match exactly three numeric characters.
(-\d{3}){2} Busque un guión seguido de tres caracteres numéricos y haga coincidir dos apariciones de este patrón.Find a hyphen followed by three numeric characters, and match two occurrences of this pattern.
[a-zA-Z0-9] Coincide con un carácter alfabético único (a a través de z o A a Z) o un carácter numérico.Match a single alphabetic character (a through z or A through Z) or numeric character.
$ Finalizar la coincidencia al final de la línea.End the match at the end of the line.

Comentarios

Normalmente, el método IsMatch se usa para validar una cadena o asegurarse de que una cadena se ajusta a un patrón determinado sin recuperar esa cadena para su manipulación posterior.The IsMatch method is typically used to validate a string or to ensure that a string conforms to a particular pattern without retrieving that string for subsequent manipulation. Si desea determinar si una o más cadenas coinciden con un patrón de expresión regular y, a continuación, recuperarlas para su manipulación posterior, llame al método Match o Matches.If you want to determine whether one or more strings match a regular expression pattern and then retrieve them for subsequent manipulation, call the Match or Matches method.

El método estático IsMatch(String, String) es equivalente a construir un objeto Regex con el patrón de expresión regular especificado por pattern y llamar al método de instancia de IsMatch(String).The static IsMatch(String, String) method is equivalent to constructing a Regex object with the regular expression pattern specified by pattern and calling the IsMatch(String) instance method. Este patrón de expresión regular se almacena en la memoria caché para que el motor de expresiones regulares la recupere rápidamente.This regular expression pattern is cached for rapid retrieval by the regular expression engine.

El parámetro pattern consta de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Se produce la excepción RegexMatchTimeoutException si el tiempo de ejecución de la operación de coincidencia supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si se Regex.InfiniteMatchTimeoutel valor de tiempo de espera, no se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se utiliza el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para comprobar una coincidencia de patrón es IsMatch(String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.The recommended static method for verifying a pattern match is IsMatch(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consulte también:

IsMatch(String, String, RegexOptions)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia especificadas.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

public:
 static bool IsMatch(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static bool IsMatch (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member IsMatch : string * string * System.Text.RegularExpressions.RegexOptions -> bool
Public Shared Function IsMatch (input As String, pattern As String, options As RegexOptions) As Boolean

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

El modelo de la expresión regular que debe coincidir.The regular expression pattern to match.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.A bitwise combination of the enumeration values that provide options for matching.

Devoluciones

true si la expresión regular encuentra una coincidencia; en caso contrario, false.true if the regular expression finds a match; otherwise, false.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es un valor RegexOptions válido.options is not a valid RegexOptions value.

Se agotó el tiempo de espera.A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios.For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se muestra el uso del método IsMatch(String, String) para determinar si una cadena es un número de pieza válido.The following example illustrates the use of the IsMatch(String, String) method to determine whether a string is a valid part number. La expresión regular supone que el número de pieza tiene un formato específico que consta de tres conjuntos de caracteres separados por guiones.The regular expression assumes that the part number has a specific format that consists of three sets of characters separated by hyphens. El primer conjunto, que contiene cuatro caracteres, debe constar de un carácter alfanumérico seguido de dos caracteres numéricos seguidos de un carácter alfanumérico.The first set, which contains four characters, must consist of an alphanumeric character followed by two numeric characters followed by an alphanumeric character. El segundo conjunto, que consta de tres caracteres, debe ser numérico.The second set, which consists of three characters, must be numeric. El tercer conjunto, que consta de cuatro caracteres, debe tener tres caracteres numéricos seguidos de un carácter alfanumérico.The third set, which consists of four characters, must have three numeric characters followed by an alphanumeric character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468a", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
      foreach (string partNumber in partNumbers)
         Console.WriteLine("{0} {1} a valid part number.", 
                           partNumber, 
                           Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) 
                                         ? "is" : "is not");
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                               "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

El patrón de la expresión regular es:The regular expression pattern is:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$  

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

PatrónPattern DescripciónDescription
^ Empieza la búsqueda de coincidencias en el principio de la cadena.Begin the match at the beginning of the string.
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
\d{2} Coincide con dos caracteres numéricos.Match two numeric characters.
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
- Buscar coincidencias con un guion.Match a hyphen.
\d{3} Coincide exactamente con tres caracteres numéricos.Match exactly three numeric characters.
(-\d{3}){2} Busque un guión seguido de tres caracteres numéricos y haga coincidir dos apariciones de este patrón.Find a hyphen followed by three numeric characters, and match two occurrences of this pattern..
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
$ Finalizar la búsqueda al final de la cadena.End the match at the end of the string.

Llamar al método IsMatch(String, String, RegexOptions) con el parámetro options establecido en RegexOptions.IgnoreCase es equivalente a definir la expresión regular siguiente:Calling the IsMatch(String, String, RegexOptions) method with the options parameter set to RegexOptions.IgnoreCase is equivalent to defining the following regular expression:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]  

Para realizar una comparación, vea el ejemplo del método IsMatch(String, String).For comparison, see the example for the IsMatch(String, String) method.

Comentarios

Normalmente, el método IsMatch se usa para validar una cadena o asegurarse de que una cadena se ajusta a un patrón determinado sin recuperar esa cadena para su manipulación posterior.The IsMatch method is typically used to validate a string or to ensure that a string conforms to a particular pattern without retrieving that string for subsequent manipulation. Si desea determinar si una o más cadenas coinciden con un patrón de expresión regular y, a continuación, recuperarlas para su manipulación posterior, llame al método Match o Matches.If you want to determine whether one or more strings match a regular expression pattern and then retrieve them for subsequent manipulation, call the Match or Matches method.

El método IsMatch(String, String, RegexOptions) estático es equivalente a construir un objeto Regex con el patrón de expresión regular especificado por pattern y las opciones de expresión regular especificadas por options y llamar al método de instancia IsMatch(String).The static IsMatch(String, String, RegexOptions) method is equivalent to constructing a Regex object with the regular expression pattern specified by pattern and the regular expression options specified by options and calling the IsMatch(String) instance method. Este patrón de expresión regular se almacena en la memoria caché para que el motor de expresiones regulares la recupere rápidamente.This regular expression pattern is cached for rapid retrieval by the regular expression engine.

El parámetro pattern consta de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Se produce la excepción RegexMatchTimeoutException si el tiempo de ejecución de la operación de coincidencia supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si se Regex.InfiniteMatchTimeoutel valor de tiempo de espera, no se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se utiliza el valor InfiniteMatchTimeout, lo que impide que se agote el tiempo de espera del método.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para comprobar una coincidencia de patrón es IsMatch(String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera.The recommended static method for verifying a pattern match is IsMatch(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consulte también:

IsMatch(String, String, RegexOptions, TimeSpan)

Indica si la expresión regular especificada encuentra una coincidencia en la cadena de entrada indicada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se especifiquen.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

public:
 static bool IsMatch(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static bool IsMatch (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member IsMatch : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> bool
Public Shared Function IsMatch (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Boolean

Parámetros

input
String

Cadena en la que se va a buscar una coincidencia.The string to search for a match.

pattern
String

El modelo de la expresión regular que debe coincidir.The regular expression pattern to match.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Devoluciones

true si la expresión regular encuentra una coincidencia; en caso contrario, false.true if the regular expression finds a match; otherwise, false.

Excepciones

Se produjo un error de análisis de expresión regular.A regular expression parsing error occurred.

El valor de input o pattern es null.input or pattern is null.

options no es un valor RegexOptions válido.options is not a valid RegexOptions value.

O bien-or- matchTimeout es negativo, cero o mayor que 24 días aproximadamente.matchTimeout is negative, zero, or greater than approximately 24 days.

Se agotó el tiempo de espera.A time-out occurred.

Ejemplos

En el ejemplo siguiente se muestra el uso del método IsMatch(String, String, RegexOptions, TimeSpan) para determinar si una cadena es un número de pieza válido.The following example illustrates the use of the IsMatch(String, String, RegexOptions, TimeSpan) method to determine whether a string is a valid part number. La expresión regular supone que el número de pieza tiene un formato específico que consta de tres conjuntos de caracteres separados por guiones.The regular expression assumes that the part number has a specific format that consists of three sets of characters separated by hyphens. El primer conjunto, que contiene cuatro caracteres, debe constar de un carácter alfanumérico seguido de dos caracteres numéricos seguidos de un carácter alfanumérico.The first set, which contains four characters, must consist of an alphanumeric character followed by two numeric characters followed by an alphanumeric character. El segundo conjunto, que consta de tres caracteres, debe ser numérico.The second set, which consists of three characters, must be numeric. El tercer conjunto, que consta de cuatro caracteres, debe tener tres caracteres numéricos seguidos de un carácter alfanumérico.The third set, which consists of four characters, must have three numeric characters followed by an alphanumeric character. La coincidencia del patrón de expresión regular debe implicar una búsqueda mínima a través de la cadena de entrada, por lo que el método establece un intervalo de tiempo de espera de 500 milisegundos.Matching the regular expression pattern should involve minimal searching through the input string, so the method sets a time-out interval of 500 milliseconds.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] partNumbers= { "1298-673-4192", "A08Z-931-468a", 
                              "_A90-123-129X", "12345-KKA-1230", 
                              "0919-2893-1256" };
      string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
      foreach (string partNumber in partNumbers)
         try {
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, 
                              Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) 
                                            ? "is" : "is not", TimeSpan.FromMilliseconds(500));
         }
         catch (RegexMatchTimeoutException e) {
            Console.WriteLine("Timeout after {0} seconds matching {1}.",
                              e.MatchTimeout, e.Input);
         }
   }
}
// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", 
                                      "_A90-123-129X", "12345-KKA-1230", 
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Try
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, _
                              IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                                  "is", "is not"),
                              TimeSpan.FromMilliseconds(500))
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("Timeout after {0} seconds matching {1}.",
                              e.MatchTimeout, e.Input)
         End Try
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

El patrón de la expresión regular es:The regular expression pattern is:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$  

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

PatrónPattern DescripciónDescription
^ Empieza la búsqueda de coincidencias en el principio de la cadena.Begin the match at the beginning of the string.
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
\d{2} Coincide con dos caracteres numéricos.Match two numeric characters.
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
- Buscar coincidencias con un guion.Match a hyphen.
\d{3} Coincide exactamente con tres caracteres numéricos.Match exactly three numeric characters.
(-\d{3}){2} Busque un guión seguido de tres caracteres numéricos y haga coincidir dos apariciones de este patrón.Find a hyphen followed by three numeric characters, and match two occurrences of this pattern.
[A-Z0-9] Coincide con cualquier carácter alfabético único de A a través de Z, o cualquier carácter numérico.Match any single alphabetic character from A through Z, or any numeric character.
$ Finalizar la búsqueda al final de la cadena.End the match at the end of the string.

Llamar al método IsMatch(String, String, RegexOptions, TimeSpan) con el parámetro options establecido en RegexOptions.IgnoreCase es equivalente a definir la expresión regular siguiente:Calling the IsMatch(String, String, RegexOptions, TimeSpan) method with the options parameter set to RegexOptions.IgnoreCase is equivalent to defining the following regular expression:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]  

Para realizar una comparación, vea el ejemplo del método IsMatch(String, String).For comparison, see the example for the IsMatch(String, String) method.

Comentarios

Normalmente, el método IsMatch se usa para validar una cadena o asegurarse de que una cadena se ajusta a un patrón determinado sin recuperar esa cadena para su manipulación posterior.The IsMatch method is typically used to validate a string or to ensure that a string conforms to a particular pattern without retrieving that string for subsequent manipulation. Si desea determinar si una o más cadenas coinciden con un patrón de expresión regular y, a continuación, recuperarlas para su manipulación posterior, llame al método Match o Matches.If you want to determine whether one or more strings match a regular expression pattern and then retrieve them for subsequent manipulation, call the Match or Matches method.

El método IsMatch(String, String, RegexOptions, TimeSpan) estático es equivalente a construir un objeto Regex con el patrón de expresión regular especificado por pattern y las opciones de expresión regular especificadas por options y llamar al método de instancia IsMatch(String).The static IsMatch(String, String, RegexOptions, TimeSpan) method is equivalent to constructing a Regex object with the regular expression pattern specified by pattern and the regular expression options specified by options and calling the IsMatch(String) instance method. Este patrón de expresión regular se almacena en la memoria caché para que el motor de expresiones regulares la recupere rápidamente.This regular expression pattern is cached for rapid retrieval by the regular expression engine.

El parámetro pattern consta de elementos de lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea .NET Framework expresiones regulares y el lenguaje de expresiones regulares: referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar buscar una coincidencia antes de que se agote el tiempo de espera. Establecer un intervalo de tiempo de espera evita que las expresiones regulares que dependen de un retroceso excesivo parezcan dejar de responder cuando procesan entradas que contienen coincidencias cercanas.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Para obtener más información, vea procedimientos recomendados para expresiones regulares y retroceso.For more information, see Best Practices for Regular Expressions and Backtracking. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Sin embargo, solo debe deshabilitar los tiempos de espera en las siguientes condiciones:However, you should disable time-outs only under the following conditions: : Cuando la entrada procesada por una expresión regular se deriva de una fuente conocida y de confianza o está formada por texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Esto excluye el texto que los usuarios han introducido dinámicamente.This excludes text that has been dynamically input by users.

-Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla de forma eficaz las coincidencias, las no coincidencias y las coincidencias cercanas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que producen un retroceso excesivo al procesar una coincidencia cercana.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Consulte también:

Se aplica a