Partage via

Regex.Split Méthode

  • Référence

Définition

Espace de noms:
System.Text.RegularExpressions
Assembly:
System.Text.RegularExpressions.dll
Assembly:
System.dll
Assembly:
netstandard.dll

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par une correspondance d’expression régulière.

Surcharges

Split(String, String, RegexOptions, TimeSpan)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Des paramètres supplémentaires spécifient des options qui modifient l’opération correspondante et un intervalle de délai d’attente si aucune correspondance n’est trouvée.
Split(String, String, RegexOptions)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Les options spécifiées modifient l’opération correspondante.
Split(String, Int32, Int32)

Fractionne une chaîne d’entrée un nombre maximal spécifié de fois en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex. La recherche du modèle d’expression régulière commence à une position de caractère spécifiée dans la chaîne d’entrée.
Split(String, String)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière.
Split(String)

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié dans le constructeur Regex.
Split(String, Int32)

Fractionne une chaîne d’entrée un nombre maximal spécifié de fois en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex.

Split(String, String, RegexOptions, TimeSpan)

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

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Des paramètres supplémentaires spécifient des options qui modifient l’opération correspondante et un intervalle de délai d’attente si aucune correspondance n’est trouvée.

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

Paramètres

input
String

Chaîne à fractionner.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

matchTimeout
TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input ou pattern est null.

ArgumentOutOfRangeException

options n’est pas une combinaison de bits valide de valeurs RegexOptions.

-ou-

matchTimeout est négatif, zéro ou supérieur à environ 24 jours.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split(Char[]), sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. La chaîne est fractionnée autant de fois que possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la chaîne de input d’origine.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

Important

Les expressions régulières compilées utilisées dans les appels aux méthodes de Split statiques sont automatiquement mises en cache. Pour gérer vous-même la durée de vie des expressions régulières compilées, utilisez l’instance Split méthodes.

Si plusieurs correspondances sont adjacentes les unes aux autres, une chaîne vide est insérée dans le tableau. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union entraîne l’insertion d’une chaîne vide dans la position où deux traits d’union adjacents sont trouvés.

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné. L’exemple suivant utilise le modèle d’expression régulière [a-z]+ pour fractionner une chaîne d’entrée sur n’importe quel caractère alphabétique majuscule ou minuscule. Étant donné que la chaîne commence et se termine par des caractères alphabétiques correspondants, la valeur du premier et du dernier élément du tableau retourné est 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 la capture de parenthèses est utilisée dans une expression Regex.Split, tout texte capturé est inclus dans le tableau de chaînes résultant. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé entre parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance n’est pas trouvée dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaire n’est pas inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux ensembles de parenthèses de capture pour extraire les éléments d’une date, y compris les délimiteurs de date, à partir d’une chaîne de date. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième jeu capture la barre oblique. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les caractères de barre oblique ; s’il est compilé et exécuté sous les versions .NET Framework 2.0 ou ultérieures, il les inclut.

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 l’expression régulière peut correspondre à la chaîne vide, Split fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement.

Le paramètre matchTimeout spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant d’expirer. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour arrière excessif d’apparaître pour cesser de répondre lorsqu’elles traitent les entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et retour arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une exception RegexMatchTimeoutException. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.

Notes pour les appelants

Nous vous recommandons de définir le paramètre matchTimeout sur une valeur appropriée, par exemple deux secondes. Si vous désactivez les délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes :

  • Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique. Cela exclut le texte qui a été entré dynamiquement par les utilisateurs.

  • Lorsque le modèle d’expression régulière a été soigneusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.

  • Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer un retour arrière excessif lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

Split(String, String, RegexOptions)

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

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Les options spécifiées modifient l’opération correspondante.

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

Paramètres

input
String

Chaîne à fractionner.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison de bits des valeurs d’énumération qui fournissent des options de correspondance.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input ou pattern est null.

ArgumentOutOfRangeException

options n’est pas une combinaison de bits valide de valeurs RegexOptions.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split(Char[]), sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. La chaîne est fractionnée autant de fois que possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la chaîne de input d’origine.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

Important

Les expressions régulières compilées utilisées dans les appels aux méthodes de Split statiques sont automatiquement mises en cache. Pour gérer vous-même la durée de vie des expressions régulières compilées, utilisez l’instance Split méthodes.

