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 String.Split (Char[])

 

Suddivide una stringa in sottostringhe basate sui caratteri in una matrice.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public string[] Split(
	params char[] separator
)

Parametri

separator
Type: System.Char[]

Matrice di caratteri che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.

Valore restituito

Type: System.String[]

Matrice i cui elementi contengono le sottostringhe da questa istanza delimitate da uno o più caratteri in separator. Per altre informazioni, vedere la sezione Osservazioni.

Quando una stringa è delimitata da un set di caratteri noto, è possibile utilizzare il Split(Char[]) metodo per separarlo in sottostringhe. Per altri modi per estrarre le sottostringhe da una stringa, vedere il alternative a String. Split sezione.

Caratteri di delimitazione non sono inclusi gli elementi della matrice restituita. Ad esempio, se la matrice separatore include il carattere "-" e il valore dell'istanza della stringa corrente è "aa-bb-cc", il metodo restituisce una matrice che contiene tre elementi: "aa", "bb" e "cc".

Se questa istanza non contiene i caratteri in separator, la matrice restituita è costituito da un unico elemento che contiene questa istanza.

Ogni elemento di separator definisce un carattere di delimitazione separato. Se due delimitatori sono adiacenti o un delimitatore si trova all'inizio o alla fine di questa istanza, l'elemento corrispondente nella matrice restituita contiene Empty. Ecco alcuni esempi:

Valore stringa

Separatore

Matrice restituita

"42, 12, 19"

nuovo Char [] {',', ' '} (c#)

Char () = {"," c "" c}) (Visual Basic)

{"42", "", "12", "", "19"}

"42..12..19"

