Metody stringów w C#: Split, Replace, Contains, IndexOf, Trim, Join i inne

System.String ma dziesiątki metod. Ta strona omawia te, które w prawdziwym kodzie wykonują większość pracy, razem z opcjami i pułapkami, które mają znaczenie. Jedna zasada dotyczy wszystkich: stringi są niemutowalne, więc każda metoda zwraca nowy string (albo wartość), a oryginał zostaje bez zmian. Samo s.Trim(); w osobnej linii nic nie robi; pisz s = s.Trim();.

Split

Split dzieli string na string[] w miejscu każdego separatora:

using System;

class Program
{
    static void Main()
    {
        string csv = "apple,banana,cherry";
        string[] fruits = csv.Split(',');
        Console.WriteLine(fruits.Length);
        foreach (string f in fruits) Console.WriteLine(f);

        // Several separator characters
        string messy = "red;green, blue|yellow";
        string[] colors = messy.Split(new[] { ';', ',', '|' });
        Console.WriteLine(string.Join("/", colors));

        // A separator longer than one character
        string log = "INFO -> started -> ready";
        string[] steps = log.Split(new[] { " -> " }, StringSplitOptions.None);
        Console.WriteLine(string.Join("/", steps));
    }
}

Wynik:

3
apple
banana
cherry
red/green/ blue/yellow
INFO/started/ready

Zwróć uwagę na " blue": Split tnie dokładnie na separatorze i zachowuje spacje. Dwie opcje załatwiają typowe porządki:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string tags = "c#, ,dotnet,,  linq ";

        string[] raw = tags.Split(',');
        Console.WriteLine(raw.Length);   // empty and blank parts included

        string[] noEmpty = tags.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine(noEmpty.Length);

        string[] clean = tags.Split(',')
            .Select(t => t.Trim())
            .Where(t => t.Length > 0)
            .ToArray();
        Console.WriteLine(string.Join("|", clean));

        // Limit the number of parts: the last one keeps the rest
        string header = "Subject: Re: Meeting: Friday";
        string[] kv = header.Split(new[] { ':' }, 2);
        Console.WriteLine($"key=[{kv[0]}] value=[{kv[1].Trim()}]");

        string words = "one  two   three";
        Console.WriteLine(words.Split((char[])null, StringSplitOptions.RemoveEmptyEntries).Length); // split on any whitespace
    }
}

Wynik:

5
4
c#|dotnet|linq
key=[Subject] value=[Re: Meeting: Friday]
3

RemoveEmptyEntries usuwa fragmenty o długości zero, ale nie te złożone z samych spacji (" " przetrwało powyżej). .NET 5 dodał StringSplitOptions.TrimEntries i obie opcje można łączyć: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) daje czysty wynik w jednym wywołaniu. Przekazanie null jako separatora dzieli po dowolnym białym znaku, co jest typowym sposobem na podział tekstu na słowa.

Podział po pojedynczym char (Split(',')) nie wymaga tablicy. Przeciążenia przyjmujące char z opcjami albo pojedynczy string istnieją od .NET Core 2.0; formy z tablicą użyte powyżej działają wszędzie, także w .NET Framework i Unity.

Replace

Replace zastępuje każde wystąpienie znaku lub podciągu:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string phone = "555-123-4567";
        Console.WriteLine(phone.Replace("-", ""));       // remove
        Console.WriteLine(phone.Replace('-', '.'));      // char overload

        string text = "Cats and cats and CATS";
        Console.WriteLine(text.Replace("cats", "dogs")); // case-sensitive
        Console.WriteLine(text.Replace("cats", "dogs", StringComparison.OrdinalIgnoreCase));

        // Only the first occurrence
        var first = new Regex("cats", RegexOptions.IgnoreCase);
        Console.WriteLine(first.Replace(text, "dogs", 1));

        // Collapse repeated spaces
        Console.WriteLine(Regex.Replace("too    many   spaces", @"\s+", " "));
    }
}

Wynik:

