Regex.Split Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Fractionne une chaîne d'entrée en tableau de sous-chaînes aux positions définies par une correspondance d'expression régulière.
Surcharges
| 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 spécifiée un nombre de fois maximal spécifié 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) |
Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière. |
| Split(String, Int32, Int32) |
Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié 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 débute à une position de caractère spécifiée dans la chaîne d’entrée. |
| Split(String, String, RegexOptions) |
Fractionne une chaîne d’entrée en 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, String, RegexOptions, TimeSpan) |
Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée. |
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
Tableau de chaînes.
Exceptions
input a la valeur null.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split(Char[]) méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble 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, 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, 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+ d’expression régulière 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 Regex.Split expression, 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é dans les parenthèses de capture, le tableau retourné inclut un élément string 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 aucune correspondance n’est trouvée dans le premier ensemble de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n’est pas inclus dans le tableau retourné. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux jeux 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 ensemble de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre oblique avant. 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 .NET Framework 2.0 ou versions 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) fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à chaque emplacement. 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 Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 Regex constructeur 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
S’applique à
Split(String, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Fractionne une chaîne d'entrée spécifiée un nombre de fois maximal spécifié 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 avoir lieu.
Retours
Tableau de chaînes.
Exceptions
input a la valeur null.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble de caractères. Le count paramètre spécifie le nombre maximal de sous-chaînes dans lesquelles la input chaîne peut être fractionnée ; la dernière chaîne contient le reste nonsplit de la chaîne. Une count valeur de zéro fournit le comportement par défaut de fractionnement autant de fois que possible.
Si plusieurs correspondances sont adjacentes l’une à l’autre ou si une correspondance est trouvée au début ou à la fin de input, et que le nombre de correspondances trouvées countest inférieur d’au moins deux à , une chaîne vide est insérée dans le tableau. Autrement dit, les chaînes vides qui résultent 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 countest égal à . Dans l’exemple suivant, l’expression /d+ régulière est utilisée pour fractionner une chaîne d’entrée qui comprend 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 ensemble 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, 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-abricot-plum-pear-banana » en un maximum de quatre sous-chaînes aboutit à 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 jeu de parenthèses de capture est inclus dans le tableau retourné. À compter de .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 countest égal à . Par exemple, dans le code suivant, une expression régulière utilise deux jeux de parenthèses de capture pour extraire les éléments d’une date d’une chaîne de date. Le premier ensemble de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre oblique avant. L’appel à la Split(String, Int32) méthode 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 .NET Framework 2.0 ou versions 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) fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à chaque emplacement. L’exemple suivant divise 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 Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 Regex constructeur 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
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 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
Tableau de chaînes.
Exceptions
Une erreur d’analyse d’expression régulière s’est produite.
input ou pattern est null.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble de caractères. La input chaîne est fractionnée autant de fois que possible. Si pattern est introuvable dans la chaîne, la input valeur de retour contient un élément dont la valeur est la chaîne d’origine input .
Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET et Langage d’expression régulière - Référence rapide.
Important
Les expressions régulières compilées utilisées dans les appels aux méthodes statiques Split sont automatiquement mises en cache. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez les méthodes instanceSplit.
Si plusieurs correspondances sont adjacentes, 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, 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+ d’expression régulière 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 Regex.Split expression, 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é dans les parenthèses de capture, le tableau retourné inclut un élément string 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 aucune correspondance n’est trouvée dans le premier ensemble de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n’est pas inclus dans le tableau retourné. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux jeux 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 ensemble de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre oblique avant. 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 .NET Framework 2.0 ou versions 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 fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à chaque emplacement. 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 aucune valeur de délai d’attente n’a é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 le 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 spécifiée un nombre de fois maximal spécifié 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 débute à 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 avoir lieu.
- startat
- Int32
Position du caractère dans la chaîne d'entrée où la recherche commencera.
Retours
Tableau de chaînes.
Exceptions
input a la valeur null.
startat est inférieur à zéro ou supérieur à la longueur de input.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble de caractères. Le count paramètre spécifie le nombre maximal de sous-chaînes dans lesquelles la input chaîne est fractionnée ; la dernière chaîne contient le reste nonsplit de la chaîne. Une count valeur de zéro fournit le comportement par défaut de fractionnement autant de fois que possible. Le startat paramètre définit le point auquel la recherche du premier délimiteur commence (cela peut être utilisé pour ignorer les espaces blancs 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 countposition +1 dans la chaîne, la méthode retourne un tableau à un élément qui contient la input chaîne. 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 l’une à l’autre et que le nombre de correspondances trouvées countest inférieur d’au moins deux à , 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 countest égal à . Dans l’exemple suivant, l’expression \d+ régulière est utilisée pour rechercher la position de départ de la première sous-chaîne de caractères numériques dans une chaîne, puis pour fractionner la chaîne un maximum de trois fois en commençant à 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 de 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, 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-abricot-plum-pear-grenade-pineapple-peach » en un maximum de quatre sous-chaînes commençant au caractère 15 dans la chaîne aboutit à 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 aucune correspondance n’est trouvée dans le premier jeu de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n’est pas inclus dans le tableau retourné. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les mots individuels dans une chaîne. Le premier ensemble 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 .NET Framework 2.0 ou versions 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 fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à chaque emplacement. L’exemple suivant fractionne la chaîne « characters » 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 Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 Regex constructeur 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
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 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 d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.
Retours
Tableau de chaînes.
Exceptions
Une erreur d’analyse d’expression régulière s’est produite.
input ou pattern est null.
options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split(Char[]) méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble 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’origine input .
Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET et Langage d’expression régulière - Référence rapide.
Important
Les expressions régulières compilées utilisées dans les appels aux méthodes statiques Split sont automatiquement mises en cache. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez les méthodes instanceSplit.
Si plusieurs correspondances sont adjacentes, 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 [a-z]+ d’expression régulière 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 Regex.Split expression, 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é dans les parenthèses de capture, le tableau retourné inclut un élément string 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 aucune correspondance n’est trouvée dans le premier ensemble de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n’est pas inclus dans le tableau retourné. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux jeux 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 ensemble de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre oblique avant. 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 .NET Framework 2.0 ou versions 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 fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à 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 aucune valeur de délai d’attente n’a é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 le 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, String, RegexOptions, TimeSpan)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Fractionne une chaîne d’entrée en tableau de sous-chaînes aux positions définies par un modèle d’expression régulière spécifié. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants 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 d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.
- matchTimeout
- TimeSpan
Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.
Retours
Tableau de chaînes.
Exceptions
Une erreur d’analyse d’expression régulière s’est produite.
input ou pattern est null.
options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.
- ou -
matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.
Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.
Remarques
Les Regex.Split méthodes sont similaires à la String.Split(Char[]) méthode, sauf que Regex.Split fractionne la chaîne au niveau d’un délimiteur déterminé par une expression régulière au lieu d’un ensemble 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’origine input .
Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET et Langage d’expression régulière - Référence rapide.
Important
Les expressions régulières compilées utilisées dans les appels aux méthodes statiques Split sont automatiquement mises en cache. Pour gérer la durée de vie des expressions régulières compilées vous-même, utilisez les méthodes instanceSplit.
Si plusieurs correspondances sont adjacentes, 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 [a-z]+ d’expression régulière 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 Regex.Split expression, 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é dans les parenthèses de capture, le tableau retourné inclut un élément string 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 aucune correspondance n’est trouvée dans le premier ensemble de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n’est pas inclus dans le tableau retourné. À compter de .NET Framework 2.0, tout le texte capturé est également ajouté au tableau retourné. Par exemple, le code suivant utilise deux jeux 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 ensemble de parenthèses de capture capture le trait d’union, et le deuxième ensemble capture la barre oblique avant. 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 .NET Framework 2.0 ou versions 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 fractionne la chaîne en un tableau de chaînes à caractère unique, car le délimiteur de chaînes vide se trouve à chaque emplacement.
Le matchTimeout paramètre 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 excessif de ne plus répondre lorsqu’elles traitent une entrée qui contient des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et le retour en arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une RegexMatchTimeoutException exception. 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 matchTimeout paramètre sur une valeur appropriée, par exemple deux secondes. Si vous désactivez les délais d’expiration 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’expiration 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 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 excessif en arrière lors du traitement d’une correspondance proche.
Voir aussi
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour