Extrahování podřetězců z řetězce

Tento článek popisuje některé různé techniky extrakce částí řetězce.

• Metodu Split použijte, pokud jsou podřetěžce, které chcete oddělit známým znakem oddělovače (nebo znaky).
• Regulární výrazy jsou užitečné, když řetězec odpovídá pevnému vzoru.
• Metody IndexOf a Substring použijte ve spojení, pokud nechcete extrahovat všechny podřetězce v řetězci.

String.Split – metoda

String.Split poskytuje několik přetížení, které vám pomůžou rozdělit řetězec do skupiny podřetězců na základě jednoho nebo více zadaných znaků s oddělovači. Můžete se rozhodnout omezit celkový počet podřetězců v konečném výsledku, oříznout prázdné znaky z podřetězců nebo vyloučit prázdné podřetězce.

Následující příklady ukazují tři různé přetížení String.Split(). První příklad volá Split(Char[]) přetížení bez předání znaků oddělovače. Pokud nezadáte žádné oddělovače, String.Split() rozdělí řetězec pomocí výchozích oddělovačů, což jsou prázdné znaky.

string s = "You win some. You lose some.";

string[] subs = s.Split();

foreach (string sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.

Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split()

For Each substring As String In subs
    Console.WriteLine("Substring: {0}", substring)
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some.
' Substring: You
' Substring: lose
' Substring: some.

Jak vidíte, znaky tečky (.) jsou zahrnuty do dvou podřetěžců. Pokud chcete znaky tečky vyloučit, můžete ho přidat jako další znak oddělovače. Další příklad ukazuje, jak to udělat.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ', '.');

foreach (string sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:

Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split(" "c, "."c)

For Each substring As String In subs
    Console.WriteLine("Substring: {0}", substring)
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring:
' Substring: You
' Substring: lose
' Substring: some
' Substring:

Tečky jsou pryč z podřetěžců, ale nyní byly zahrnuty dva nadbytečné prázdné podřetětěce. Tyto prázdné podřetětězí představují podřetězí mezi slovem a tečkou, která za ním následuje. Chcete-li vynechat prázdné podřetězce z výsledného pole, můžete volat Split(Char[], StringSplitOptions) přetížení a určit StringSplitOptions.RemoveEmptyEntries parametr options .

string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };

string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);

foreach (string sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some

Dim s As String = "You win some. You lose some."
Dim separators As Char() = New Char() {" "c, "."c}
Dim subs As String() = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)

For Each substring As String In subs
    Console.WriteLine("Substring: {0}", substring)
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring: You
' Substring: lose
' Substring: some

Regulární výrazy

Pokud je řetězec v souladu s pevným vzorem, můžete k extrakci a zpracování jeho prvků použít regulární výraz. Pokud například řetězce mají tvar "číslo operandu", můžete k extrakci a zpracování prvků řetězce použít regulární výraz. Tady je příklad:

String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                       "42 - 18", "12 * 7",
                       "2, 4, 6, 8" };
String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";

