Compartir vía

Regex.Split Método

  • Referencia

Definición

Espacio de nombres:
System.Text.RegularExpressions
Ensamblado:
System.Text.RegularExpressions.dll
Ensamblado:
System.dll
Ensamblado:
netstandard.dll

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por una coincidencia de expresión regular.

Sobrecargas

Split(String, String, RegexOptions, TimeSpan)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado. Los parámetros adicionales especifican opciones que modifican la operación coincidente y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.
Split(String, String, RegexOptions)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado. Las opciones especificadas modifican la operación de coincidencia.
Split(String, Int32, Int32)

Divide una cadena de entrada un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex. La búsqueda del patrón de expresión regular comienza en una posición de carácter especificada en la cadena de entrada.
Split(String, String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular.
Split(String)

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado en el constructor de Regex.
Split(String, Int32)

Divide una cadena de entrada un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.

Split(String, String, RegexOptions, TimeSpan)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado. Los parámetros adicionales especifican opciones que modifican la operación coincidente y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

Parámetros

input
String

Cadena que se va a dividir.

pattern
String

Patrón de expresión regular que se va a coincidir.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones para la coincidencia.

matchTimeout
TimeSpan

Intervalo de tiempo de espera o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de RegexOptions valores.

-o-

matchTimeout es negativo, cero o mayor que aproximadamente 24 días.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Importante

Las expresiones regulares compiladas usadas en llamadas a métodos de Split estáticos se almacenan automáticamente en caché. Para administrar la duración de las expresiones regulares compiladas usted mismo, use los métodos Split de instancia.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición donde se encuentran dos guiones adyacentes.

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta. En el ejemplo siguiente se usa el patrón de expresión regular [a-z]+ para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz devuelta es String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si se usan paréntesis de captura en una expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Si la expresión regular puede coincidir con la cadena vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación.

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

  • Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

  • Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

  • Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

Se aplica a

Split(String, String, RegexOptions)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado. Las opciones especificadas modifican la operación de coincidencia.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

Parámetros

input
String

Cadena que se va a dividir.

pattern
String

Patrón de expresión regular que se va a coincidir.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones para la coincidencia.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

ArgumentOutOfRangeException

options no es una combinación bit a bit válida de RegexOptions valores.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Importante

Las expresiones regulares compiladas usadas en llamadas a métodos de Split estáticos se almacenan automáticamente en caché. Para administrar la duración de las expresiones regulares compiladas usted mismo, use los métodos Split de instancia.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición donde se encuentran dos guiones adyacentes.

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta. En el ejemplo siguiente se usa el patrón de expresión regular [a-z]+ para dividir una cadena de entrada en cualquier carácter alfabético en mayúsculas o minúsculas. Dado que la cadena comienza y termina con caracteres alfabéticos coincidentes, el valor del primer y último elemento de la matriz devuelta es String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Si se usan paréntesis de captura en una expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Si la expresión regular puede coincidir con la cadena vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método . Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

Split(String, Int32, Int32)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex. La búsqueda del patrón de expresión regular comienza en una posición de carácter especificada en la cadena de entrada.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);
public string[] Split (string input, int count, int startat);
member this.Split : string * int * int -> string[]
Public Function Split (input As String, count As Integer, startat As Integer) As String()

Parámetros

input
String

Cadena que se va a dividir.

count
Int32

Número máximo de veces que se puede producir la división.

startat
Int32

Posición del carácter en la cadena de entrada donde comenzará la búsqueda.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentNullException

input es null.

ArgumentOutOfRangeException

startat es menor que cero o mayor que la longitud de input.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. El parámetro count especifica el número máximo de subcadenas en las que se divide la cadena input; la última cadena contiene el resto sin dividir de la cadena. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible. El parámetro startat define el punto en el que comienza la búsqueda del primer delimitador (se puede usar para omitir el espacio en blanco inicial).

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

Si no se encuentran coincidencias desde la posición count+1 de la cadena, el método devuelve una matriz de un elemento que contiene la cadena input. Si se encuentran una o varias coincidencias, el primer elemento de la matriz devuelta contiene la primera parte de la cadena del primer carácter hasta un carácter antes de la coincidencia.