Si plusieurs correspondances sont adjacentes les unes aux autres, une chaîne vide est insérée dans le tableau. Par exemple, le fractionnement d’une chaîne sur un seul trait d’union entraîne l’insertion d’une chaîne vide dans la position où deux traits d’union adjacents sont trouvés.

Si une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné. L’exemple suivant utilise le modèle d’expression régulière [a-z]+ pour fractionner une chaîne d’entrée sur n’importe quel caractère alphabétique majuscule ou minuscule. Étant donné que la chaîne commence et se termine par des caractères alphabétiques correspondants, la valeur du premier et du dernier élément du tableau retourné est 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 la capture de parenthèses est utilisée dans une expression Regex.Split, tout texte capturé est inclus dans le tableau de chaînes résultant. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé entre parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance n’est pas trouvée dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaire n’est pas inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux ensembles de parenthèses de capture pour extraire les éléments d’une date, y compris les délimiteurs de date, à partir d’une chaîne de date. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième jeu capture la barre oblique. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les caractères de barre oblique ; s’il est compilé et exécuté sous les versions .NET Framework 2.0 ou ultérieures, il les inclut.

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 l’expression régulière peut correspondre à la chaîne vide, Split fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel la méthode est appelée. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. La méthode statique recommandée pour fractionner du texte sur une correspondance de modèle est Split(String, String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Split(String, Int32, Int32)

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

Fractionne une chaîne d’entrée un nombre maximal spécifié de fois en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur Regex. La recherche du modèle d’expression régulière commence à une position de caractère spécifiée dans la chaîne d’entrée.

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

Paramètres

input
String

Chaîne à fractionner.

count
Int32

Nombre maximal de fois où le fractionnement peut se produire.

startat
Int32

Position de caractère dans la chaîne d’entrée où la recherche commence.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentNullException

input est null.

ArgumentOutOfRangeException

startat est inférieur à zéro ou supérieur à la longueur de input.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split, sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. Le paramètre count spécifie le nombre maximal de sous-chaînes dans lesquelles la chaîne input est fractionnée ; la dernière chaîne contient le reste nonsplit de la chaîne. Une valeur count de zéro fournit le comportement par défaut de fractionnement autant de fois que possible. Le paramètre startat définit le point auquel commence la recherche du premier délimiteur (cela peut être utilisé pour ignorer l’espace blanc de début).

Pour plus d’informations sur startat, consultez la section Remarques de Match(String, Int32).

Si aucune correspondance n’est trouvée à partir de la position count+1 dans la chaîne, la méthode retourne un tableau à un élément qui contient la chaîne input. Si une ou plusieurs correspondances sont trouvées, le premier élément du tableau retourné contient la première partie de la chaîne du premier caractère jusqu’à un caractère avant la correspondance.

Si plusieurs correspondances sont adjacentes les unes aux autres et que le nombre de correspondances trouvées est au moins deux inférieurs à count, une chaîne vide est insérée dans le tableau. De même, si une correspondance est trouvée à startat, qui est le premier caractère de la chaîne, le premier élément du tableau retourné est une chaîne vide. Autrement dit, les chaînes vides résultant de correspondances adjacentes sont comptabilisées pour déterminer si le nombre de sous-chaînes correspondantes est égal à count. Dans l’exemple suivant, l’expression régulière \d+ est utilisée pour rechercher la position de départ du premier sous-chaîne de caractères numériques dans une chaîne, puis pour fractionner la chaîne un maximum de trois fois à partir de cette position. Étant donné que le modèle d’expression régulière correspond au début de la chaîne d’entrée, le tableau de chaînes retourné se compose d’une chaîne vide, d’une chaîne alphabétique à cinq caractères et du reste de la chaîne,

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 la capture de parenthèses est utilisée dans une expression régulière, tout texte capturé est inclus dans le tableau de chaînes fractionnées. Toutefois, tous les éléments de tableau qui contiennent du texte capturé ne sont pas comptabilisés pour déterminer si le nombre de correspondances a atteint count. Par exemple, le fractionnement de la chaîne '"apple-apricot-plum-pear-pomegranate-ananas-peach » en un maximum de quatre sous-chaînes commençant à caractère 15 dans la chaîne entraîne un tableau de sept éléments, comme le montre le code suivant.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance est introuvable dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaire n’est pas inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux ensembles de parenthèses de capture pour extraire les mots individuels d’une chaîne. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre verticale. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les caractères de barre verticale ; s’il est compilé et exécuté sous les versions .NET Framework 2.0 ou ultérieures, il les inclut.

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 l’expression régulière peut correspondre à la chaîne vide, Split fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement. L’exemple suivant fractionne la chaîne « caractères » en autant d’éléments que la chaîne d’entrée contient, en commençant par le caractère « a ». Étant donné que la chaîne Null correspond à la fin de la chaîne d’entrée, une chaîne Null est insérée à la fin du tableau retourné.

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}

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan). Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée

