String di C#: Length, Compare, Escape Character, Verbatim dan Multiline String

string di C# adalah urutan karakter UTF-16 (nilai char). Ia adalah reference type, tetapi berperilaku seperti nilai dalam hal-hal yang penting: ia immutable, dan == membandingkan teksnya, bukan identitas object-nya. string adalah kata kunci C# untuk tipe .NET System.String; keduanya bisa dipakai bergantian.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Output:

Porto
5
0
*****
hi
Porto has 5 letters

String bersifat immutable

Tidak ada method yang mengubah string secara langsung. ToUpper, Replace, Trim, dan semua method lainnya mengembalikan string baru dan membiarkan string aslinya tidak tersentuh. Lupa memakai nilai kembaliannya adalah bug string yang sangat umum:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Output:

[  maya  ]
[MAYA]
tea
tea and cake

Sifat immutable membuat string aman dipakai bersama di banyak thread dan dipakai sebagai key dictionary. Konsekuensinya, membangun string sepotong demi sepotong di dalam perulangan akan membuat string baru di setiap langkah; untuk itu, pakai StringBuilder.

Length dan indeks

Length adalah property (tanpa tanda kurung). Indexer s[i] mengembalikan char di posisi i, dihitung mulai dari 0, dan bersifat read-only:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Output:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 dan sesudahnya juga menerima indeks dari ujung: code[^1] adalah karakter terakhir, sama dengan code[code.Length - 1]. Untuk mengambil beberapa karakter sekaligus, lihat substring.

Length menghitung code unit UTF-16, bukan karakter seperti yang dilihat pembaca. Kebanyakan huruf di kebanyakan bahasa hanya satu unit, tetapi emoji dan beberapa aksara langka memakai dua (sebuah surrogate pair), jadi "👍".Length bernilai 2.

Membandingkan string

== dan != membandingkan karakternya dengan peka huruf besar kecil. Untuk perbandingan lain, berikan nilai StringComparison yang menyatakan cara membandingkannya:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Output:

False
False
True
True
apple first
True
False
False
True

Perbandingan mana yang dipakai:

• Ordinal membandingkan kode numerik karakternya. Cepat, bisa diprediksi, dan sama di setiap komputer. Pakai untuk identifier, nama file, key, nilai protokol, dan apa pun yang tidak ditampilkan ke orang.
• OrdinalIgnoreCase sama, tetapi mengabaikan huruf besar kecil. Pilihan yang tepat untuk pengecekan yang tidak peka huruf besar kecil seperti ekstensi file atau header HTTP.
• CurrentCulture (dan CurrentCultureIgnoreCase) mengikuti aturan bahasa pengguna, jadi mengurutkan kata seperti kamus dalam bahasa itu. Pakai untuk mengurutkan daftar yang ditampilkan ke pengguna.
• InvariantCulture memakai aturan yang peka culture, tetapi tidak bergantung pada pengaturan bahasa pengguna. Hasilnya tetap bergantung pada library globalisasi: .NET modern memakai ICU, .NET Framework memakai NLS dari Windows, dan keduanya bisa mengurutkan beberapa string secara berbeda.

string.Compare(a, b) dan a.CompareTo(b) tanpa StringComparison memakai culture yang sedang aktif, sehingga hasilnya bisa berbeda di setiap komputer. Hindari membandingkan dengan a.ToLower() == b.ToLower(): cara ini membuat dua string baru, dan memberi jawaban yang salah di beberapa culture (huruf i bertitik dan tanpa titik di bahasa Turki adalah contoh klasiknya).

Memanggil a.Equals(b) saat a bernilai null melempar NullReferenceException, sedangkan a == b dan string.Equals(a, b) yang static menangani null dengan aman.

Escape character

Di dalam string literal biasa, backslash memulai sebuah escape sequence:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Output:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

Sequence yang tidak dikenal seperti "\d" adalah error kompilasi (CS1009, escape sequence tidak dikenal), dan itulah yang terjadi saat path Windows atau regular expression ditulis sebagai string biasa.

String verbatim dan string multiline

Memberi awalan @ pada literal membuatnya verbatim: backslash menjadi karakter literal, dan string-nya boleh terdiri dari beberapa baris. Satu-satunya escape yang tersisa adalah "", yang menghasilkan satu tanda kutip ganda.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Output:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

String multiline verbatim mencakup semua yang ada di antara tanda kutipnya, termasuk indentasi baris lanjutannya, itulah sebabnya string seperti ini biasanya ditulis rapat ke margin seperti di atas. Baris baru di dalamnya adalah baris baru dari file source, jadi file yang disimpan dengan akhir baris Windows menghasilkan \r\n.

C# 11 menambahkan raw string literal, yang menyelesaikan kedua masalah itu. Literal ini dimulai dan diakhiri dengan tiga tanda kutip ganda atau lebih, sama sekali tidak butuh escape, dan membuang indentasi sesuai indentasi tanda kutip penutupnya:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

Jika isinya sendiri mengandung """, mulai dan akhiri dengan empat tanda kutip. Raw literal juga bisa digabung dengan interpolation ($"""..."""); lihat string interpolation.

Null, kosong, dan whitespace

Variabel string bisa bernilai null (sama sekali tidak ada string), kosong ("", panjangnya 0), atau hanya berisi whitespace. Dua helper static memeriksa kasus-kasus ini tanpa risiko NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Output:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Untuk memvalidasi input pengguna, string.IsNullOrWhiteSpace hampir selalu menjadi yang kamu butuhkan. string.Empty dan "" adalah nilai yang sama; memilih salah satunya hanya soal gaya.

Perulangan pada setiap karakter

String bisa dienumerasi, jadi foreach mengunjungi setiap char. Tipe char punya method static untuk mengelompokkan karakter:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Output:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Menggabungkan string

+ menggabungkan string, dan bisa dipakai dengan tipe apa pun di sisi lainnya (ia memanggil ToString()). Untuk menggabungkan banyak nilai, lebih baik pakai interpolation atau string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Output:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

Dua baris terakhir menunjukkan jebakan urutan operasi: + dievaluasi dari kiri ke kanan, jadi begitu sisi kirinya berupa string, setiap + berikutnya adalah penggabungan. Beri tanda kurung pada operasi aritmetika di dalam penggabungan.