nuovo Char [] {'. '} (C#)

Char () = {"." c} (Visual Basic)

{"42", "", "12", "", "19"}

"Banana"

nuovo Char [] {'. '} (C#)

Char () = {"." c} (Visual Basic)

{"Banana"}

"Darb\nSmarba" (c#)

"Darb" / vbLf / "Smarba" (Visual Basic)

nuovo Char [] {} (c#)

Char () = {} (Visual Basic)

{"Darb", "Smarba"}

"Darb\nSmarba" (c#)

"Darb" / vbLf / "Smarba" (Visual Basic)

null (C#)

Nothing (Visual Basic)

{"Darb", "Smarba"}

Ogni elemento del separatore definisce un delimitatore separato costituito da un singolo carattere. Se il separator argomento null o non contiene caratteri, il metodo considera gli spazi vuoti come delimitatori. Gli spazi vuoti sono definiti da Unicode standard; restituiscono true se vengono passati il Char.IsWhiteSpace metodo.

Anche se il singolo parametro per questo overload di String.Split è una matrice di caratteri, è possibile chiamare con un singolo carattere, come illustrato nell'esempio seguente.

using System;

public class Example
{
   public static void Main()
   {
      String value = "This is a short string.";
      Char delimiter = 's';
      String[] substrings = value.Split(delimiter);
      foreach (var substring in substrings)
         Console.WriteLine(substring);
   }
}
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.

Poiché il separator parametro è decorato con il ParamArrayAttribute attributo, compilatori interpreterà un singolo carattere come una matrice di caratteri a singolo elemento. Questo non avviene per altri String.Split overload che includono un separator parametro; è necessario passare in modo esplicito questi overload una matrice di caratteri come il separator argomento.

Il Split(Char[]) metodo estrae le sottostringhe di questa stringa delimitate da uno o più dei caratteri di separator di matrice e restituisce tali sottostringhe come elementi di una matrice.

Il Split(Char[]) metodo cerca i delimitatori eseguendo confronti utilizzando regole di ordinamento ordinali tra maiuscole e minuscole. Per ulteriori informazioni sulla parola, stringa e ordinale ordinamenti, vedere il System.Globalization.CompareOptions enumerazione.

Il Split metodo non è sempre il modo migliore per suddividere una stringa delimitata in sottostringhe. Se non si desidera estrarre le sottostringhe di una stringa delimitata, o se si desidera analizzare una stringa in base a un criterio anziché un set di caratteri di delimitazione, considerare le seguenti alternative.

Se le stringhe conforme a un modello predefinito, è possibile utilizzare un'espressione regolare per estrarre e gestire i relativi elementi. Ad esempio, se le stringhe di assumono la forma "numerooperandonumero" è possibile utilizzare un espressione regolare per estrarre e gestire gli elementi della stringa. Di seguito è riportato un esempio:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                               "42 - 18", "12 * 7",
                               "2, 4, 6, 8" };
      String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";
      foreach (var expression in expressions)
         foreach (Match m in Regex.Matches(expression, pattern)) {
            int value1 = Int32.Parse(m.Groups[1].Value);
            int value2 = Int32.Parse(m.Groups[3].Value);
            switch (m.Groups[2].Value)
            {
               case "+":
                  Console.WriteLine("{0} = {1}", m.Value, value1 + value2);
                  break;
               case "-":
                  Console.WriteLine("{0} = {1}", m.Value, value1 - value2);
                  break;
               case "*":
                  Console.WriteLine("{0} = {1}", m.Value, value1 * value2);
                  break;
               case "/":
                  Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2);
                  break;
            }
         }
   }
}
// The example displays the following output:
//       16 + 21 = 37
//       31 * 3 = 93
//       28 / 3 = 9.33
//       42 - 18 = 24
//       12 * 7 = 84

Criterio di espressione regolare (\d+)\s+([-+*/])\s+(\d+) è definito come segue:

Criterio

Descrizione

(\d+)

Trova la corrispondenza con una o più cifre decimali. Equivale al primo gruppo di acquisizione.

\s+

Corrisponde a uno o più spazi vuoti.

([-+*/])

Corrisponde a un segno di operatori aritmetici (+, -, *, o /). Equivale al secondo gruppo di acquisizione.

\s+

Corrisponde a uno o più spazi vuoti.

(\d+)

Trova la corrispondenza con una o più cifre decimali. Equivale al terzo gruppo di acquisizione.

È inoltre possibile utilizzare un'espressione regolare per estrarre le sottostringhe da una stringa basata su un modello, anziché un set fisso di caratteri. Si tratta di uno scenario comune quando una di queste condizioni si verifica:

  • Uno o più i caratteri di delimitazione non sempre essere utilizzato come un delimitatore di String istanza.

  • La sequenza e il numero di caratteri di delimitazione è sconosciuto o variabile.

Ad esempio, il Split metodo non può essere utilizzato per suddividere la stringa seguente, perché il numero di \n (in c#) o vbCrLf (in Visual Basic) di caratteri è variabile e non vengono sempre utilizzati come delimitatori.


[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]
\n[Some more captured text:\n   Option1\n   Option2][Terse text.] 

Un'espressione regolare è possibile suddividere la stringa semplice, come illustrato nell'esempio seguente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String input = "[This is captured\ntext.]\n\n[\n" +
                     "[This is more captured text.]\n]\n" +
                     "[Some more captured text:\n   Option1" +
                     "\n   Option2][Terse text.]";
      String pattern = @"\[([^\[\]]+)\]";
      int ctr = 0;
      foreach (Match m in Regex.Matches(input, pattern))
         Console.WriteLine("{0}: {1}", ++ctr, m.Groups[1].Value);
   }
}
// The example displays the following output:
//       1: This is captured
//       text.
//       2: This is more captured text.
//       3: Some more captured text:
//          Option1
//          Option2
//       4: Terse text.

Criterio di espressione regolare \[([^\[\]]+)\] è definito come segue:

Criterio

Descrizione

\[

Corrisponde a una parentesi di apertura.

([^\[\]]+)

Corrisponde a qualsiasi carattere che non è una parentesi o una parentesi di chiusura una o più volte. Equivale al primo gruppo di acquisizione.

\]

Corrisponde a una parentesi di chiusura.

Il Regex.Split è pressoché identico al metodo String.Split, ad eccezione del fatto che suddivide una stringa in base a un criterio di espressione regolare invece di un set di caratteri predefinito. Ad esempio, l'esempio seguente usa il Regex.Splitmetodo per suddividere una stringa contenente le sottostringhe delimitate da varie combinazioni di trattini e altri caratteri.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String input = "abacus -- alabaster - * - atrium -+- " +
                     "any -*- actual - + - armoir - - alarm";
      String pattern = @"\s-\s?[+*]?\s?-\s";
      String[] elements = Regex.Split(input, pattern);
      foreach (var element in elements)
         Console.WriteLine(element);
   }
}
// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoir
//       alarm

Criterio di espressione regolare \s-\s?[+*]?\s?-\s è definito come segue:

Criterio

Descrizione

\s-

