Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

String.Split-Methode: (Char[])

 

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parameter

separator
Type: System.Char[]

Ein Zeichenarray, das die Teilzeichenfolgen in dieser Zeichenfolge trennt, ein leeres Array ohne Trennzeichen oder null.

Rückgabewert

Type: System.String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch ein oder mehr Zeichen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Wenn eine Zeichenfolge von einem bekannten Satz von Zeichen getrennt sind, können Sie die Split(Char[]) Methode in Teilzeichenfolgen abzugrenzen. Andere Möglichkeiten, um Teilzeichenfolgen aus einer Zeichenfolge zu extrahieren, finden Sie unter der Alternativen zu String.Split Abschnitt.

Trennzeichen sind nicht in den Elementen im zurückgegebenen Array enthalten. Beispielsweise enthält das Array Trennzeichen das Zeichen "-" und der Wert der aktuellen Zeichenfolgeninstanz "aa-bb-cc", die Methode gibt ein Array, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn keine Zeichen in dieser Instanz enthält separator, das zurückgegebene Array besteht aus einem einzelnen Element, das diese Instanz enthält.

Jedes Element der separator ein separates Trennzeichen definiert. Wenn zwei Trennzeichen angrenzen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Element im zurückgegebenen Array Empty. Hier einige Beispiele:

Zeichenfolgenwert

Trennzeichen

Zurückgegebene array

"42, 12, 19"

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

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

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

"42..12..19"