5551234567
555.123.4567
Cats and dogs and CATS
dogs and dogs and dogs
dogs and cats and CATS
too many spaces

Przeciążenie z argumentem StringComparison jest dostępne w .NET Core 2.0 i nowszych. W .NET Framework zamianę bez rozróżniania wielkości liter robi się przez Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Zamiana na "" to sposób na usuwanie znaków, a łańcuch kilku wywołań Replace sprawdza się przy kilku podstawieniach.

Contains, IndexOf, StartsWith i EndsWith

Te metody wyszukują. Contains odpowiada tak lub nie; IndexOf i LastIndexOf zwracają pozycję albo -1, gdy nie ma dopasowania; StartsWith i EndsWith sprawdzają początek i koniec.

using System;

class Program
{
    static void Main()
    {
        string subject = "Invoice #4471 overdue: please pay";

        Console.WriteLine(subject.Contains("overdue"));                    // True
        Console.WriteLine(subject.Contains("OVERDUE"));                    // False: case-sensitive
        Console.WriteLine(subject.Contains("OVERDUE", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine(subject.IndexOf("OVERDUE", StringComparison.OrdinalIgnoreCase) >= 0);

        Console.WriteLine(subject.IndexOf('#'));            // 8
        Console.WriteLine(subject.IndexOf("pay"));          // first "pay"
        Console.WriteLine(subject.LastIndexOf('e'));
        Console.WriteLine(subject.IndexOf("refund"));       // -1: not found
        Console.WriteLine(subject.IndexOf('e', 10));        // search from index 10

        string file = "photo.JPG";
        Console.WriteLine(file.EndsWith(".jpg"));           // False
        Console.WriteLine(file.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine("https://coddy.tech".StartsWith("https://"));
    }
}

Wynik:

True
False
True
True
8
30
28
-1
16
False
True
True

Domyślnie wszystkie rozróżniają wielkość liter. Contains(string, StringComparison) istnieje w .NET Core 2.1 i nowszych; forma IndexOf(...) >= 0 działa w każdej wersji, dlatego widać ją w starszym kodzie. IndexOfAny(new[] { ',', ';' }) znajduje pierwszy z kilku znaków.

Uwaga o kulturze: bez StringComparison metody StartsWith, EndsWith, IndexOf(string) i CompareTo stosują reguły zależne od kultury, a Contains, Replace i IndexOf(char) porównują porządkowo. Jawne przekazanie StringComparison.Ordinal lub OrdinalIgnoreCase usuwa tę niejednoznaczność i zalecają to analizatory kodu.

Trim, TrimStart i TrimEnd

Trim usuwa białe znaki (spacje, tabulatory, nowe linie) z obu końców. TrimStart i TrimEnd usuwają je z jednego końca. Jeśli podasz znaki, usuwają właśnie je:

using System;

class Program
{
    static void Main()
    {
        string input = "  \t ana@example.com \n";
        Console.WriteLine($"[{input.Trim()}]");
        Console.WriteLine($"[{input.TrimStart()}]".Replace("\n", "\\n"));
        Console.WriteLine($"[{"  x  ".TrimEnd()}]");

        Console.WriteLine("***SALE***".Trim('*'));
        Console.WriteLine("007".TrimStart('0'));
        Console.WriteLine("path/to/dir///".TrimEnd('/'));
        Console.WriteLine("1,234.50 USD".TrimEnd(' ', 'U', 'S', 'D'));
    }
}

Wynik:

[ana@example.com]
[ana@example.com \n]
[  x]
SALE
7
path/to/dir
1,234.50

Trim dotyka tylko końców; spacje w środku stringa zostają. TrimStart('0') na "000" zwraca pusty string, więc liczby zapisane jako tekst parsuj przez int.Parse, zamiast ręcznie obcinać zera.

ToUpper i ToLower

using System;

class Program
{
    static void Main()
    {
        string name = "maya Lopez";
        Console.WriteLine(name.ToUpper());
        Console.WriteLine(name.ToLower());
        Console.WriteLine(name.ToUpperInvariant());

        // Capitalize the first letter
        string word = "coffee";
        string capital = char.ToUpper(word[0]) + word.Substring(1);
        Console.WriteLine(capital);
    }
}

Wynik:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper i ToLower działają według bieżącej kultury, więc po turecku "i".ToUpper() to wielkie İ z kropką, a nie I. Dla identyfikatorów, kluczy i nazw plików używaj ToUpperInvariant i ToLowerInvariant. Do porównywania użyj StringComparison zamiast w ogóle zmieniać wielkość liter (zobacz stringi). Do zamiany pierwszej litery każdego słowa na wielką służy CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), choć zostawia bez zmian słowa zapisane w całości wielkimi literami.

PadLeft i PadRight

Dopełnianie dodaje znaki, aż string osiągnie łączną szerokość. Przydaje się przy wydruku o stałej szerokości i przy uzupełnianiu kodów zerami:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("42".PadLeft(6, '0'));
        Console.WriteLine("[" + "Tea".PadRight(8) + "]");
        Console.WriteLine("[" + "Tea".PadLeft(8) + "]");
        Console.WriteLine("Too long already".PadLeft(4));   // never truncates

        string[] items = { "Espresso", "Latte", "Mocha" };
        decimal[] prices = { 2.40m, 3.60m, 3.95m };
        for (int i = 0; i < items.Length; i++)
        {
            Console.WriteLine(items[i].PadRight(10, '.') + prices[i].ToString("F2").PadLeft(6));
        }
    }
}

