Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

String.Split, méthode (String[], StringSplitOptions)

 

Fractionne une chaîne en sous-chaînes en fonction des chaînes contenues dans un tableau. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

separator
Type: System.String[]

Tableau de chaînes qui délimite les sous-chaînes de cette chaîne, tableau vide qui ne contient pas de délimiteur ou null.

options
Type: System.StringSplitOptions

StringSplitOptions.RemoveEmptyEntries pour ignorer les éléments vides du tableau retourné ou StringSplitOptions.None pour les inclure.

Valeur de retour

Type: System.String[]

Tableau dont les éléments contiennent les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs chaînes dans separator. Pour plus d'informations, consultez la section Remarques.

Exception Condition
ArgumentException

options ne fait pas partie des valeurs StringSplitOptions.

Lorsqu’une chaîne est délimitée par un ensemble connu de chaînes, vous pouvez utiliser la Split méthode pour le séparer en sous-chaînes.

Les chaînes de délimiteur ne sont pas inclus dans les éléments du tableau retourné. Par exemple, si le separator tableau comprend la chaîne «--» et la valeur de l'instance actuelle de la chaîne est « aa, bb-cc », la méthode retourne un tableau qui contient trois éléments: « aa », « bb » et « cc ».

Si cette instance ne contient aucune des chaînes dans separator, le tableau retourné se compose d'un seul élément contenant cette instance.

Si le options paramètre est RemoveEmptyEntries et la longueur de cette instance est égale à zéro, la méthode retourne un tableau vide.

Chaque élément de separator définit un délimiteur séparé qui se compose d'un ou plusieurs caractères. Si le options argument est None, et deux délimiteurs sont adjacents ou qu'un délimiteur est trouvé au début ou à la fin de cette instance, l'élément de tableau correspondant contient String.Empty. Par exemple, si separator inclut deux éléments, «-» et « _ », la valeur de l'instance de chaîne est « - _aa-_ » et la valeur de la options argument est None, la méthode retourne un tableau de chaîne avec les cinq éléments suivants :

  1. String.Empty, qui représente la chaîne vide qui précède le «-» sous-chaîne à l'index 0.

  2. String.Empty, qui représente une chaîne vide entre le «-» sous-chaîne à l'index 0 et la sous-chaîne « _ » à l'index 1.

  3. « aa »,

  4. String.Empty, qui représente la chaîne vide qui suit la sous-chaîne « _ » à l'index 4.

  5. String.Empty, qui représente la chaîne vide qui suit le «-» sous-chaîne à index 5.

Si un des éléments separator se compose de plusieurs caractères, l'intégralité de la sous-chaîne est considéré comme un délimiteur. Par exemple, si un des éléments dans separator est « 10 », une tentative fractionner la chaîne « This10is10a10string ». Retourne le tableau de quatre éléments suivant: {« This », « est », « a », « string ». }.

Si le separator paramètre est null ou ne contient aucun caractère, espaces blancs sont supposés pour être les délimiteurs. Espaces blancs sont définis par la norme Unicode et retournent true s'ils sont passés à la Char.IsWhiteSpace (méthode).

Si le separator paramètre dans l'appel à cette surcharge de méthode est null, la résolution de surcharge du compilateur échoue. Pour identifier sans ambiguïté la méthode appelée, votre code doit indiquer le type de la null. L'exemple suivant montre plusieurs façons d'identifier cette surcharge clairement.

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);

Le Split méthode extrait les sous-chaînes de cette chaîne qui sont délimitées par une ou plusieurs des chaînes dans le separator paramètre et retourne ces sous-chaînes comme éléments d'un tableau.

Le Split méthode recherche les délimiteurs en effectuant des comparaisons à l'aide des règles de tri ordinales sensibles à la casse. Pour plus d'informations sur les mots, des chaînes et tri ordinal, consultez la System.Globalization.CompareOptions énumération.

Le Split méthode ignore tout élément de separator dont la valeur est null ou une chaîne vide (« »).

Pour éviter des résultats ambigus lorsque des chaînes dans separator ont en commun, les caractères le Split opération démarre à partir du début jusqu'à la fin de la valeur de l'instance et recherche le premier élément de separator qui est égal à un délimiteur de l'instance. L'ordre de rencontre des sous-chaînes dans l'instance a priorité sur l'ordre des éléments dans separator.

Par exemple, considérez une instance dont la valeur est « abcdef ». Si le premier élément de separator était « ef » et le deuxième élément était « bcde », le résultat de l'opération de fractionnement serait un tableau de chaînes qui contient deux éléments, « a » et « f ». Il s'agit, car la sous-chaîne dans l'instance, « bcde », est rencontrée et correspond à un élément de separator avant que la sous-chaîne « f » est rencontrée.

Toutefois, si le premier élément du separator était « bcd » et le deuxième élément était « bc », le résultat de l'opération de fractionnement serait un tableau de chaînes qui contient deux éléments, « a » et « ef ». Effet, « bcd » est le premier délimiteur de separator qui correspond à un délimiteur de l'instance. Si l'ordre des séparateurs a été inversé pour le premier élément était « bc » et le deuxième élément était « bcd », le résultat est un tableau de chaînes qui contient deux éléments, « a » et « def ».

Le Split méthodes allouent de mémoire pour l'objet tableau retourné et un String objet pour chaque élément du tableau. Si votre application nécessite des performances optimales, ou si la gestion de l'allocation de mémoire est critique dans votre application, envisagez d'utiliser le IndexOf ou IndexOfAny (méthode) et éventuellement le Compare (méthode), pour trouver une sous-chaîne dans une chaîne.

Si vous fractionnez une chaîne au caractère de séparation, utilisez la IndexOf ou IndexOfAny méthode de localisation d'un caractère de séparation dans la chaîne. Si vous fractionnez une chaîne à une chaîne de séparation, utilisez la IndexOf ou IndexOfAny méthode pour rechercher le premier caractère de la chaîne de séparation. Utilisez ensuite le Compare méthode pour déterminer si les caractères après le premier caractère sont égaux aux caractères restants de la chaîne de séparation.

En outre, si le même jeu de caractères est utilisé pour fractionner des chaînes en plusieurs Split des appels de méthode, envisagez la création d'un tableau unique et son référencement dans chaque appel de méthode. Cela réduit sensiblement la surcharge supplémentaire de chaque appel de méthode.

Remarques à l'attention des appelants :

Dans le .NET Framework 3.5 et les versions antérieures, si la Split est transmis à la méthode un separator qui est null ou ne contient aucun caractère, la méthode utilise un jeu de caractères légèrement différent pour fractionner la chaîne que le Trim méthode effectue pour découper la chaîne. Dans la .NET Framework 4, les deux méthodes utilisent un jeu identique d'espaces blancs Unicode.

L'exemple suivant illustre la différence dans les tableaux retournés par l'appel d'une chaîne String.Split(String[], StringSplitOptions) méthode avec ses options égal au paramètre StringSplitOptions.None et 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'

L'exemple suivant définit un tableau de séparateurs comprenant des signes de ponctuation et espaces. En passant ce tableau ainsi qu'une valeur de StringSplitOptions.RemoveEmptyEntries pour la Split(String[], StringSplitOptions) renvoie un tableau qui se compose des mots individuels à partir de la chaîne.

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 depuis 8
.NET Framework
Disponible depuis 2.0
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: