Teilen von Zeichenfolgen in Teilzeichenfolgen in C#

Tip

Dieser Artikel ist Teil des Abschnitts "Grundlagen" für Entwickler, die bereits mindestens eine Programmiersprache kennen und C# erlernen. Wenn Sie noch nicht mit der Programmierung vertraut sind, beginnen Sie zuerst mit den Lernprogrammen " Erste Schritte ".

Kommen Sie aus einer anderen Sprache?string.Split ist das C#-Gegenstück zu Javas String.split und JavaScripts String.prototype.split. Im Gegensatz zu diesen Sprachen gibt C# ein Array (string[]), keine Liste zurück, und das Trennzeichenargument ist ein Zeichen oder eine Zeichenfolge, kein regulärer Ausdruck. Informationen zur musterbasierten Aufteilung finden Sie unter Regex.Split.

Die String.Split Methode bricht eine Zeichenfolge in ein Array von Teilzeichenfolgen unter Verwendung eines oder mehrerer Trennzeichen auf. Es ist die einfachste Möglichkeit, getrennten Text wie Wörter, CSV-Formatwerte oder Protokolltoken zu analysieren.

Die Methode hat viele Überladungen, aber damit werden vier unabhängige Entscheidungen abgedeckt:

  • Trennzeichen: ein char, ein Array von char, eins stringoder ein Array von string.
  • Maximale Ergebnisanzahl: Die Anzahl der zurückgegebenen Teilzeichenfolgen wird begrenzt.
  • Behandlung leerer Einträge: Leere Teilzeichenfolgen beibehalten (Standard) oder ablegen mit StringSplitOptions.RemoveEmptyEntries.
  • Leerzeichenbehandlung: Kürzen Sie führende und nachfolgende Leerzeichen von jedem Eintrag mit StringSplitOptions.TrimEntries.

Aufteilen einer Zeichenfolge in Wörter

Um eine Phrase anhand von Leerraumzeichen zu trennen, übergeben Sie ' ' als Trennzeichen:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ');

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => <The>
// => <quick>
// => <brown>
// => <fox>
// => <jumps>
// => <over>
// => <the>
// => <lazy>
// => <dog.>

Durchlaufen Sie das zurückgegebene Array mit for, um die Position jedes Worts zu ermitteln:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ');

for (int i = 0; i < words.Length; i++)
{
    Console.WriteLine($"Index {i}: <{words[i]}>");
}
// => Index 0: <The>
// => Index 1: <quick>
// => Index 2: <brown>
// => ...

Wenn die Eingabe wiederholte Vorkommen des Trennzeichens enthält, erzeugt Split leere Einträge, jeweils einen für jede „Lücke“ zwischen aufeinanderfolgenden Trennzeichen:

string phrase = "The quick brown    fox     jumps over the lazy dog.";
string[] words = phrase.Split(' ');

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// The runs of spaces produce empty entries:
// => <The>
// => <quick>
// => <brown>
// => <>
// => <>
// => <>
// => <fox>
// => ...

Übergeben Sie StringSplitOptions.RemoveEmptyEntries, um diese leeren Einträge zu entfernen, wie weiter unten in diesem Artikel gezeigt.

Auf mehrere Trennzeichen teilen

Wenn mehrere Zeichen als Trennzeichen fungieren können, übergeben Sie sie als Array. Im folgenden Beispiel werden Leerzeichen, Kommas, Punkte, Doppelpunkte und Tabulatoren als Wortgrenzen behandelt:

char[] delimiters = [' ', ',', '.', ':', '\t'];

string text = "one\ttwo three:four,five six seven";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(delimiters);
Console.WriteLine($"{words.Length} words in text:");

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => 7 words in text:
// => <one>
// => <two>
// => <three>
// => <four>
// => <five>
// => <six>
// => <seven>

Benachbarte Trennzeichen erzeugen weiterhin leere Einträge:

char[] delimiters = [' ', ',', '.', ':', '\t'];

string text = "one\ttwo :,five six seven";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(delimiters);
Console.WriteLine($"{words.Length} words in text:");

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => 7 words in text:
// => <one>
// => <two>
// => <>
// => <>
// => <five>
// => <six>
// => <seven>

Aufteilen anhand von Trennzeichen mit mehreren Zeichen

Übergeben Sie ein Array von Zeichenfolgen, um anhand von Trennzeichen zu teilen, die aus ganzen Wörtern oder mehreren Zeichen bestehen. Für die Zeichenfolgenarrayüberladungen ist ein StringSplitOptions Wert erforderlich. Verwenden Sie RemoveEmptyEntries, wenn wiederholte Trennzeichen andernfalls leere Ergebnisse erzeugen würden:

string[] separators = ["<<", "..."];

string text = "one<<two......three<four";
Console.WriteLine($"Original text: '{text}'");

string[] words = text.Split(separators, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"{words.Length} substrings in text:");

foreach (var word in words)
{
    Console.WriteLine(word);
}
// => 3 substrings in text:
// => one
// => two
// => three<four

Begrenzen Sie, wie viele Teilzeichenfolgen Sie zurückerhalten

Übergeben Sie das Argument count, um die Anzahl der Ergebnisse zu begrenzen. Der letzte Eintrag enthält alles, was übrig ist, einschließlich aller verbleibenden Trennzeichen:

string phrase = "The quick brown fox jumps over the lazy dog.";
string[] words = phrase.Split(' ', 4, StringSplitOptions.None);

foreach (var word in words)
{
    Console.WriteLine($"<{word}>");
}
// => <The>
// => <quick>
// => <brown>
// => <fox jumps over the lazy dog.>

Dieses Muster eignet sich für key=value Paare und andere Formate, bei denen nur das erste Trennzeichen aussagekräftig ist.

Leerzeichen aus jedem Eintrag entfernen

StringSplitOptions.TrimEntries Entfernt führende und nachfolgende Leerzeichen von jeder zurückgegebenen Teilzeichenfolge. Sie können es mit RemoveEmptyEntries für die typische CSV-Bereinigung kombinieren:

string numerals = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10";
string[] trimmed = numerals.Split(',', StringSplitOptions.TrimEntries);

Console.WriteLine("Trimmed entries:");
foreach (var word in trimmed)
{
    Console.WriteLine($"<{word}>");
}

string[] untrimmed = numerals.Split(',', StringSplitOptions.None);
Console.WriteLine("Untrimmed entries:");
foreach (var word in untrimmed)
{
    Console.WriteLine($"<{word}>");
}
// => Trimmed entries: <1> <2> ... <10>
// => Untrimmed entries: <1> < 2> ... < 10>

Reguläre Ausdrücke verwenden

Split eignet sich gut für feste Trennzeichen für Zeichen oder Zeichenfolgen. Verwenden Sie Regex.Splitfür die musterbasierte Aufteilung . Eine Einführung in reguläre Ausdrücke für Zeichenfolgen finden Sie unter String-Vorgänge.

Siehe auch

  • Last updated on