מתודות מחרוזת ב-C#: Split, Replace, Contains, IndexOf, Trim, Join ועוד

ל-System.String יש עשרות מתודות. העמוד הזה מכסה את אלה שעושות את רוב העבודה בקוד אמיתי, עם האפשרויות והמלכודות שחשובות. כלל אחד חל על כולן: מחרוזות הן בלתי ניתנות לשינוי, ולכן כל מתודה מחזירה מחרוזת חדשה (או ערך) ומשאירה את המקור ללא שינוי. s.Trim(); בשורה משלה לא עושה כלום; כתבו s = s.Trim();.

Split

Split מפצלת מחרוזת ל-string[] בכל מפריד:

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

פלט:

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

שימו לב ל-" blue": Split חותכת בדיוק במפריד ושומרת רווחים. שתי אפשרויות מטפלות בניקויים הנפוצים:

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

פלט:

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

RemoveEmptyEntries משמיטה חלקים באורך אפס, אבל לא חלקים שמכילים רק רווחים (" " שרד בדוגמה). ב-.NET 5 נוספה StringSplitOptions.TrimEntries, ואפשר לשלב בין השתיים: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) נותנת את התוצאה הנקייה בקריאה אחת. העברת null כמפריד מפצלת בכל רווח לבן, וזו הדרך המקובלת לפצל טקסט למילים.

פיצול לפי char בודד (Split(',')) לא דורש מערך. ההעמסות שמקבלות char יחד עם אפשרויות, או string בודד, קיימות מ-.NET Core 2.0 ואילך; הצורות עם מערך שבדוגמאות עובדות בכל מקום, כולל .NET Framework ו-Unity.

Replace

Replace מחליפה כל מופע של תו או של תת-מחרוזת:

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

פלט:

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

ההעמסה עם ארגומנט StringComparison זמינה ב-.NET Core 2.0 ומעלה. ב-.NET Framework מבצעים החלפה בלי תלות באותיות גדולות וקטנות עם Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). החלפה ב-"" היא הדרך להסיר תווים, ושרשור של כמה קריאות Replace מתאים בהחלט לקומץ החלפות.

Contains, IndexOf, StartsWith ו-EndsWith

המתודות האלה מחפשות. Contains עונה כן או לא; IndexOf ו-LastIndexOf מחזירות מיקום, או -1 כשאין התאמה; StartsWith ו-EndsWith בודקות את הקצוות.

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

פלט:

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

כולן תלויות באותיות גדולות וקטנות כברירת מחדל. Contains(string, StringComparison) קיימת ב-.NET Core 2.1 ומעלה; הצורה IndexOf(...) >= 0 עובדת בכל גרסה, ולכן רואים אותה בקוד ישן. IndexOfAny(new[] { ',', ';' }) מוצאת את הראשון מבין כמה תווים.

הערה על תרבויות: בלי StringComparison, המתודות StartsWith, EndsWith, IndexOf(string) ו-CompareTo משתמשות בכללים שתלויים בתרבות, בעוד ש-Contains, Replace ו-IndexOf(char) משוות באופן סידורי (ordinal). העברה מפורשת של StringComparison.Ordinal או OrdinalIgnoreCase מסירה את העמימות, וכלי ניתוח קוד ממליצים על כך.

Trim, TrimStart ו-TrimEnd

Trim מסירה רווח לבן (רווחים, טאבים, שורות חדשות) משני הקצוות. TrimStart ו-TrimEnd מסירות מקצה אחד. כשמעבירים להן תווים, הן מסירות אותם במקום:

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

פלט:

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

Trim נוגעת רק בקצוות; רווחים בתוך המחרוזת נשמרים. TrimStart('0') על "000" מחזירה מחרוזת ריקה, ולכן המירו מחרוזות של מספרים עם int.Parse במקום להסיר אפסים ידנית.

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

פלט:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper ו-ToLower פועלות לפי התרבות הנוכחית, ולכן בטורקית "i".ToUpper() היא İ גדולה עם נקודה, ולא I. למזהים, מפתחות ושמות קבצים השתמשו ב-ToUpperInvariant וב-ToLowerInvariant. להשוואה, השתמשו ב-StringComparison במקום להמיר אותיות בכלל (ראו strings). כדי להפוך את האות הראשונה של כל מילה לגדולה קיימת CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), אבל היא לא נוגעת במילים שכבר כתובות כולן באותיות גדולות.

PadLeft ו-PadRight

ריפוד מוסיף תווים עד שהמחרוזת מגיעה לרוחב כולל. זה שימושי לפלט ברוחב קבוע ולריפוד קודים באפסים:

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

פלט:

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

יישור באינטרפולציה ({name,-10}) עושה את אותה עבודה בתוך השורה.

Join ו-Concat

string.Join שמה מפריד בין האיברים של כל אוסף. string.Concat מחברת בלי מפריד:

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

פלט:

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

Join היא הדרך הנכונה לבנות רשימה עם מפרידים: אין מפריד מיותר בסוף שצריך להסיר, והיא בונה את התוצאה במעבר אחד. היא קוראת ל-ToString() על כל איבר, ולכן עובדת גם עם מספרים ואובייקטים.

Reverse, Insert ו-Remove

אין מתודה string.Reverse שמחזירה מחרוזת. שתי הגישות המקובלות:

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

פלט:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() לבדה מחזירה IEnumerable<char>, לא מחרוזת; הדפסה שלה מציגה שם של טיפוס. שתי השיטות הופכות יחידות קוד של UTF-16, וזה שובר תווים שמורכבים משתי יחידות (רוב האמוג'י) ואותיות עם סימני הטעמה משולבים.

טבלת סיכום