Voir aussi

  • langage d’expression régulière - de référence rapide

S’applique à

Split(String, String)

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

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière.

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

Paramètres

input
String

Chaîne à fractionner.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input ou pattern est null.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split, sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. La chaîne input est fractionnée autant de fois que possible. Si pattern est introuvable dans la chaîne input, la valeur de retour contient un élément dont la valeur est la chaîne de input d’origine.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

Important

Les expressions régulières compilées utilisées dans les appels aux méthodes de Split statiques sont automatiquement mises en cache. Pour gérer vous-même la durée de vie des expressions régulières compilées, utilisez l’instance Split méthodes.

Si plusieurs correspondances sont adjacentes les unes aux autres, une chaîne vide est insérée dans le tableau. Par exemple, le fractionnement d’une chaîne sur un trait d’union unique entraîne l’insertion d’une chaîne vide dans la position où deux traits d’union adjacents sont trouvés, comme le montre le code suivant.

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 une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné. L’exemple suivant utilise le modèle d’expression régulière \d+ pour fractionner une chaîne d’entrée sur des caractères numériques. Étant donné que la chaîne commence et se termine par des caractères numériques correspondants, la valeur du premier et du dernier élément du tableau retourné est 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 la capture de parenthèses est utilisée dans une expression Regex.Split, tout texte capturé est inclus dans le tableau de chaînes résultant. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé entre parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance n’est pas trouvée dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaire n’est pas inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux ensembles de parenthèses de capture pour extraire les éléments d’une date, y compris les délimiteurs de date, à partir d’une chaîne de date. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième jeu capture la barre oblique. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les caractères de barre oblique ; s’il est compilé et exécuté sous les versions .NET Framework 2.0 ou ultérieures, il les inclut.

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 l’expression régulière peut correspondre à la chaîne vide, Split fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement. Par exemple:

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', ''}

Notez que le tableau retourné inclut également une chaîne vide au début et à la fin du tableau.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel la méthode est appelée. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. La méthode statique recommandée pour fractionner du texte sur une correspondance de modèle est Split(String, String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Split(String)

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

Fractionne une chaîne d’entrée en un tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié dans le constructeur 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()

Paramètres

input
String

Chaîne à fractionner.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentNullException

input est null.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split(Char[]), sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. La chaîne est fractionnée autant de fois que possible. Si aucun délimiteur n’est trouvé, la valeur de retour contient un élément dont la valeur est la chaîne d’entrée d’origine.

Si plusieurs correspondances sont adjacentes les unes aux autres, une chaîne vide est insérée dans le tableau. Par exemple, le fractionnement d’une chaîne sur un trait d’union unique entraîne l’insertion d’une chaîne vide dans la position où deux traits d’union adjacents sont trouvés, comme le montre le code suivant.

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 une correspondance est trouvée au début ou à la fin de la chaîne d’entrée, une chaîne vide est incluse au début ou à la fin du tableau retourné. L’exemple suivant utilise le modèle d’expression régulière \d+ pour fractionner une chaîne d’entrée sur des caractères numériques. Étant donné que la chaîne commence et se termine par des caractères numériques correspondants, la valeur du premier et du dernier élément du tableau retourné est 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 la capture de parenthèses est utilisée dans une expression Regex.Split, tout texte capturé est inclus dans le tableau de chaînes résultant. Par exemple, si vous fractionnez la chaîne « plum-pear » sur un trait d’union placé entre parenthèses de capture, le tableau retourné inclut un élément de chaîne qui contient le trait d’union.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si une correspondance n’est pas trouvée dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaire n’est pas inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux ensembles de parenthèses de capture pour extraire les éléments d’une date, y compris les délimiteurs de date, à partir d’une chaîne de date. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième jeu capture la barre oblique. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les caractères de barre oblique ; s’il est compilé et exécuté sous les versions .NET Framework 2.0 ou ultérieures, il les inclut.

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 l’expression régulière peut correspondre à la chaîne vide, Split(String) fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement. Par exemple:

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, }

