Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Regex.Split (String, Int32)

 

Data di pubblicazione: ottobre 2016

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.

Spazio dei nomi:   System.Text.RegularExpressions
Assembly:  System (in System.dll)

public string[] Split(
	string input,
	int count
)

Parametri

input
Type: System.String

Stringa da suddividere.

count
Type: System.Int32

Numero massimo di volte in cui la suddivisione può aver luogo.

Valore restituito

Type: System.String[]

Matrice di stringhe.

Exception Condition
ArgumentNullException

input è null.

RegexMatchTimeoutException

Si è verificato un timeout. Per altre informazioni sui timeout, vedere la sezione Osservazioni.

Il Regex.Split sono simili ai metodi di String.Split (metodo), con la differenza che Regex.Split suddivide la stringa delimitatore determinato da un'espressione regolare anziché un set di caratteri. Il count parametro specifica il numero massimo di sottostringhe in cui il input stringa può essere suddivisa; l'ultima stringa contiene il resto della stringa non diviso. Oggetto count valore pari a zero fornisce il comportamento predefinito di suddividere il numero di volte possibile.

Se più corrispondenze sono adiacenti o se viene trovata una corrispondenza all'inizio o alla fine di input, e il numero di corrispondenze trovate è almeno due meno count, una stringa vuota viene inserita nella matrice. Ovvero, stringhe vuote risultanti di corrispondenze adiacenti o di corrispondenze all'inizio o alla fine della stringa di input vengono contate per determinare se il numero di sottostringhe corrispondente è uguale count. Nell'esempio seguente, l'espressione regolare /d+ viene utilizzato per suddividere una stringa di input che include uno o più cifre decimali in un massimo di tre sottostringhe. Poiché l'inizio della stringa di input corrisponde al modello 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'

Se in un'espressione regolare vengono utilizzate le parentesi di cattura, qualsiasi testo acquisito viene incluso nella matrice di stringhe suddivise. Tuttavia, qualsiasi elemento di matrice che contengono testo acquisito non viene conteggiati per determinare se ha raggiunto il numero di corrispondenze count. Ad esempio, suddividere la stringa "apple-albicocca-Lilla carico-pear-banana" in un massimo di quattro sottostringhe in una matrice di sette elementi, come il codice seguente mostra.

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'      

Tuttavia, quando il criterio di espressione regolare include più set di parentesi di cattura, 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 cattura è 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 corrispondente è uguale count. Nel codice seguente, ad esempio, un'espressione regolare utilizza due set di parentesi di cattura per estrarre gli elementi di una data da una stringa di Data. Il primo set di parentesi di cattura acquisisce il trattino e il secondo insieme acquisisce la barra rovesciata. 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 di due elementi. Se viene compilato ed eseguito con il .NET Framework 2.0 o versioni successive, il metodo restituisce una matrice di stringhe di 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' 

Se l'espressione regolare può corrispondere a una stringa vuota, Split(String, Int32) dividerà la stringa in una matrice di stringhe di caratteri a singolo, in quanto il delimitatore di stringa vuota è reperibile in ogni posizione. Nell'esempio seguente suddivide la stringa "caratteri" in come numero di elementi siano presenti nella stringa di input. Poiché la stringa null corrisponde all'inizio della stringa di input, una stringa null viene inserita all'inizio della matrice restituita. In questo modo il decimo elemento consiste di 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}

Il RegexMatchTimeoutException eccezione viene generata se il tempo di esecuzione dell'operazione di divisione supera l'intervallo di timeout specificato per il 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 un valore di timeout stabilito per il dominio applicazione in cui il Regex viene creato l'oggetto. Se il timeout non viene definito nel Regex chiamata al costruttore o nelle proprietà del dominio applicazione, o se il valore di timeout è Regex.InfiniteMatchTimeout, viene generata alcuna eccezione

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: