Split Método (String[], StringSplitOptions)
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

String.Split (Método) (String[], StringSplitOptions)

 

Divide una cadena en subcadenas en función de las cadenas de una matriz. Puede especificar si las subcadenas incluyen elementos de matriz vacíos.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(false)]
public string[] Split(
	string[] separator,
	StringSplitOptions options
)

Parámetros

separator
Type: System.String[]

Matriz de cadenas que delimitan las subcadenas de esta cadena, una matriz vacía sin delimitadores o null.

options
Type: System.StringSplitOptions

StringSplitOptions.RemoveEmptyEntries para omitir los elementos de matriz vacíos de la matriz devuelta; o bien, StringSplitOptions.None para incluir los elementos de matriz vacíos en la matriz devuelta.

Valor devuelto

Type: System.String[]

Una matriz cuyos elementos contienen las subcadenas de esta cadena que están delimitadas por una o varias cadenas de separator. Para obtener más información, vea la sección Comentarios.

Exception Condition
ArgumentException

options no es uno de los valores de StringSplitOptions.

Cuando una cadena está delimitada por un conjunto conocido de cadenas, puede utilizar el Split método para separar en subcadenas.

Las cadenas delimitadoras no se incluyen en los elementos de la matriz devuelta. Por ejemplo, si la separator matriz incluye la cadena "--" y el valor de la instancia de cadena actual es "aa: bb cc", el método devuelve una matriz que contiene tres elementos: "aa", "bb" y "cc".

Si esta instancia no contiene ninguna de las cadenas de separator, la matriz devuelta constará de un solo elemento que contiene esta instancia.

Si el options parámetro es RemoveEmptyEntries y la longitud de esta instancia es cero, el método devuelve una matriz vacía.

Cada elemento de separator define un delimitador independiente que consta de uno o más caracteres. Si el options argumento es None, y dos delimitadores son adyacentes o se encuentra un delimitador al principio o al final de esta instancia, el elemento de matriz correspondiente contiene String.Empty. Por ejemplo, si separator incluye dos elementos, "-" y "_", el valor de la instancia de la cadena es "- _aa-_" y el valor de la options argumento es None, el método devuelve una matriz de cadena con los siguientes cinco elementos:

  1. String.Empty, que representa la cadena vacía que precede a la "-" subcadena en el índice 0.

  2. String.Empty, que representa la cadena vacía entre el "-" subcadena en el índice 0 y la subcadena "_" en el índice 1.

  3. "aa",

  4. String.Empty, que representa la cadena vacía que sigue a la subcadena "_" en el índice 4.

  5. String.Empty, que representa la cadena vacía que sigue a la "-" subcadena al índice 5.

Si alguno de los elementos de separator consta de varios caracteres, toda la subcadena se considera un delimitador. Por ejemplo, si uno de los elementos de separator es "10", intente dividir la cadena "This10is10a10string." Devuelve la siguiente matriz de cuatro elementos: {"This", "es", "a", "string". }.

Si el separator parámetro es null o no contiene caracteres, se supone que los caracteres de espacio en blanco son los delimitadores. Caracteres de espacio en blanco se definen mediante Unicode estándar y devolver true Si se pasan a la Char.IsWhiteSpace (método).

Si el separator parámetro en la llamada a esta sobrecarga del método es null, se produce un error en la resolución de sobrecarga de compilador. Para identificar de forma inequívoca el método llamado, el código debe indicar el tipo de la null. En el ejemplo siguiente se muestra varias maneras de identificar inequívocamente esta sobrecarga.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);

El Split método extrae las subcadenas de esta cadena que están delimitadas por uno o más de las cadenas en el separator parámetro y devuelve esas subcadenas como elementos de una matriz.

El Split método busca los delimitadores realizando comparaciones mediante las reglas de ordenación ordinal entre mayúsculas y minúsculas. Para obtener más información acerca de la ordenación de palabras, cadena y ordinal, vea el System.Globalization.CompareOptions (enumeración).

El Split método omite cualquier elemento de separator cuyo valor es null o una cadena vacía ("").