Notez que le tableau retourné inclut également une chaîne vide au début et à la fin du tableau.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan). Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée

Voir aussi

  • langage d’expression régulière - de référence rapide

S’applique à

Split(String, Int32)

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

Fractionne une chaîne d’entrée un nombre maximal spécifié de fois en un tableau de sous-chaînes, aux positions définies par une expression régulière spécifiée dans le constructeur 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()

Paramètres

input
String

Chaîne à fractionner.

count
Int32

Nombre maximal de fois où le fractionnement peut se produire.

Retours

String[]

Tableau de chaînes.

Exceptions

ArgumentNullException

input est null.

RegexMatchTimeoutException

Un délai d’attente s’est produit. Pour plus d’informations sur les délais d’attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split, sauf que Regex.Split fractionne la chaîne à un délimiteur déterminé par une expression régulière au lieu d’un jeu de caractères. Le paramètre count spécifie le nombre maximal de sous-chaînes dans lesquelles la chaîne de input peut être fractionnée ; la dernière chaîne contient le reste nonsplit de la chaîne. Une valeur count de zéro fournit le comportement par défaut de fractionnement autant de fois que possible.

Si plusieurs correspondances sont adjacentes les unes aux autres ou si une correspondance est trouvée au début ou à la fin de input, et que le nombre de correspondances trouvées est au moins deux inférieurs à count, une chaîne vide est insérée dans le tableau. Autrement dit, les chaînes vides résultant de correspondances adjacentes ou de correspondances au début ou à la fin de la chaîne d’entrée sont comptabilisées pour déterminer si le nombre de sous-chaînes correspondantes est égal à count. Dans l’exemple suivant, l’expression régulière /d+ est utilisée pour fractionner une chaîne d’entrée qui inclut un ou plusieurs chiffres décimaux en un maximum de trois sous-chaînes. Étant donné que le début de la chaîne d’entrée correspond au modèle d’expression régulière, le premier élément de tableau contient String.Empty, le deuxième contient le premier jeu de caractères alphabétiques dans la chaîne d’entrée, et le troisième contient le reste de la chaîne qui suit la troisième correspondance.

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 la capture de parenthèses est utilisée dans une expression régulière, tout texte capturé est inclus dans le tableau de chaînes fractionnées. Toutefois, tous les éléments de tableau qui contiennent du texte capturé ne sont pas comptabilisés pour déterminer si le nombre de correspondances a atteint count. Par exemple, le fractionnement de la chaîne « apple-apricot-plum-pear-banana » en un maximum de quatre sous-chaînes entraîne un tableau de sept éléments, comme le montre le code suivant.

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'

Toutefois, lorsque le modèle d’expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, seul le texte capturé du premier ensemble de parenthèses de capture est inclus dans le tableau retourné. À compter du .NET Framework 2.0, tout le texte capturé est ajouté au tableau retourné. Toutefois, les éléments du tableau retourné qui contiennent du texte capturé ne sont pas comptabilisés pour déterminer si le nombre de sous-chaînes correspondantes est égal à count. Par exemple, dans le code suivant, une expression régulière utilise deux ensembles de parenthèses de capture pour extraire les éléments d’une date à partir d’une chaîne de date. Le premier jeu de parenthèses de capture capture le trait d’union, et le deuxième jeu capture la barre oblique. L’appel à la méthode Split(String, Int32) spécifie ensuite un maximum de deux éléments dans le tableau retourné. Si l’exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, la méthode retourne un tableau de chaînes à deux éléments. Si elle est compilée et exécutée sous les versions .NET Framework 2.0 ou ultérieures, la méthode retourne un tableau de chaînes à trois éléments.

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 l’expression régulière peut correspondre à la chaîne vide, Split(String, Int32) fractionnera la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaîne vide est trouvé à chaque emplacement. L’exemple suivant fractionne la chaîne « caractères » en autant d’éléments que dans la chaîne d’entrée. Étant donné que la chaîne Null correspond au début de la chaîne d’entrée, une chaîne Null est insérée au début du tableau retourné. Ainsi, le dixième élément se compose des deux caractères à la fin de la chaîne d’entrée.

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}

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération de fractionnement dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan). Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée

Voir aussi

  • langage d’expression régulière - de référence rapide

S’applique à