Corrisponde a uno spazio vuoto seguito da un trattino.

\s?

Trova la corrispondenza zero o uno spazio vuoto.

[+*]?

Corrisponde a zero o una occorrenza di uno il + o * carattere.

\s?

Trova la corrispondenza zero o uno spazio vuoto.

-\s

Corrisponde a un trattino seguito da uno spazio vuoto.

Se non si è interessati in tutte le sottostringhe in una stringa, è preferibile usare uno dei metodi di confronto tra stringhe che restituisce l'indice in corrispondenza del quale inizia la corrispondenza. È quindi possibile chiamare il Substring metodo per estrarre la sottostringa che si desidera. I metodi di confronto di stringhe includono:

  • IndexOf, che restituisce l'indice in base zero della prima occorrenza di un carattere o una stringa in un'istanza di stringa.

  • IndexOfAny, che restituisce l'indice in base zero nell'istanza della stringa corrente della prima occorrenza di qualsiasi carattere presente in una matrice di caratteri.

  • LastIndexOf, che restituisce l'indice in base zero dell'ultima occorrenza di un carattere o una stringa in un'istanza di stringa.

  • LastIndexOfAny, che restituisce un indice in base zero nell'istanza corrente di stringa dell'ultima occorrenza di qualsiasi carattere presente in una matrice di caratteri.

L'esempio seguente usa il IndexOf metodo per individuare i periodi in una stringa. Viene quindi utilizzato il Substring per restituire frasi intere.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      String value = "This is the first sentence in a string. " +
                     "More sentences will follow. For example, " +
                     "this is the third sentence. This is the " +
                     "fourth. And this is the fifth and final " +
                     "sentence.";
      var sentences = new List<String>();
      int position = 0;
      int start = 0;
      // Extract sentences from the string.
      do {
         position = value.IndexOf('.', start);
         if (position >= 0) {
            sentences.Add(value.Substring(start, position - start + 1).Trim());
            start = position + 1;
         }
      } while (position > 0);

      // Display the sentences.
      foreach (var sentence in sentences)
         Console.WriteLine(sentence);
   }
}
// The example displays the following output:
//       This is the first sentence in a string.
//       More sentences will follow.
//       For example, this is the third sentence.
//       This is the fourth.
//       And this is the fifth and final sentence.

IlSplit metodi allocano memoria per l'oggetto matrice restituito e un String oggetto per ogni elemento della matrice. Se l'applicazione richiede di ottenere prestazioni ottimali, o se la gestione dell'allocazione di memoria critico dell'applicazione, è possibile utilizzare il IndexOf o IndexOfAny metodo. È inoltre la possibilità di usare il Compare metodo per individuare una sottostringa all'interno di una stringa.

Per suddividere una stringa in un carattere separatore, utilizzare il IndexOf o IndexOfAny metodo per individuare un carattere di separazione della stringa. Per suddividere una stringa in una stringa di separazione, utilizzare il IndexOf o IndexOfAny metodo per individuare il primo carattere della stringa di separazione. Utilizzare quindi la Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.

Inoltre, se lo stesso set di caratteri viene utilizzato per suddividere in più stringhe Split chiamate al metodo, prendere in considerazione la creazione di una matrice e farvi riferimento in ogni chiamata al metodo. Questo riduce notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.

Note per i chiamanti:

Nel .NET Framework 3.5 e versioni precedenti, se il Split viene passato un separator ovvero null o non contiene caratteri, il metodo utilizza un set di caratteri leggermente diverso per suddividere la stringa che il Trim metodo consente di tagliare la stringa. Nel .NET Framework 4, entrambi i metodi utilizzano un set identico di caratteri spazi vuoti Unicode.

Nell'esempio seguente viene illustrato come estrarre singole parole da un blocco di testo trattando spazi e segni di punteggiatura come delimitatori. Passata la matrice di caratteri di separator parametro del String.Split(Char[]) metodo è costituito da uno spazio e un carattere di tabulazione, con alcuni simboli di punteggiatura comuni.

using System;

public class SplitTest {
    public static void Main() {

        string words = "This is a list of words, with: a bit of punctuation" +
                       "\tand a tab character.";

        string [] split = words.Split(new Char [] {' ', ',', '.', ':', '\t' });

        foreach (string s in split) {

            if (s.Trim() != "")
                Console.WriteLine(s);
        }
    }
}
// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character

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: