Substring trong C#: cắt một phần chuỗi an toàn

Substring trả về một chuỗi mới tạo từ một phần của chuỗi có sẵn. Phương thức này có hai overload:

• s.Substring(startIndex): từ startIndex đến cuối chuỗi.
• s.Substring(startIndex, length): length ký tự, bắt đầu tại startIndex.

Chỉ số bắt đầu từ 0, và đối số thứ hai là độ dài, không phải vị trí kết thúc. Đó là điểm khác với substring(start, end) của JavaScript và substring(begin, end) của Java, và là nguồn gốc của rất nhiều bug lệch vài ký tự khi chuyển code từ ngôn ngữ khác sang.

using System;

class Program
{
    static void Main()
    {
        string sku = "SHOE-4271-BLK";
        //            0123456789...

        Console.WriteLine(sku.Substring(5));        // from index 5 to the end
        Console.WriteLine(sku.Substring(0, 4));     // 4 chars from index 0
        Console.WriteLine(sku.Substring(5, 4));     // 4 chars from index 5
        Console.WriteLine(sku.Substring(10, 3));    // last 3
        Console.WriteLine(sku.Substring(sku.Length).Length); // start == Length: empty string

        Console.WriteLine(sku);                     // unchanged: strings are immutable
    }
}

Đầu ra:

4271-BLK
SHOE
4271
BLK
0
SHOE-4271-BLK

Như mọi phương thức chuỗi khác, Substring không sửa chuỗi gốc; nó trả về một chuỗi mới, nên hãy gán kết quả lại.

ArgumentOutOfRangeException và cách tránh

Substring ném ArgumentOutOfRangeException khi đoạn được yêu cầu không nằm gọn trong chuỗi: startIndex âm, startIndex lớn hơn Length, length âm, hoặc startIndex + length lớn hơn Length. Không có chuyện tự cắt ngắn lặng lẽ như slice của Python.

using System;

class Program
{
    static void Show(string label, Func<string> take)
    {
        try
        {
            Console.WriteLine($"{label} -> \"{take()}\"");
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine($"{label} -> ArgumentOutOfRangeException");
        }
    }

    static void Main()
    {
        string word = "Coffee";   // Length 6

        Show("Substring(2, 4)", () => word.Substring(2, 4));
        Show("Substring(2, 5)", () => word.Substring(2, 5));   // 2 + 5 > 6
        Show("Substring(6)", () => word.Substring(6));         // allowed: empty
        Show("Substring(7)", () => word.Substring(7));
        Show("Substring(-1)", () => word.Substring(-1));
        Show("Substring(0, 10)", () => word.Substring(0, 10));
    }
}

Đầu ra:

Substring(2, 4) -> "ffee"
Substring(2, 5) -> ArgumentOutOfRangeException
Substring(6) -> ""
Substring(7) -> ArgumentOutOfRangeException
Substring(-1) -> ArgumentOutOfRangeException
Substring(0, 10) -> ArgumentOutOfRangeException

Cách phòng thủ thông dụng là giới hạn độ dài theo phần còn lại của chuỗi bằng Math.Min:

using System;

class Program
{
    static string SafeSubstring(string s, int start, int length)
    {
        if (string.IsNullOrEmpty(s) || start >= s.Length) return "";
        if (start < 0) start = 0;
        return s.Substring(start, Math.Min(length, s.Length - start));
    }

    static void Main()
    {
        Console.WriteLine(SafeSubstring("Coffee", 2, 100));
        Console.WriteLine(SafeSubstring("Tea", 1, 2));
        Console.WriteLine($"[{SafeSubstring("Tea", 5, 2)}]");
        Console.WriteLine($"[{SafeSubstring(null, 0, 2)}]");
    }
}

Đầu ra:

ffee
ea
[]
[]

Gọi Substring trên một chuỗi null sẽ ném NullReferenceException, không phải ArgumentOutOfRangeException, vì vậy hàm hỗ trợ kiểm tra null trước tiên.

n ký tự đầu và cuối

Lấy phần đầu hoặc phần cuối là cách dùng Substring phổ biến nhất. Cả hai đều ném ngoại lệ khi chuỗi ngắn hơn n, nên code thực tế luôn kiểm tra độ dài:

using System;

class Program
{
    static string Left(string s, int n) => s.Length <= n ? s : s.Substring(0, n);
    static string Right(string s, int n) => s.Length <= n ? s : s.Substring(s.Length - n);

    static void Main()
    {
        string card = "4111111111111111";
        Console.WriteLine("**** " + Right(card, 4));

        string title = "An Unexpectedly Long Product Name";
        Console.WriteLine(Left(title, 12) + "...");

        Console.WriteLine(Left("Hi", 12));     // shorter than n: returned whole
        Console.WriteLine(Right("Hi", 4));
    }
}

Đầu ra:

**** 1111
An Unexpecte...
Hi
Hi

Khi điều bạn muốn là bỏ phần đầu chuỗi, chỉ cần Substring(n): "#FF8800".Substring(1) là "FF8800". Phương thức liên quan Remove(start, count) làm ngược lại với Substring: nó trả về chuỗi đã bỏ đi đoạn đó.

Substring kết hợp IndexOf

Phần lớn chuỗi con trong thực tế được tìm ra chứ không phải đếm ra. IndexOf trả về vị trí của một ký tự hoặc chuỗi (hoặc -1 nếu không có), còn LastIndexOf tìm từ cuối. Kết hợp chúng với Substring để cắt văn bản quanh một dấu phân cách:

using System;