Para evitar resultados ambiguos cuando las cadenas en separator tienen caracteres en común, la Split operación continúa desde el principio hasta el final del valor de la instancia y compara el primer elemento de separator que es igual a un delimitador en la instancia. El orden en el que se encuentran las subcadenas en la instancia tiene prioridad sobre el orden de los elementos de separator.

Por ejemplo, consideremos una instancia cuyo valor es "abcdef". Si el primer elemento de separator era "ef" y el segundo elemento es "bcde", el resultado de la operación de división será una matriz de cadenas que contiene dos elementos, "a" y "f". Esto es porque la subcadena de la instancia "bcde", se encuentra y coincide con un elemento de separator antes de que se encuentra la subcadena "f".

Sin embargo, si el primer elemento de separator era "bcd" y el segundo elemento es "bc", el resultado de la operación de división será una matriz de cadenas que contiene dos elementos, "a" y "ef". Esto es porque "bcd" es el primer delimitador en separator que coincide con un delimitador en la instancia. Si se invierte el orden de los separadores para el primer elemento es "bc" y el segundo elemento es "bcd", el resultado sería una matriz de cadenas que contiene dos elementos, "a" y "def".

El Split métodos asignan memoria para el objeto de matriz devuelta y un String objeto para cada elemento de matriz. Si la aplicación requiere un rendimiento óptimo o administrar la asignación de memoria es fundamental en la aplicación, considere el uso de la IndexOf o IndexOfAny (método) y, opcionalmente, el Compare método para buscar una subcadena dentro de una cadena.

Si va a dividir una cadena en un carácter separador, utilice el IndexOf o IndexOfAny método para buscar un carácter separador en la cadena. Si va a dividir una cadena en una cadena separadora, utilice el IndexOf o IndexOfAny método para buscar el primer carácter de la cadena de separador. A continuación, utilice el Compare método para determinar si los caracteres situados detrás de ese primer carácter son iguales a los caracteres restantes de la cadena de separador.

Además, si el mismo conjunto de caracteres se utiliza para dividir las cadenas en varios Split llamadas de método, considere la posibilidad de crear una sola matriz y hacer referencia a ella en cada llamada al método. Esto reduce considerablemente la sobrecarga adicional de cada llamada al método.

Notas para los llamadores:

En el .NET Framework 3,5 y versiones anteriores, si la Split se pasa al método un separator es null o no contiene caracteres, el método usa un conjunto de caracteres ligeramente diferente para dividir la cadena de la Trim método no recorte la cadena. En el .NET Framework 4, ambos métodos usan un conjunto idéntico de caracteres de espacio en blanco de Unicode.

En el ejemplo siguiente se ilustra la diferencia entre las matrices devueltas por una llamada a una cadena String.Split(String[], StringSplitOptions) método con su options igual al parámetro StringSplitOptions.None y StringSplitOptions.RemoveEmptyEntries.

using System;

class Example 
{
   public static void Main() 
   {
      string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
      string[] stringSeparators = new string[] {"[stop]"};
      string[] result;

      // Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
      Console.WriteLine();
      Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                        stringSeparators[0]);
      Console.WriteLine();                           

      // Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None);
      Console.WriteLine("Result including all elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
      Console.WriteLine();

      // Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, 
                            StringSplitOptions.RemoveEmptyEntries);
      Console.WriteLine("Result including non-empty elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    Result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    Result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'

En el ejemplo siguiente se define una matriz de los separadores que incluyen signos de puntuación y caracteres de espacio en blanco. Pasa esta matriz junto con un valor de StringSplitOptions.RemoveEmptyEntries para el Split(String[], StringSplitOptions) método devuelve una matriz que consta de las palabras individuales de la cadena.

using System;

public class Example
{
   public static void Main()
   {
      string[] separators = {",", ".", "!", "?", ";", ":", " "};
      string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
      string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
      foreach (var word in words)
         Console.WriteLine(word);
   }
}
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate

Note that the method is called with the options argument set to F:System.StringSplitOptions.RemoveEmptyEntries. This prevents the returned array from includingF:System.String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Universal Windows Platform
Disponible desde 8
.NET Framework
Disponible desde 2.0
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar:
© 2016 Microsoft