Phương thức chuỗi trong C#: Split, Replace, Contains, IndexOf, Trim, Join

System.String có hàng chục phương thức. Trang này trình bày những phương thức gánh phần lớn công việc trong code thực tế, cùng các tùy chọn và cạm bẫy đáng chú ý. Có một quy tắc áp dụng cho tất cả: chuỗi là bất biến (immutable), nên mọi phương thức đều trả về chuỗi mới (hoặc một giá trị) và giữ nguyên chuỗi gốc. Viết s.Trim(); trên một dòng riêng không làm gì cả; hãy viết s = s.Trim();.

Split

Split tách một chuỗi thành string[] tại mỗi dấu phân cách:

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));
    }
}

Đầu ra:

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

Để ý " blue": Split cắt đúng tại dấu phân cách và giữ lại mọi khoảng trắng. Hai tùy chọn xử lý những việc dọn dẹp thường gặp:

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
    }
}

Đầu ra:

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

RemoveEmptyEntries bỏ các phần có độ dài bằng 0 nhưng không bỏ các phần chỉ toàn khoảng trắng (" " vẫn còn ở trên). .NET 5 bổ sung StringSplitOptions.TrimEntries, và có thể kết hợp cả hai: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) cho kết quả sạch chỉ với một lời gọi. Truyền null làm dấu phân cách sẽ tách theo mọi khoảng trắng, đây là cách thường dùng để tách văn bản thành các từ.

Tách theo một char (Split(',')) không cần mảng. Các overload nhận một char kèm tùy chọn, hoặc một string, có từ .NET Core 2.0; các dạng mảng dùng ở trên chạy ở mọi nơi, kể cả .NET Framework và Unity.

Replace

Replace thay thế mọi lần xuất hiện của một ký tự hoặc chuỗi con:

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+", " "));
    }
}

Đầu ra:

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

Overload có đối số StringComparison có từ .NET Core 2.0. Trên .NET Framework, thay thế không phân biệt hoa thường được thực hiện bằng Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Thay bằng "" là cách xóa ký tự, và nối nhiều lời gọi Replace liên tiếp là ổn khi chỉ có vài phép thay thế.

Contains, IndexOf, StartsWith và EndsWith

Các phương thức này dùng để tìm kiếm. Contains trả lời có hoặc không; IndexOf và LastIndexOf trả về một vị trí, hoặc -1 khi không khớp; StartsWith và EndsWith kiểm tra hai đầu chuỗi.

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://"));
    }
}

Đầu ra:

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

Mặc định tất cả đều phân biệt hoa thường. Contains(string, StringComparison) có từ .NET Core 2.1; dạng IndexOf(...) >= 0 chạy trên mọi phiên bản, đó là lý do bạn hay thấy nó trong code cũ. IndexOfAny(new[] { ',', ';' }) tìm ký tự đầu tiên trong số nhiều ký tự.

Một lưu ý về culture: khi không có StringComparison, StartsWith, EndsWith, IndexOf(string) và CompareTo dùng quy tắc phụ thuộc culture, còn Contains, Replace và IndexOf(char) so sánh theo thứ tự mã (ordinal). Truyền tường minh StringComparison.Ordinal hoặc OrdinalIgnoreCase sẽ loại bỏ sự mơ hồ, và các công cụ phân tích code cũng khuyên làm vậy.

Trim, TrimStart và TrimEnd

Trim xóa khoảng trắng (dấu cách, tab, xuống dòng) ở cả hai đầu. TrimStart và TrimEnd xóa ở một đầu. Khi được truyền các ký tự, chúng xóa những ký tự đó thay vì khoảng trắng:

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'));
    }
}

Đầu ra:

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

Trim chỉ tác động lên hai đầu; khoảng trắng bên trong chuỗi được giữ nguyên. TrimStart('0') trên "000" trả về chuỗi rỗng, nên hãy phân tích chuỗi số bằng int.Parse thay vì tự bỏ các số 0.

ToUpper và 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);
    }
}

Đầu ra:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper và ToLower theo culture hiện tại, nên trong tiếng Thổ Nhĩ Kỳ "i".ToUpper() là chữ İ hoa có dấu chấm, không phải I. Với định danh, khóa và tên tệp, hãy dùng ToUpperInvariant và ToLowerInvariant. Khi so sánh, hãy dùng StringComparison thay vì đổi hoa thường (xem chuỗi). Để viết hoa chữ cái đầu mỗi từ, có CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), dù nó bỏ qua những từ đã viết hoa toàn bộ.

PadLeft và PadRight

Đệm chuỗi là thêm ký tự cho đến khi chuỗi đạt độ rộng tổng mong muốn. Rất tiện cho đầu ra có độ rộng cố định và cho việc đệm số 0 vào mã:

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));
        }
    }
}

Đầu ra:

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

Căn lề trong nội suy chuỗi ({name,-10}) làm cùng việc này ngay tại chỗ.

Join và Concat

string.Join đặt một dấu phân cách giữa các phần tử của bất kỳ collection nào. string.Concat nối mà không có dấu phân cách:

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);
    }
}

Đầu ra:

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

Join là cách đúng để tạo một danh sách có dấu phân cách: không có dấu phân cách thừa ở cuối cần xóa, và kết quả được tạo trong một lượt. Nó gọi ToString() trên từng phần tử, nên dùng được cả với số và đối tượng.

Reverse, Insert và Remove

Không có phương thức string.Reverse nào trả về chuỗi. Có hai cách thường dùng:

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
    }
}

Đầu ra:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

Riêng word.Reverse() trả về một IEnumerable<char>, không phải chuỗi; in nó ra chỉ thấy tên kiểu. Cả hai cách đều đảo các đơn vị mã UTF-16, làm hỏng những ký tự gồm hai đơn vị (hầu hết emoji) và chữ cái có dấu kết hợp.

Tra cứu nhanh