Regex.Split Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Suddivide una stringa di input in una matrice di sottostringhe nelle posizioni definite dalla corrispondenza di un'espressione regolare.
Overload
Split(String) |
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato nel costruttore Regex. |
Split(String, Int32) |
Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. |
Split(String, String) |
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare. |
Split(String, Int32, Int32) |
Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. La ricerca del criterio di espressione regolare inizia da una posizione del carattere specificata nella stringa di input. |
Split(String, String, RegexOptions) |
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. Le opzioni specificate modificano l'operazione di corrispondenza. |
Split(String, String, RegexOptions, TimeSpan) |
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza. |
Split(String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato nel costruttore 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()
Parametri
- input
- String
Stringa da dividere.
Restituisce
Matrice di stringhe.
Eccezioni
input
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split(Char[]) metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene suddivisa il maggior numero possibile di volte. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa di input originale.
Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.
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'
Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita. Nell'esempio seguente viene usato il modello \d+
di espressione regolare per dividere una stringa di input su caratteri numerici. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''
Se le parentesi di acquisizione vengono usate in un'espressione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato all'interno delle parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, li include.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split(String) suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Ad esempio:
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, }
Si noti che la matrice restituita include anche una stringa vuota all'inizio e alla fine della matrice.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata al Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Vedi anche
Si applica a
Split(String, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore 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()
Parametri
- input
- String
Stringa da suddividere.
- count
- Int32
Numero massimo di volte in cui la suddivisione può aver luogo.
Restituisce
Matrice di stringhe.
Eccezioni
input
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il count
parametro specifica il numero massimo di sottostringhe in cui è possibile suddividere la input
stringa. L'ultima stringa contiene il resto senzasplit della stringa. Il count
valore zero fornisce il comportamento predefinito della suddivisione il maggior numero possibile di volte.
Se più corrispondenze sono adiacenti tra loro o se viene trovata una corrispondenza all'inizio o alla fine di input
e il numero di corrispondenze trovate è almeno due minore di count
, viene inserita una stringa vuota nella matrice. Ovvero, vengono conteggiate stringhe vuote risultanti da corrispondenze adiacenti o da corrispondenze all'inizio o alla fine della stringa di input per determinare se il numero di sottostringhe corrispondenti è uguale a count
. Nell'esempio seguente l'espressione /d+
regolare viene usata per dividere una stringa di input che include una o più cifre decimali in un massimo di tre sottostringhe. Poiché l'inizio della stringa di input corrisponde al criterio di espressione regolare, il primo elemento della matrice contiene String.Empty, il secondo contiene il primo set di caratteri alfabetici nella stringa di input e il terzo contiene il resto della stringa che segue la terza corrispondenza.
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'
Se le parentesi di acquisizione vengono usate in un'espressione regolare, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, tutti gli elementi della matrice che contengono testo acquisito non vengono conteggiati per determinare se il numero di corrispondenze ha raggiunto count
. Ad esempio, suddividendo la stringa "apple-albicocca-plum-pear-banana" in un massimo di quattro sottostringhe si ottiene una matrice di sette elementi, come illustrato nel codice seguente.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, solo il testo acquisito dal primo set di parentesi di acquisizione è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto alla matrice restituita. Tuttavia, gli elementi nella matrice restituita che contengono testo acquisito non vengono conteggiati per determinare se il numero di sottostringhe corrispondenti è uguale a count
. Nel codice seguente, ad esempio, un'espressione regolare usa due set di parentesi di acquisizione per estrarre gli elementi di una data da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. La chiamata al Split(String, Int32) metodo specifica quindi un massimo di due elementi nella matrice restituita. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, il metodo restituisce una matrice di stringhe a due elementi. Se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, il metodo restituisce una matrice di stringhe a tre elementi.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split(String, Int32) suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi presenti nella stringa di input. Poiché la stringa Null corrisponde all'inizio della stringa di input, viene inserita una stringa Null all'inizio della matrice restituita. In questo modo il decimo elemento è costituito dai due caratteri alla fine della stringa di input.
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'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata al Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Vedi anche
Si applica a
Split(String, String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare.
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()
Parametri
- input
- String
Stringa da dividere.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
Restituisce
Matrice di stringhe.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
o pattern
è null
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La input
stringa viene suddivisa il maggior numero possibile di volte. Se pattern
non viene trovato nella input
stringa, il valore restituito contiene un elemento il cui valore è la stringa originale input
.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.
Importante
Le espressioni regolari compilate usate nelle chiamate ai metodi statici Split vengono memorizzate automaticamente nella cache. Per gestire manualmente la durata delle espressioni regolari compilate, usare i metodi di istanza Split .
Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti, come illustrato nel codice seguente.
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'
Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita. Nell'esempio seguente viene usato il modello \d+
di espressione regolare per dividere una stringa di input su caratteri numerici. Poiché la stringa inizia e termina con caratteri numerici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''
Se le parentesi di acquisizione vengono usate in un'espressione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato all'interno delle parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, li include.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Ad esempio:
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', ''}
Si noti che la matrice restituita include anche una stringa vuota all'inizio e alla fine della matrice.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo . Se non viene definito alcun timeout nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.
Note per i chiamanti
Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato il metodo . Se non è stato definito un valore di timeout per il dominio applicazione, viene utilizzato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la suddivisione del testo in una corrispondenza del criterio è Split(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.
Vedi anche
Si applica a
Split(String, Int32, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input per un numero massimo di volte specificato in una matrice di sottostringhe in corrispondenza delle posizioni definite da un'espressione regolare specificata nel costruttore Regex. La ricerca del criterio di espressione regolare inizia da una posizione del carattere specificata nella stringa di input.
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()
Parametri
- input
- String
Stringa da suddividere.
- count
- Int32
Numero massimo di volte in cui la suddivisione può aver luogo.
- startat
- Int32
Posizione del carattere nella stringa di input da cui avrà inizio la ricerca.
Restituisce
Matrice di stringhe.
Eccezioni
input
è null
.
startat
è minore di zero o maggiore della lunghezza di input
.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. Il count
parametro specifica il numero massimo di sottostringhe in cui viene divisa la input
stringa. L'ultima stringa contiene il resto non inserito della stringa. Il count
valore zero fornisce il comportamento predefinito della suddivisione il maggior numero possibile di volte. Il startat
parametro definisce il punto in cui inizia la ricerca del primo delimitatore ( che può essere usato per ignorare gli spazi vuoti iniziali).
Per altre informazioni su startat
, vedere la sezione Osservazioni di Match(String, Int32).
Se nella stringa non vengono trovate corrispondenze dalla count
posizione +1, il metodo restituisce una matrice di un elemento contenente la input
stringa. Se vengono trovate una o più corrispondenze, il primo elemento della matrice restituita contiene la prima parte della stringa dal primo carattere fino a un carattere prima della corrispondenza.
Se più corrispondenze sono adiacenti l'una all'altra e il numero di corrispondenze trovate è almeno due minori di count
, viene inserita una stringa vuota nella matrice. Analogamente, se viene trovata una corrispondenza in startat
, ovvero il primo carattere nella stringa, il primo elemento della matrice restituita è una stringa vuota. Ovvero, le stringhe vuote risultanti da corrispondenze adiacenti vengono conteggiate per determinare se il numero di sottostringhe corrispondenti è uguale a count
. Nell'esempio seguente l'espressione \d+
regolare viene usata per trovare la posizione iniziale della prima sottostringa di caratteri numerici in una stringa e quindi per dividere la stringa un massimo di tre volte a partire da tale posizione. Poiché il criterio di espressione regolare corrisponde all'inizio della stringa di input, la matrice di stringhe restituita è costituita da una stringa vuota, da una stringa alfabetica a cinque caratteri e dal resto della stringa,
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'
Se le parentesi di acquisizione vengono usate in un'espressione regolare, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, tutti gli elementi della matrice che contengono testo acquisito non vengono conteggiati per determinare se il numero di corrispondenze ha raggiunto count
. Ad esempio, suddividendo la stringa '"apple-albicocca-plum-pear-pomegranate-ananas-pesca" in un massimo di quattro sottostringhe a partire dal carattere 15 nella stringa si ottiene una matrice di sette elementi, come illustrato nel codice seguente.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre le singole parole in una stringa. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra verticale. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri della barra verticale; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, li include.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione. Nell'esempio seguente la stringa "characters" viene suddivisa in tutti gli elementi contenuti nella stringa di input, a partire dal carattere "a". Poiché la stringa Null corrisponde alla fine della stringa di input, viene inserita una stringa Null alla fine della matrice restituita.
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'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato dal Regex.Regex(String, RegexOptions, TimeSpan) costruttore. Se non si imposta un intervallo di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex . Se non viene definito alcun timeout nella chiamata al Regex costruttore o nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione
Vedi anche
Si applica a
Split(String, String, RegexOptions)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. Le opzioni specificate modificano l'operazione di corrispondenza.
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()
Parametri
- input
- String
Stringa da dividere.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
Restituisce
Matrice di stringhe.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
o pattern
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split(Char[]) metodo , ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché da un set di caratteri. La stringa viene suddivisa il maggior numero possibile di volte. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa originale input
.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressioni regolari - Riferimento rapido.
Importante
Le espressioni regolari compilate usate nelle chiamate ai metodi statici Split vengono memorizzate automaticamente nella cache. Per gestire manualmente la durata delle espressioni regolari compilate, usare i metodi di istanza Split .
Se più corrispondenze sono adiacenti tra loro, viene inserita una stringa vuota nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino fa sì che la matrice restituita includa una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.
Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, viene inclusa una stringa vuota all'inizio o alla fine della matrice restituita. Nell'esempio seguente viene usato il modello [a-z]+
di espressione regolare per dividere una stringa di input in qualsiasi carattere alfabetico maiuscolo o minuscolo. Poiché la stringa inizia e termina con caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''
Se le parentesi di acquisizione vengono usate in un'espressione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si divide la stringa "plum-pear" su un trattino posizionato all'interno delle parentesi di acquisizione, la matrice restituita include un elemento stringa che contiene il trattino.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, se non viene trovata una corrispondenza all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, li include.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a carattere singolo perché il delimitatore stringa vuoto può essere trovato in ogni posizione.
L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato per il dominio dell'applicazione in cui viene chiamato il metodo . Se non viene definito alcun timeout nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.
Note per i chiamanti
Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato il metodo . Se non è stato definito un valore di timeout per il dominio applicazione, viene utilizzato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per la suddivisione del testo in una corrispondenza del criterio è Split(String, String, RegexOptions, TimeSpan), che consente di impostare l'intervallo di timeout.
Vedi anche
Si applica a
Split(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Suddivide una stringa di input in una matrice di sottostringhe in corrispondenza delle posizioni definite da un criterio di espressione regolare specificato. I parametri aggiuntivi specificano le opzioni che modificano l'operazione di corrispondenza e un intervallo di timeout se non viene trovata alcuna corrispondenza.
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()
Parametri
- input
- String
Stringa da dividere.
- pattern
- String
Criterio di espressione regolare di cui trovare la corrispondenza.
- options
- RegexOptions
Combinazione bit per bit dei valori di enumerazione che forniscono le opzioni per la corrispondenza.
- matchTimeout
- TimeSpan
Intervallo di timeout o InfiniteMatchTimeout per indicare che per il metodo non è previsto un timeout.
Restituisce
Matrice di stringhe.
Eccezioni
Si è verificato un errore di analisi dell'espressione regolare.
input
o pattern
è null
.
options
non è una combinazione bit per bit valida di valori di RegexOptions.
-oppure-
matchTimeout
è negativo, zero o maggiore di circa 24 giorni.
Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.
Commenti
I Regex.Split metodi sono simili al String.Split(Char[]) metodo, ad eccezione del fatto che Regex.Split divide la stringa in corrispondenza di un delimitatore determinato da un'espressione regolare anziché un set di caratteri. La stringa viene divisa il più volte possibile. Se non viene trovato alcun delimitatore, il valore restituito contiene un elemento il cui valore è la stringa originale input
.
Il pattern
parametro è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da corrispondere. Per altre informazioni sulle espressioni regolari, vedere Espressioni regolari .NET e Linguaggio di espressione regolare - Riferimento rapido.
Importante
Le espressioni regolari compilate usate nelle chiamate ai metodi statici Split vengono memorizzate automaticamente nella cache. Per gestire la durata delle espressioni regolari compilate autonomamente, usare i metodi di istanza Split .
Se più corrispondenze sono adiacenti tra loro, una stringa vuota viene inserita nella matrice. Ad esempio, la suddivisione di una stringa su un singolo trattino causa l'inclusione di una stringa vuota nella posizione in cui vengono trovati due trattini adiacenti.
Se viene trovata una corrispondenza all'inizio o alla fine della stringa di input, una stringa vuota viene inclusa all'inizio o alla fine della matrice restituita. Nell'esempio seguente viene usato il modello [a-z]+
di espressione regolare per dividere una stringa di input in qualsiasi carattere alfabetico maiuscolo o minuscolo. Poiché la stringa inizia e termina con caratteri alfabetici corrispondenti, il valore del primo e dell'ultimo elemento della matrice restituita è 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', ''
Se l'acquisizione delle parentesi viene usata in un'espressione Regex.Split , qualsiasi testo acquisito viene incluso nella matrice di stringhe risultante. Ad esempio, se si suddivide la stringa "plum-pear" su un trattino posizionato all'interno delle parentesi di acquisizione, la matrice restituita include un elemento stringa contenente il trattino.
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'
Tuttavia, quando il modello di espressione regolare include più set di parentesi di acquisizione, il comportamento di questo metodo dipende dalla versione di .NET Framework. In .NET Framework 1.0 e 1.1, se una corrispondenza non viene trovata all'interno del primo set di parentesi di acquisizione, il testo acquisito da parentesi di acquisizione aggiuntive non è incluso nella matrice restituita. A partire da .NET Framework 2.0, tutto il testo acquisito viene aggiunto anche alla matrice restituita. Ad esempio, il codice seguente usa due set di parentesi di acquisizione per estrarre gli elementi di una data, inclusi i delimitatori di data, da una stringa di data. Il primo set di parentesi di acquisizione acquisisce il trattino e il secondo set acquisisce la barra in avanti. Se il codice di esempio viene compilato ed eseguito in .NET Framework 1.0 o 1.1, esclude i caratteri della barra; se viene compilato ed eseguito in .NET Framework 2.0 o versioni successive, le include.
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'
Se l'espressione regolare può corrispondere alla stringa vuota, Split suddividerà la stringa in una matrice di stringhe a caratteri singoli perché il delimitatore stringa vuoto può essere trovato in ogni posizione.
Il matchTimeout
parametro specifica la durata di un metodo di corrispondenza del modello per cercare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce alle espressioni regolari che si basano su un backtracking eccessivo di apparire per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere Procedure consigliate per espressioni regolari e Backtracking. Se non viene trovata alcuna corrispondenza nell'intervallo di tempo, il metodo genera un'eccezione RegexMatchTimeoutException . matchTimeout
esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio dell'applicazione in cui viene eseguito il metodo.
Note per i chiamanti
È consigliabile impostare il matchTimeout
parametro su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore di espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo in base alle condizioni seguenti:
Quando l'input elaborato da un'espressione regolare deriva da un'origine nota e attendibile o è costituita da testo statico. Ciò esclude il testo che è stato immesso dinamicamente dagli utenti.
Quando il modello di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.
Quando il modello di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.
Vedi anche
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per