Si hay varias coincidencias adyacentes entre sí y el número de coincidencias encontradas es al menos dos menos que count, se inserta una cadena vacía en la matriz. Del mismo modo, si se encuentra una coincidencia en startat, que es el primer carácter de la cadena, el primer elemento de la matriz devuelta es una cadena vacía. Es decir, las cadenas vacías resultantes de coincidencias adyacentes se cuentan para determinar si el número de subcadenas coincidentes es igual a count. En el ejemplo siguiente, la expresión regular \d+ se usa para buscar la posición inicial de la primera subcadena de caracteres numéricos en una cadena y, a continuación, para dividir la cadena un máximo de tres veces a partir de esa posición. Dado que el patrón de expresión regular coincide con el principio de la cadena de entrada, la matriz de cadenas devuelta consta de una cadena vacía, una cadena alfabética de cinco caracteres y el resto de la cadena,

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si se usan paréntesis de captura en una expresión regular, cualquier texto capturado se incluye en la matriz de cadenas divididas. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si el número de coincidencias ha alcanzado count. Por ejemplo, dividir la cadena '"apple-apricot-plum-pear-pomegranate-piña-melocotón" en un máximo de cuatro subcadenas a partir del carácter 15 de la cadena da como resultado una matriz de siete elementos, como se muestra en el código siguiente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia dentro del primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer las palabras individuales de una cadena. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra vertical. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra vertical; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Si la expresión regular puede coincidir con la cadena vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. En el ejemplo siguiente se divide la cadena "characters" en tantos elementos como contiene la cadena de entrada, empezando por el carácter "a". Dado que la cadena null coincide con el final de la cadena de entrada, se inserta una cadena null al final de la matriz devuelta.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

Se aplica a

Split(String, String)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);
public static string[] Split (string input, string pattern);
static member Split : string * string -> string[]
Public Shared Function Split (input As String, pattern As String) As String()

Parámetros

input
String

Cadena que se va a dividir.

pattern
String

Patrón de expresión regular que se va a coincidir.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input o pattern es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena input se divide tantas veces como sea posible. Si no se encuentra pattern en la cadena input, el valor devuelto contiene un elemento cuyo valor es la cadena de input original.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Importante

Las expresiones regulares compiladas usadas en llamadas a métodos de Split estáticos se almacenan automáticamente en caché. Para administrar la duración de las expresiones regulares compiladas usted mismo, use los métodos Split de instancia.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentran dos guiones adyacentes, como se muestra en el código siguiente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta. En el ejemplo siguiente se usa el patrón de expresión regular \d+ para dividir una cadena de entrada en caracteres numéricos. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la matriz devuelta es String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si se usan paréntesis de captura en una expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Si la expresión regular puede coincidir con la cadena vacía, Split dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. Por ejemplo:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Tenga en cuenta que la matriz devuelta también incluye una cadena vacía al principio y al final de la matriz.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama al método . Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para dividir texto en una coincidencia de patrones es Split(String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

Split(String)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada en una matriz de subcadenas en las posiciones definidas por un patrón de expresión regular especificado en el constructor de Regex.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);
public string[] Split (string input);
member this.Split : string -> string[]
Public Function Split (input As String) As String()

Parámetros

input
String

Cadena que se va a dividir.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentNullException

input es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split(Char[]), salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. La cadena se divide tantas veces como sea posible. Si no se encuentra ningún delimitador, el valor devuelto contiene un elemento cuyo valor es la cadena de entrada original.

Si hay varias coincidencias adyacentes entre sí, se inserta una cadena vacía en la matriz. Por ejemplo, dividir una cadena en un solo guión hace que la matriz devuelta incluya una cadena vacía en la posición en la que se encuentran dos guiones adyacentes, como se muestra en el código siguiente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

Si se encuentra una coincidencia al principio o al final de la cadena de entrada, se incluye una cadena vacía al principio o al final de la matriz devuelta. En el ejemplo siguiente se usa el patrón de expresión regular \d+ para dividir una cadena de entrada en caracteres numéricos. Dado que la cadena comienza y termina con caracteres numéricos coincidentes, el valor del primer y último elemento de la matriz devuelta es String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Si se usan paréntesis de captura en una expresión de Regex.Split, cualquier texto capturado se incluye en la matriz de cadenas resultante. Por ejemplo, si divide la cadena "plum-pear" en un guión colocado dentro de los paréntesis de captura, la matriz devuelta incluye un elemento de cadena que contiene el guión.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, si no se encuentra una coincidencia en el primer conjunto de paréntesis de captura, el texto capturado de paréntesis de captura adicional no se incluye en la matriz devuelta. A partir de .NET Framework 2.0, todo el texto capturado también se agrega a la matriz devuelta. Por ejemplo, el código siguiente usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha, incluidos los delimitadores de fecha, de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, excluye los caracteres de barra diagonal; si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, los incluye.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Si la expresión regular puede coincidir con la cadena vacía, Split(String) dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. Por ejemplo:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }

Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

Tenga en cuenta que la matriz devuelta también incluye una cadena vacía al principio y al final de la matriz.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

Se aplica a

Split(String, Int32)

Source:
Regex.Split.cs
Source:
Regex.Split.cs
Source:
Regex.Split.cs

Divide una cadena de entrada un número máximo especificado de veces en una matriz de subcadenas, en las posiciones definidas por una expresión regular especificada en el constructor Regex.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count);
public string[] Split (string input, int count);
member this.Split : string * int -> string[]
Public Function Split (input As String, count As Integer) As String()

Parámetros

input
String

Cadena que se va a dividir.

count
Int32

Número máximo de veces que se puede producir la división.

Devoluciones

String[]

Matriz de cadenas.

Excepciones

ArgumentNullException

input es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener más información sobre los tiempos de espera, vea la sección Comentarios.

Comentarios

Los métodos Regex.Split son similares al método String.Split, salvo que Regex.Split divide la cadena en un delimitador determinado por una expresión regular en lugar de un conjunto de caracteres. El parámetro count especifica el número máximo de subcadenas en las que se puede dividir la cadena input; la última cadena contiene el resto sin dividir de la cadena. Un count valor de cero proporciona el comportamiento predeterminado de dividir tantas veces como sea posible.

Si hay varias coincidencias adyacentes entre sí o si se encuentra una coincidencia al principio o al final de input, y el número de coincidencias encontradas es al menos dos menos que count, se inserta una cadena vacía en la matriz. Es decir, las cadenas vacías resultantes de coincidencias adyacentes o de coincidencias al principio o al final de la cadena de entrada se cuentan para determinar si el número de subcadenas coincidentes es igual a count. En el ejemplo siguiente, la expresión regular /d+ se usa para dividir una cadena de entrada que incluya uno o varios dígitos decimales en un máximo de tres subcadenas. Dado que el principio de la cadena de entrada coincide con el patrón de expresión regular, el primer elemento de matriz contiene String.Empty, el segundo contiene el primer conjunto de caracteres alfabéticos en la cadena de entrada y el tercero contiene el resto de la cadena que sigue a la tercera coincidencia.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Si se usan paréntesis de captura en una expresión regular, cualquier texto capturado se incluye en la matriz de cadenas divididas. Sin embargo, los elementos de matriz que contienen texto capturado no se cuentan para determinar si el número de coincidencias ha alcanzado count. Por ejemplo, dividir la cadena "apple-apricot-plum-pear-banana" en un máximo de cuatro subcadenas da como resultado una matriz de siete elementos, como se muestra en el código siguiente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'

Sin embargo, cuando el patrón de expresión regular incluye varios conjuntos de paréntesis de captura, el comportamiento de este método depende de la versión de .NET Framework. En .NET Framework 1.0 y 1.1, solo se incluye texto capturado del primer conjunto de paréntesis de captura en la matriz devuelta. A partir de .NET Framework 2.0, se agrega todo el texto capturado a la matriz devuelta. Sin embargo, los elementos de la matriz devuelta que contienen texto capturado no se cuentan para determinar si el número de subcadenas coincidentes es igual a count. Por ejemplo, en el código siguiente, una expresión regular usa dos conjuntos de paréntesis de captura para extraer los elementos de una fecha de una cadena de fecha. El primer conjunto de captura de paréntesis captura el guión y el segundo conjunto captura la barra diagonal. A continuación, la llamada al método Split(String, Int32) especifica un máximo de dos elementos en la matriz devuelta. Si el código de ejemplo se compila y se ejecuta en .NET Framework 1.0 o 1.1, el método devuelve una matriz de cadenas de dos elementos. Si se compila y se ejecuta en .NET Framework 2.0 o versiones posteriores, el método devuelve una matriz de cadenas de tres elementos.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007'

Si la expresión regular puede coincidir con la cadena vacía, Split(String, Int32) dividirá la cadena en una matriz de cadenas de un solo carácter porque el delimitador de cadena vacío se puede encontrar en cada ubicación. En el ejemplo siguiente se divide la cadena "caracteres" en tantos elementos como haya en la cadena de entrada. Dado que la cadena null coincide con el principio de la cadena de entrada, se inserta una cadena null al principio de la matriz devuelta. Esto hace que el décimo elemento conste de los dos caracteres al final de la cadena de entrada.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de división supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

Se aplica a