Wyodrębnianie podciągów z ciągu
W tym artykule opisano kilka różnych technik wyodrębniania części ciągu.
- Użyj metody Split, gdy żądane podciągi są rozdzielane przez znany znak ogranicznika (lub znaki).
- Wyrażenia regularne są przydatne, gdy ciąg jest zgodny ze stałym wzorcem.
- Użyj metod IndexOf i Substring w połączeniu, gdy nie chcesz wyodrębniać wszystkich podciągów w ciągu.
String.Split, metoda
String.Split Udostępnia kilka przeciążeń, które ułatwiają podzielenie ciągu na grupę podciągów na podstawie jednego lub większej liczby znaków ograniczników, które określisz. Możesz ograniczyć całkowitą liczbę podciągów w końcowym wyniku, przyciąć znaki odstępu z podciągów lub wykluczyć puste podciągy.
W poniższych przykładach przedstawiono trzy różne przeciążenia elementu String.Split(). Pierwszy przykład wywołuje Split(Char[]) przeciążenie bez przekazywania znaków separatora. Jeśli nie określisz żadnych znaków ograniczników, String.Split() użyj domyślnych ograniczników, które są znakami odstępu, aby podzielić ciąg.
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 widać, znaki kropki (.) są uwzględnione w dwóch podciągach. Jeśli chcesz wykluczyć znaki kropki, możesz dodać znak kropki jako dodatkowy znak ogranicznika. W następnym przykładzie pokazano, jak to zrobić.
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:
Okresy pochodzą z podciągów, ale teraz zostały uwzględnione dwa dodatkowe puste podciągy. Te puste podciągy reprezentują podciąg między wyrazem a kropką, która następuje po nim. Aby pominąć puste podciągnięcia z wynikowej tablicy, można wywołać Split(Char[], StringSplitOptions) przeciążenie i określić 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
Wyrażenia regularne
Jeśli ciąg jest zgodny ze stałym wzorcem, możesz użyć wyrażenia regularnego, aby wyodrębnić i obsłużyć jego elementy. Jeśli na przykład ciągi mają postać "liczba operandów liczbowych", możesz użyć wyrażenia regularnego, aby wyodrębnić i obsłużyć elementy ciągu. Oto przykład:
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
Wzorzec (\d+)\s+([-+*/])\s+(\d+) wyrażenia regularnego jest zdefiniowany w następujący sposób:
| Wzorzec | opis |
|---|---|
(\d+) |
Dopasowanie do co najmniej jednej cyfry dziesiętnej. Jest to pierwsza grupa przechwytywania. |
\s+ |
Dopasuj co najmniej jeden znak odstępu. |
([-+*/]) |
Dopasuj znak operatora arytmetycznego (+, -, *lub /). Jest to druga grupa przechwytywania. |
\s+ |
Dopasuj co najmniej jeden znak odstępu. |
(\d+) |
Dopasowanie do co najmniej jednej cyfry dziesiętnej. Jest to trzecia grupa przechwytywania. |
Można również użyć wyrażenia regularnego do wyodrębniania podciągów z ciągu na podstawie wzorca, a nie stałego zestawu znaków. Jest to typowy scenariusz, gdy wystąpi jeden z tych warunków:
Co najmniej jeden znak ogranicznika nie zawsze służy jako ogranicznik w wystąpieniu String .
Sekwencja i liczba znaków ograniczników jest zmienna lub nieznana.
Na przykład Split nie można użyć metody do podzielenia następującego ciągu, ponieważ liczba \n znaków (newline) jest zmienna i nie zawsze służą jako ograniczniki.
[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]
\n[Some more captured text:\n Option1\n Option2][Terse text.]
Wyrażenie regularne może łatwo podzielić ten ciąg, jak pokazano w poniższym przykładzie.
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.
Wzorzec \[([^\[\]]+)\] wyrażenia regularnego jest zdefiniowany w następujący sposób:
| Wzorzec | opis |
|---|---|
\[ |
Dopasuj nawias otwierający. |
([^\[\]]+) |
Dopasuj dowolny znak, który nie jest otwarciem lub nawiasem zamykającym co najmniej raz. Jest to pierwsza grupa przechwytywania. |
\] |
Dopasuj nawias zamykający. |
Metoda jest prawie identyczna Regex.Split z String.Split, z tą różnicą, że dzieli ciąg na podstawie wzorca wyrażenia regularnego zamiast zestawu stałych znaków. Na przykład w poniższym przykładzie użyto Regex.Split metody , aby podzielić ciąg, który zawiera podciągi rozdzielone przez różne kombinacje łączników i innych znaków.
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
Wzorzec \s-\s?[+*]?\s?-\s wyrażenia regularnego jest zdefiniowany w następujący sposób:
| Wzorzec | opis |
|---|---|
\s- |
Dopasuj znak odstępu, po którym następuje łącznik. |
\s? |
Dopasowuje zero lub jeden znak odstępu. |
[+*]? |
Dopasuj zero lub jedno wystąpienie znaku + lub * . |
\s? |
Dopasowuje zero lub jeden znak odstępu. |
-\s |
Dopasuj łącznik, po którym następuje znak odstępu. |
Metody String.IndexOf i String.Substring
Jeśli nie interesuje Cię wszystkie podciągy w ciągu, warto pracować z jedną z metod porównania ciągów, która zwraca indeks, na którym rozpoczyna się dopasowanie. Następnie możesz wywołać metodę Substring w celu wyodrębnienia żądanego podciągu. Metody porównania ciągów obejmują:
IndexOf, który zwraca indeks zerowy pierwszego wystąpienia znaku lub ciągu w wystąpieniu ciągu.
IndexOfAny, który zwraca indeks oparty na zerze w bieżącym wystąpieniu ciągu pierwszego wystąpienia dowolnego znaku w tablicy znaków.
LastIndexOf, który zwraca indeks zerowy ostatniego wystąpienia znaku lub ciągu w wystąpieniu ciągu.
LastIndexOfAny, który zwraca indeks oparty na zera w bieżącym wystąpieniu ciągu ostatniego wystąpienia dowolnego znaku w tablicy znaków.
W poniższym przykładzie użyto IndexOf metody , aby znaleźć kropki w ciągu. Następnie używa Substring metody do zwracania pełnych zdań.
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.