neue Char [] {"."} (C#)

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

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

"Banane"

neue Char [] {"."} (C#)

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

{"Banane"}

"Darb\nSmarba" (c#)

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

neue Char [] {} (c#)

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

{"Darb", "Smarba"}

"Darb\nSmarba" (c#)

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

null (C#)

Nothing (Visual Basic)

{"Darb", "Smarba"}

Jedes Element des Trennzeichens definiert ein separaten Trennzeichen, das ein einzelnes Zeichen besteht. Wenn die separator Argument ist null oder keine Zeichen enthält, die Methode behandelt Leerzeichen als Trennzeichen. Leerzeichen werden durch die Unicode-standard definiert. Diese zurückgeben true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.

Obwohl die einzelnen Parameter für diese Überladung der String.Split ist ein Array von Zeichen, wie im folgenden Beispiel gezeigt mit einem einzelnen Zeichen aufrufen.

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.

Da die separator Parameter ergänzt wird, mit der ParamArrayAttribute -Attribut, Compiler ein einzelnes Zeichen als ein Array von Einzelelement-Zeichen interpretiert werden. Dies gilt nicht für andere String.Split Überladungen, die eine separator -Parameter müssen Sie explizit übergeben diese Überladungen ein Array von Zeichen als die separator Argument.

Die Split(Char[]) Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere Zeichen getrennt sind die separator array und gibt diese Teilzeichenfolgen als Elemente eines Arrays zurück.

Die Split(Char[]) Methode sucht nach Trennzeichen, durch das Durchführen von Vergleichen mit Ordinalsortierung Groß-/Kleinschreibung beachtet. Weitere Informationen zu Word, Zeichenfolgen- und ordinal sortiert, finden Sie unter der System.Globalization.CompareOptions Enumeration.

Die Split Methode ist nicht immer die beste Möglichkeit, eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen unterteilt. Wenn nicht alle Teilzeichenfolgen einer durch Trennzeichen getrennten Zeichenfolge extrahiert werden sollen oder eine Zeichenfolge, die basierend auf einem Muster, anstatt einen Satz von Trennzeichen analysiert werden sollen, sollten Sie die folgenden Alternativen.

Wenn Zeichenfolgen einem festen Muster entsprechen, können Sie einen regulären Ausdruck zum Extrahieren und ihre Elemente zu behandeln. Z. B. Zeichenfolgen handeln "AnzahlOperandAnzahl" können Sie eine reguläre zum Extrahieren und die Zeichenfolge Elemente behandeln. Im Folgenden ein Beispiel:

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

Muster für reguläre Ausdrücke (\d+)\s+([-+*/])\s+(\d+) wird wie folgt definiert:

Muster

Beschreibung

(\d+)

Entsprechung für mindestens eine Dezimalstelle finden. Dies ist die erste Erfassungsgruppe.

\s+

Übereinstimmung mit mindestens ein Leerzeichen Zeichen.

([-+*/])

Entspricht einem arithmetischen Operator Vorzeichen (+, -, *, oder /). Dies ist die zweite Erfassungsgruppe.

\s+

Übereinstimmung mit mindestens ein Leerzeichen Zeichen.

(\d+)

Entsprechung für mindestens eine Dezimalstelle finden. Dies ist die dritte Erfassungsgruppe.

Einen regulären Ausdruck können auch um Teilzeichenfolgen aus einer Zeichenfolge basierend auf einen festen Satz von Zeichen, anstatt ein Muster zu extrahieren. Dies ist ein gängiges Szenario, wenn eine dieser Bedingungen auftritt:

  • Mindestens eines der Trennzeichen immer verarbeitet nicht als Trennzeichen in der String Instanz.

  • Die Reihenfolge und die Anzahl der Zeichen, Trennzeichen ist variabel oder unbekannt.

Z. B. die Split Methode kann nicht so teilen Sie die folgende Zeichenfolge verwendet werden, da die Anzahl der \n (in c#) oder vbCrLf (in Visual Basic) Zeichen ist variabel, und führen Sie sie nicht immer als Trennzeichen dienen.


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

Diese Zeichenfolge kann einfach, wie das folgende Beispiel zeigt ein regulärer Ausdruck unterteilt werden.

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.

Muster für reguläre Ausdrücke \[([^\[\]]+)\] wird wie folgt definiert:

Muster

Beschreibung

\[

Übereinstimmung mit einer öffnenden Klammer.

([^\[\]]+)

Übereinstimmung mit beliebigem Zeichen, die kein öffnendes oder eine schließende Klammer ein- oder mehrmals ist ein. Dies ist die erste Erfassungsgruppe.

\]

Übereinstimmung mit einer schließenden Klammer.

Die Regex.Split Methode entspricht weitgehend dem String.Split, außer dass es sich um eine Zeichenfolge, die basierend auf das Muster eines regulären Ausdrucks anstelle einer festen Zeichensatz unterteilt. Z. B. im folgenden Beispiel wird die Regex.SplitMethode zum Aufteilen einer Zeichenfolge, die durch verschiedene Kombinationen von Bindestrichen und andere Zeichen als Trennzeichen für Teilzeichenfolgen enthält.

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

Muster für reguläre Ausdrücke \s-\s?[+*]?\s?-\s wird wie folgt definiert:

Muster

Beschreibung

\s-

Entspricht einem Leerzeichen, gefolgt von einem Bindestrich.

\s?

Übereinstimmung mit keinem oder einem Leerzeichen Zeichen.

[+*]?

Übereinstimmung mit keinem oder einem Vorkommen entweder das + oder * Zeichen.

\s?

Übereinstimmung mit keinem oder einem Leerzeichen Zeichen.

-\s

Übereinstimmung mit einem Bindestrich gefolgt von einem Leerzeichen.

Wenn Sie nicht alle der Teilzeichenfolgen in einer Zeichenfolge interessiert sind, empfiehlt es sich, arbeiten mit einer der Methoden zum Zeichenfolgenvergleich, die den Index zurückgibt, an dem der Vergleich beginnt. Rufen Sie dann die Substring Methode, um die Teilzeichenfolge extrahiert, die Sie möchten. Die Methoden zum Zeichenfolgenvergleich gehören:

  • IndexOf, die den nullbasierten Index des ersten Vorkommens eines Zeichens oder einer Zeichenfolge in eine Zeichenfolgeninstanz zurückgibt.

  • IndexOfAny, die den nullbasierten Index in der aktuellen Zeichenfolgeninstanz des ersten Vorkommens eines beliebigen Zeichens aus einem Array von Zeichen zurückgibt.

  • LastIndexOf, die den nullbasierten Index des letzten Vorkommens eines Zeichens oder einer Zeichenfolge in eine Zeichenfolgeninstanz zurückgibt.

  • LastIndexOfAny, womit einen nullbasierten Index in der aktuellen Zeichenfolgeninstanz des letzten Vorkommens eines beliebigen Zeichens aus einem Array von Zeichen zurückgegeben.

Im folgenden Beispiel wird die IndexOf Methode, um die Punkte in einer Zeichenfolge zu ermitteln. Es verwendet dann die Substring Methode, um vollständige Sätze zurückzugeben.

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.

DieSplit Methoden von Arbeitsspeicher für das zurückgegebene Array-Objekt und ein String -Objekt für jedes Arrayelement. Wenn Ihre Anwendung eine optimale Leistung erfordert oder Verwalten von speicherbelegung in Ihrer Anwendung wichtig ist, sollten Sie mithilfe der IndexOf oder IndexOfAny Methode. Sie haben auch die Möglichkeit der Verwendung der Compare Methode, um eine Teilzeichenfolge innerhalb einer Zeichenfolge suchen.

Um eine Zeichenfolge an einem Trennzeichen teilen möchten, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge. Um eine Zeichenfolge an einem Trennzeichen teilen möchten, verwenden die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen der verbleibenden Zeichen der Zeichenfolge als Trennzeichen gleich sind.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dies reduziert wesentlich den Mehraufwand von jedem Methodenaufruf.

Hinweise für Aufrufer:

In der .NET Framework 3.5 und frühere Versionen, wenn die Split -Methode übergeben eine separator also null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen der Zeichenfolge als der Trim Methode hat, um die Zeichenfolge abzuschneiden. In der .NET Framework 4, beide Methoden verwenden einen identischen Satz von Unicode-Leerzeichen.

Im folgenden Beispiel wird veranschaulicht, wie einzelne Wörter aus einem Text-Block zum Behandeln von Leerzeichen und Satzzeichen, als Trennzeichen zu extrahieren. Das Zeichenarray übergeben, um die separator Parameter von der String.Split(Char[]) Methode besteht aus einem Leerzeichen und einem Tabstoppzeichen, zusammen mit einigen häufig verwendeten Interpunktionszeichen.

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

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: