Részsztringek kinyerése sztringből

Ez a cikk a sztring részeinek kinyerésének néhány különböző technikáját ismerteti.

string.Split metódus

String.Split néhány metódusváltozatot biztosít, amelyekkel karakterláncokat tud felosztani rész-karakterláncok csoportjára egy vagy több megadott elválasztó karakter alapján. A végeredményben korlátozhatja az alsztringek teljes számát, levághatja a szóköz karaktereket az alsztringekből, vagy kizárhatja az üres részszúrásokat.

Az alábbi példák három különböző túlterhelést mutatnak a String.Split()-nél. Az első példa elválasztó karakterek megadása nélkül hívja meg a Split(Char[]) függvény túlterhelést. Ha nem ad meg elválasztó karaktereket, a String.Split() alapértelmezett elválasztójeleket, azaz szóköz karaktereket használ a sztring felosztásához.

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.

Mint látható, a pont karakterek (.) két részszúrásban szerepelnek. Ha ki szeretné zárni a pont karaktereket, a pont karaktert további elválasztó karakterként is hozzáadhatja. A következő példa bemutatja, hogyan teheti ezt meg.

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:

Az időszakok el lettek távolítva az alsztringekből, de most már két további üres részszúrást is belefoglaltak. Ezek az üres részsztringek a szót és az azt követő pont közötti részsztringet jelölik. Ha üres részstringeket szeretne kihagyni az eredményül kapott tömbből, meghívhatja a Split(Char[], StringSplitOptions) túlterhelést, és megadhatja StringSplitOptions.RemoveEmptyEntries a options paramétert.

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áris kifejezések

Ha a karakterlánc egy rögzített mintának felel meg, egy reguláris kifejezéssel kinyerheti és kezelheti annak elemeit. Ha például a sztringek "szám operandusszám" alakot használnak, akkor egy reguláris kifejezéssel kinyerheti és kezelheti a sztring elemeit. Itt egy példa:

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($"{m.Value} = {value1 + value2}");
                break;
            case "-":
                Console.WriteLine($"{m.Value} = {value1 - value2}");
                break;
            case "*":
                Console.WriteLine($"{m.Value} = {value1 * value2}");
                break;
            case "/":
                Console.WriteLine($"{m.Value} = {value1 / value2:N2}");
                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

A reguláris kifejezésminta (\d+)\s+([-+*/])\s+(\d+) a következőképpen van definiálva:

Minta Leírás
(\d+) Egy vagy több számjegy illesztése. Ez az első rögzítési csoport.
\s+ Egy vagy több szóköz karakter illesztése.
([-+*/]) Egy aritmetikai operátorjel (+, -, *vagy /) egyeztetése. Ez a második rögzítési csoport.
\s+ Egy vagy több szóköz karakter illesztése.
(\d+) Egy vagy több számjegy illesztése. Ez a harmadik rögzítési csoport.

Normál kifejezéssel is kinyerhet részsztringeket egy sztringből egy minta alapján, nem pedig rögzített karakterkészlet alapján. Ez egy gyakori forgatókönyv, ha az alábbi feltételek valamelyike következik be:

  • Egy vagy több elválasztó karakter nem mindig szolgál elválasztóként a String példányban.

  • Az elválasztó karakterek sorrendje és száma változó vagy ismeretlen.

Például, a Split metódus nem használható a következő sztring különválasztására, mert a \n (sortörés) karakterek száma változó, és nem mindig szolgálnak elválasztóként.

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

A reguláris kifejezések könnyen feloszthatják ezt a sztringet, ahogy az alábbi példa is mutatja.

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($"{++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.

A reguláris kifejezésminta \[([^\[\]]+)\] a következőképpen van definiálva:

Minta Leírás
\[ Egyeztessen egy nyitó zárójelet.
([^\[\]]+) Illeszkedik minden olyan karakterre, amely nem nyitó vagy záró zárójel, és legalább egyszer előfordul. Ez az első rögzítési csoport.
\] Egyező zárójelet találni.

A Regex.Split metódus majdnem megegyezik String.Splitazzal a kivételrel, hogy rögzített karakterkészlet helyett normál kifejezésminta alapján oszt fel egy sztringet. Az alábbi példa például egy sztring felosztására használja a Regex.Split metódust, amely kötőjelek és egyéb karakterek különböző kombinációi által tagolt részsztringeket tartalmaz.

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

A reguláris kifejezésminta \s-\s?[+*]?\s?-\s a következőképpen van definiálva:

Minta Leírás
\s- Egyezik egy szóköz karakterrel, amelyet egy kötőjel követ.
\s? Egyezik a nulla vagy egy szóköz karakterrel.
[+*]? Egyezik a + vagy * karakter nullával vagy egy előfordulásával.
\s? Egyezik a nulla vagy egy szóköz karakterrel.
-\s Egyezik egy kötőjellel, majd egy szóköz karakterrel.

String.IndexOf és String.Substring metódusok

Ha nem érdekli egy sztring összes alsztringje, érdemes lehet az egyik sztring-összehasonlító módszerrel dolgozni, amely visszaadja azt az indexet, amelyen az egyezés kezdődik. Ezután meghívhatja a Substring metódust a kívánt részstring kinyeréséhez. A karakterlánc összehasonlító módszerei a következők:

  • IndexOf, amely egy karakter vagy sztring első előfordulásának nullaalapú indexét adja vissza egy sztringpéldányban.

  • IndexOfAny, amely a karaktertömbben lévő karakterek első előfordulásának aktuális sztringpéldányában lévő nulla alapú indexet adja vissza.

  • LastIndexOf, amely egy karakterláncpéldányban egy karakter vagy sztring utolsó előfordulásának nulla alapú indexét adja vissza.

  • LastIndexOfAny, amely egy nulla alapú indexet ad vissza a karaktertömbben lévő karakterek utolsó előfordulásának aktuális sztringpéldányában.

Az alábbi példa a IndexOf metódussal keresi meg a karaktersorozatban lévő pontok helyét. Ezután a Substring módszert használja a teljes mondatok visszaadásához.

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.

Tartományok és indexek

A C# -tartomány operátora .. és az index-from-end operátor ^ lehetővé teszi az alsztringek kinyerését tömör szintaxis használatával. Ezeket az operátorokat közvetlenül sztringekre alkalmazhatja anélkül, hogy a Substring-t hívná meg.

Az alábbi példa számos módszert mutat be egy sztring részeinek tartományokkal való kinyerésére:

string str = "Hello, World!";

// Get the first 5 characters.
string hello = str[..5];
Console.WriteLine(hello);
// Output: Hello

// Get the last 6 characters.
string world = str[^6..];
Console.WriteLine(world);
// Output: World!

// Get characters from index 7 through 11 (exclusive of 12).
string substr = str[7..12];
Console.WriteLine(substr);
// Output: World

A következő példa az index-from-end operátor használatával távolít el egy fájlkiterjesztést (az utolsó három karaktert) az elérési útból:

string filePath = "C:\\Users\\user1\\bin\\fileA.cs";

// Remove the last 3 characters (.cs extension).
string trimmedPath = filePath[..^3];
Console.WriteLine(trimmedPath);
// Output: C:\Users\user1\bin\fileA

Megjegyzés:

A tartományok és az index-from-end operátor C#-funkciók. A Visual Basic nem támogatja ezt a szintaxist; használja helyette a Substring-t.

Lásd még

  • Last updated on