Substring ב-C#: חילוץ חלק ממחרוזת בבטחה

Substring מחזירה מחרוזת חדשה שמורכבת מחלק של מחרוזת קיימת. יש לה שתי העמסות:

• s.Substring(startIndex): מ-startIndex ועד הסוף.
• s.Substring(startIndex, length): length תווים, החל מ-startIndex.

האינדקסים מתחילים מ-0, והארגומנט השני הוא אורך, לא מיקום סיום. זה ההבדל מ-substring(start, end) של JavaScript ומ-substring(begin, end) של Java, והמקור להרבה באגים של סטייה באינדקס כשמעבירים קוד בין שפות.

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

פלט:

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

כמו כל מתודת מחרוזת, Substring לא משנה את המקור; היא מחזירה מחרוזת חדשה, אז השימו את התוצאה במשתנה.

ArgumentOutOfRangeException ואיך להימנע ממנה

Substring זורקת ArgumentOutOfRangeException כשהטווח המבוקש לא נכנס בתוך המחרוזת: startIndex שלילי, startIndex גדול מ-Length, length שלילי, או startIndex + length גדול מ-Length. אין קיצוץ שקט, בניגוד ל-slices של 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));
    }
}

פלט:

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

ההגנה המקובלת היא להגביל את האורך למה שנשאר מהמחרוזת עם 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)}]");
    }
}

פלט:

ffee
ea
[]
[]

קריאה ל-Substring על מחרוזת null זורקת NullReferenceException, לא ArgumentOutOfRangeException, ולכן פונקציית העזר בודקת קודם null.

n התווים הראשונים והאחרונים

לקיחת תחילית או סיומת היא השימוש הנפוץ ביותר ב-Substring. שתיהן זורקות כשהמחרוזת קצרה מ-n, ולכן קוד אמיתי בודק את האורך:

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

פלט:

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

כשמה שרוצים הוא להשמיט את החלק הראשון של המחרוזת, Substring(n) לבדה מספיקה: "#FF8800".Substring(1) הוא "FF8800". המתודה הקשורה Remove(start, count) עושה את ההפך מ-Substring: היא מחזירה את המחרוזת בלי הטווח הזה.

Substring עם IndexOf

רוב תתי-המחרוזות האמיתיות נמצאות בחיפוש, לא בספירה. IndexOf מחזירה את המיקום של תו או מחרוזת (או -1 אם הם לא שם), ו-LastIndexOf מחפשת מהסוף. שלבו אותן עם Substring כדי לחתוך טקסט סביב מפריד:

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

פלט:

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

החשבון פועל לפי כלל אחד: כדי לקחת את הטקסט שבין המיקומים a ו-b (בלי אף אחד מהם), ההתחלה היא a + 1 והאורך הוא b - a - 1.

הסכנה היא ש-IndexOf תחזיר -1. email.Substring(0, -1) זורקת, וגרוע מזה, email.Substring(-1 + 1) מחזירה בשקט את כל המחרוזת. בדקו תמיד:

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

פלט:

shop.io
(none)

Split כחלופה

כשמחרוזת היא רשימה של שדות עם מפריד, Split פשוטה יותר משרשרת של קריאות IndexOf ו-Substring, ואין בה חשבון אינדקסים שאפשר לטעות בו:

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

פלט:

Ana Silva
Porto
maya.lopez
beach.jpg

Split מקצה מערך ועוד מחרוזת אחת לכל שדה, כך שלחיתוך בודד בלולאה חמה IndexOf ו-Substring זולות יותר. לכל השאר, הקריאות מנצחת. אפשרויות נוספות (כמה מפרידים, הסרת רשומות ריקות, מספר מקסימלי) נמצאות ב-מתודות מחרוזת. לתבניות כמו "הספרות שאחרי ID:", ביטוי רגולרי הוא בדרך כלל הכלי הברור ביותר.

אופרטור הטווח (C# 8 ומעלה)

C# 8 הוסיפה תחביר של אינדקסים וטווחים, שעובד על מחרוזות ועל מערכים. ^n פירושו "n מהסוף", ו-a..b הוא הטווח מ-a ועד b בלי לכלול אותו, כך שהמספר השני הוא אינדקס סיום, לא אורך:

// 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'

על מחרוזת, טווח מתקמפל לקריאה ל-Substring, כך שהוא מקצה מחרוזת חדשה וזורק ArgumentOutOfRangeException באותם מקרים של חריגה מהגבולות. במה להשתמש זה עניין של סגנון; טווחים קריאים יותר כששני הקצוות נמדדים מצדדים שונים ([1..^1]).

תתי-מחרוזות בלי העתקה: Span

כל קריאה ל-Substring מקצה מחרוזת חדשה. בקוד פענוח שרגיש לביצועים (קריאת קבצים גדולים, טיפול בהרבה בקשות), .NET Core 2.1 ומעלה מציעות את ReadOnlySpan<char>, תצוגה של חלק מהמחרוזת המקורית בלי העתקה:

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

אי אפשר לשמור spans בשדות של מחלקות רגילות או להשתמש בהם לאורך await, כך שמקומם בקוד סינכרוני והדוק. לקוד אפליקציה רגיל, Substring היא הכלי הנכון.

טעויות נפוצות

• העברת אינדקס סיום בתור אורך. s.Substring(2, 5) פירושו חמישה תווים מאינדקס 2, לא "מאינדקס 2 עד 5". כדי לקחת את הטקסט מאינדקס a ועד אינדקס b בלי לכלול אותו, האורך הוא b - a.
• אי-בדיקה אם IndexOf החזירה -1. או חריגה, או, עם + 1, כל המחרוזת בטעות.
• הנחה שמחרוזות קצרות ארוכות מספיק. שם, קוד או שורה מקובץ יכולים להיות קצרים ממה שמצפים. הגבילו עם Math.Min או בדקו את Length.
• השלכת התוצאה. s.Substring(1); בשורה משלה לא עושה שום דבר מועיל.