class Program
{
    static void Main()
    {
        string email = "maya.lopez@example.com";
        int at = email.IndexOf('@');
        Console.WriteLine(email.Substring(0, at));       // before the @
        Console.WriteLine(email.Substring(at + 1));      // after the @

        string file = "report.final.v2.pdf";
        int dot = file.LastIndexOf('.');
        Console.WriteLine(file.Substring(dot + 1));      // extension
        Console.WriteLine(file.Substring(0, dot));       // name without extension

        string log = "2026-09-24 [WARN] Disk almost full";
        int open = log.IndexOf('[');
        int close = log.IndexOf(']', open + 1);
        Console.WriteLine(log.Substring(open + 1, close - open - 1)); // between [ and ]
        Console.WriteLine(log.Substring(close + 2));                  // the message
    }
}

Đầu ra:

maya.lopez
example.com
pdf
report.final.v2
WARN
Disk almost full

Phép tính tuân theo một quy tắc: để lấy văn bản giữa hai vị trí a và b (không bao gồm cả hai), điểm bắt đầu là a + 1 và độ dài là b - a - 1.

Nguy hiểm nằm ở chỗ IndexOf trả về -1. email.Substring(0, -1) ném ngoại lệ, và tệ hơn, email.Substring(-1 + 1) lặng lẽ trả về cả chuỗi. Luôn kiểm tra:

using System;

class Program
{
    static string Domain(string email)
    {
        int at = email.IndexOf('@');
        if (at < 0) return null;
        return email.Substring(at + 1);
    }

    static void Main()
    {
        Console.WriteLine(Domain("leo@shop.io") ?? "(none)");
        Console.WriteLine(Domain("not-an-email") ?? "(none)");
    }
}

Đầu ra:

shop.io
(none)

Split, một cách thay thế

Khi chuỗi là một danh sách các trường có dấu phân cách, Split đơn giản hơn một chuỗi lời gọi IndexOf và Substring, và không có phép tính chỉ số nào để làm sai:

using System;

class Program
{
    static void Main()
    {
        string row = "1042;Ana Silva;Porto;31";
        string[] fields = row.Split(';');
        Console.WriteLine(fields[1]);
        Console.WriteLine(fields[2]);

        string email = "maya.lopez@example.com";
        string user = email.Split('@')[0];
        Console.WriteLine(user);

        string path = "images/2026/09/beach.jpg";
        string[] parts = path.Split('/');
        Console.WriteLine(parts[parts.Length - 1]);   // last segment
    }
}

Đầu ra:

Ana Silva
Porto
maya.lopez
beach.jpg

Split cấp phát một mảng cộng thêm một chuỗi cho mỗi trường, nên với một lần cắt duy nhất trong vòng lặp chạy nhiều, IndexOf và Substring tốn ít hơn. Với mọi trường hợp khác, dễ đọc là ưu tiên. Các tùy chọn khác (nhiều dấu phân cách, bỏ phần tử rỗng, số phần tử tối đa) có trong các phương thức chuỗi. Với những mẫu như "các chữ số sau ID:", biểu thức chính quy thường là công cụ rõ ràng nhất.

Toán tử range (C# 8 trở đi)

C# 8 bổ sung cú pháp index và range, dùng được với chuỗi và mảng. ^n nghĩa là "thứ n tính từ cuối" và a..b là đoạn từ a đến b nhưng không bao gồm b, nên số thứ hai là chỉ số kết thúc, không phải độ dài:

// C# 8 and later
string sku = "SHOE-4271-BLK";

string first4 = sku[..4];      // "SHOE"        same as Substring(0, 4)
string middle = sku[5..9];     // "4271"        same as Substring(5, 4)
string last3  = sku[^3..];     // "BLK"         same as Substring(sku.Length - 3)
string noEnds = sku[1..^1];    // "HOE-4271-BL" drop first and last
char lastChar = sku[^1];       // 'K'

Trên chuỗi, range được biên dịch thành lời gọi Substring, nên nó cấp phát chuỗi mới và ném ArgumentOutOfRangeException trong cùng những trường hợp vượt giới hạn. Dùng cách nào là tùy phong cách; range dễ đọc hơn khi hai đầu được đo từ hai phía khác nhau ([1..^1]).

Chuỗi con không cần sao chép: Span

Mỗi lời gọi Substring cấp phát một chuỗi mới. Trong code phân tích cần hiệu năng cao (đọc tệp lớn, xử lý nhiều request), .NET Core 2.1 trở đi có ReadOnlySpan<char>, một khung nhìn vào một phần của chuỗi gốc mà không sao chép:

ReadOnlySpan<char> line = "2026-09-24,42.50,EUR".AsSpan();
ReadOnlySpan<char> amount = line.Slice(11, 5);          // "42.50", no allocation
decimal value = decimal.Parse(amount, provider: CultureInfo.InvariantCulture);

Span không thể lưu trong trường của các lớp thông thường hay dùng xuyên qua await, nên chúng thuộc về code đồng bộ, gọn và chạy nhiều. Với code ứng dụng thông thường, Substring là công cụ phù hợp.

Lỗi thường gặp

• Truyền chỉ số kết thúc làm độ dài. s.Substring(2, 5) nghĩa là năm ký tự từ chỉ số 2, không phải "từ chỉ số 2 đến 5". Để lấy văn bản từ chỉ số a đến trước chỉ số b, độ dài là b - a.
• Không kiểm tra IndexOf trả về -1. Kết quả là ngoại lệ, hoặc với + 1 thì vô tình lấy cả chuỗi.
• Cho rằng chuỗi ngắn vẫn đủ dài. Một cái tên, một mã hay một dòng đọc từ tệp có thể ngắn hơn bạn nghĩ. Hãy giới hạn bằng Math.Min hoặc kiểm tra Length.
• Bỏ quên kết quả. s.Substring(1); đứng riêng một dòng chẳng làm được gì hữu ích.