foreach (string expression in expressions)
{
    foreach (System.Text.RegularExpressions.Match m in
    System.Text.RegularExpressions.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

Dim expressions() As String = {"16 + 21", "31 * 3", "28 / 3",
                              "42 - 18", "12 * 7",
                              "2, 4, 6, 8"}

Dim pattern As String = "(\d+)\s+([-+*/])\s+(\d+)"
For Each expression In expressions
    For Each m As Match In Regex.Matches(expression, pattern)
        Dim value1 As Integer = Int32.Parse(m.Groups(1).Value)
        Dim value2 As Integer = Int32.Parse(m.Groups(3).Value)
        Select Case m.Groups(2).Value
            Case "+"
                Console.WriteLine("{0} = {1}", m.Value, value1 + value2)
            Case "-"
                Console.WriteLine("{0} = {1}", m.Value, value1 - value2)
            Case "*"
                Console.WriteLine("{0} = {1}", m.Value, value1 * value2)
            Case "/"
                Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2)
        End Select
    Next
Next

' The example displays the following output:
'       16 + 21 = 37
'       31 * 3 = 93
'       28 / 3 = 9.33
'       42 - 18 = 24
'       12 * 7 = 84

Vzor (\d+)\s+([-+*/])\s+(\d+) regulárního výrazu je definován takto:

Regulární výraz můžete použít také k extrakci podřetězců z řetězce založeného na vzoru místo pevné sady znaků. Jedná se o běžný scénář, kdy dojde k některé z těchto podmínek:

• Jeden nebo více znaků oddělovače nemusí v instanci vždy sloužit jako oddělovač String .

• Posloupnost a počet znaků oddělovače jsou proměnné nebo neznámé.

Například metodu Split nelze použít k rozdělení následujícího řetězce, protože počet \n znaků (newline) je proměnný a nemusí vždy sloužit jako oddělovače.

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

Regulární výraz může tento řetězec snadno rozdělit, jak ukazuje následující příklad.

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 (System.Text.RegularExpressions.Match m in
   System.Text.RegularExpressions.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.

Dim input As String = String.Format("[This is captured{0}text.]" +
                                  "{0}{0}[{0}[This is more " +
                                  "captured text.]{0}{0}" +
                                  "[Some more captured text:" +
                                  "{0}   Option1" +
                                  "{0}   Option2][Terse text.]",
                                  vbCrLf)
Dim pattern As String = "\[([^\[\]]+)\]"
Dim ctr As Integer = 0
For Each m As Match In Regex.Matches(input, pattern)
    ctr += 1
    Console.WriteLine("{0}: {1}", ctr, m.Groups(1).Value)
Next

' 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.

Vzor \[([^\[\]]+)\] regulárního výrazu je definován takto:

Metoda Regex.Split je téměř identická s String.Splittím rozdílem, že rozdělí řetězec na základě vzoru regulárního výrazu místo pevné znakové sady. Například následující příklad používá metodu Regex.Split k rozdělení řetězce, který obsahuje podřetězce oddělené různými kombinacemi spojovníků a dalších znaků.

String input = "abacus -- alabaster - * - atrium -+- " +
               "any -*- actual - + - armoire - - alarm";
String pattern = @"\s-\s?[+*]?\s?-\s";
String[] elements = System.Text.RegularExpressions.Regex.Split(input, pattern);

foreach (string element in elements)
    Console.WriteLine(element);

// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoire
//       alarm

Dim input As String = "abacus -- alabaster - * - atrium -+- " +
                    "any -*- actual - + - armoire - - alarm"
Dim pattern As String = "\s-\s?[+*]?\s?-\s"
Dim elements() As String = Regex.Split(input, pattern)
For Each element In elements
    Console.WriteLine(element)
Next

' The example displays the following output:
'       abacus
'       alabaster
'       atrium
'       any
'       actual
'       armoire
'       alarm

Vzor \s-\s?[+*]?\s?-\s regulárního výrazu je definován takto:

Metody String.IndexOf a String.Substring

Pokud vás všechny podřetězce v řetězci nezajímají, můžete raději pracovat s některou z metod porovnání řetězců, která vrátí index, na kterém začíná shoda. Potom můžete volat metodu Substring pro extrahování požadovaného podřetězce. Mezi metody porovnání řetězců patří:

• IndexOf, který vrátí index založený na nule prvního výskytu znaku nebo řetězce v instanci řetězce.

• IndexOfAny, který vrátí index založený na nule v aktuální řetězcové instanci prvního výskytu libovolného znaku v poli znaků.

• LastIndexOf, který vrátí index založený na nule poslední výskyt znaku nebo řetězce v instanci řetězce.

• LastIndexOfAny, který vrátí index založený na nule v aktuální řetězcové instanci posledního výskytu libovolného znaku v poli znaků.

Následující příklad používá metodu IndexOf k vyhledání období v řetězci. Pak použije metodu Substring k vrácení celých vět.

String s = "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 start = 0;
int position;

// Extract sentences from the string.
do
{
    position = s.IndexOf('.', start);
    if (position >= 0)
    {
        sentences.Add(s.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.

    Dim input As String = "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."
    Dim sentences As New List(Of String)
    Dim start As Integer = 0
    Dim position As Integer

    ' Extract sentences from the string.
    Do
        position = input.IndexOf("."c, start)
        If position >= 0 Then
            sentences.Add(input.Substring(start, position - start + 1).Trim())
            start = position + 1
        End If
    Loop While position > 0

    ' Display the sentences.
    For Each sentence In sentences
        Console.WriteLine(sentence)
    Next
End Sub

' 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.

Viz také

• Základní řetězcové operace v .NET
• Regulární výrazy .NET
• Analýza řetězců pomocí String.Split v jazyce C#