Wynik:

000042
[Tea     ]
[     Tea]
Too long already
Espresso..  2.40
Latte.....  3.60
Mocha.....  3.95

Wyrównanie w interpolacji ({name,-10}) robi to samo w miejscu.

Join i Concat

string.Join wstawia separator między elementy dowolnej kolekcji. string.Concat łączy bez separatora:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var guests = new List<string> { "Ana", "Ben", "Chloe" };
        Console.WriteLine(string.Join(", ", guests));
        Console.WriteLine(string.Join(" + ", new[] { 1, 2, 3 }));   // any type
        Console.WriteLine(string.Join(",", new string[0]) == "");    // empty input: empty string

        Console.WriteLine(string.Concat("2026", "-", "09"));
        Console.WriteLine(string.Concat(guests));

        // "A, B and C"
        string list = guests.Count > 1
            ? string.Join(", ", guests.GetRange(0, guests.Count - 1)) + " and " + guests[guests.Count - 1]
            : string.Join("", guests);
        Console.WriteLine(list);
    }
}

Wynik:

Ana, Ben, Chloe
1 + 2 + 3
True
2026-09
AnaBenChloe
Ana, Ben and Chloe

Join to właściwy sposób na zbudowanie listy z separatorami: nie trzeba usuwać separatora na końcu, a wynik powstaje w jednym przebiegu. Wywołuje ToString() na każdym elemencie, więc działa też z liczbami i obiektami.

Reverse, Insert i Remove

Nie ma metody string.Reverse, która zwraca string. Dwa typowe podejścia:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string word = "stressed";

        char[] chars = word.ToCharArray();
        Array.Reverse(chars);
        Console.WriteLine(new string(chars));

        Console.WriteLine(new string(word.Reverse().ToArray()));   // LINQ

        string racecar = "Racecar";
        string lower = racecar.ToLowerInvariant();
        Console.WriteLine(lower == new string(lower.Reverse().ToArray()));  // palindrome?

        Console.WriteLine("2026-09".Insert(4, "/Q3"));     // insert at an index
        Console.WriteLine("Hello, World".Remove(5));        // everything from index 5 removed
        Console.WriteLine("Hello, World".Remove(5, 2));     // 2 chars removed at 5
    }
}

Wynik:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

Samo word.Reverse() zwraca IEnumerable<char>, a nie string; wypisanie go pokazuje nazwę typu. Obie metody odwracają jednostki kodowe UTF-16, co psuje znaki złożone z dwóch jednostek (większość emoji) i litery z łączonymi akcentami.

Ściąga