String C#

String adalah urutan karakter. Di C#, string adalah kata kunci bahasa untuk jenis tersebut System.String . Setiap string harfiah yang Anda tulis menghasilkan instans System.String .

string Vs. String

Kata string kunci dan String nama jenis merujuk ke jenis yang sama. Keduanya dikompilasi menjadi bahasa perantara (IL) yang sama.

// The 'string' keyword is an alias for System.String. The two are identical.
string a = "hello";
String b = "hello";

Console.WriteLine(a == b);                // True
Console.WriteLine(typeof(string) == typeof(String)); // True

Gunakan kata kunci string dalam kode Anda. Ini konsisten dengan kata kunci tipe bawaan lainnya (int, bool, double), dan dapat berfungsi tanpa direktif using System;.

String tidak dapat diubah

Tidak dapat diubah berarti nilai tidak dapat diubah setelah dibuat. Setelah membuat string, Anda tidak dapat mengubah karakternya. Metode seperti ToUpperInvariant, , ReplaceSubstring, dan Trim mengembalikan string baru yang berisi nilai yang dimodifikasi. Instans asli tetap sama.

string greeting = "hello";

// ToUpper returns a *new* string. The original is unchanged.
string shouted = greeting.ToUpperInvariant();

Console.WriteLine(greeting);  // hello
Console.WriteLine(shouted);   // HELLO

Karena string tidak dapat diubah, Anda dapat membagikannya dengan aman di berbagai metode dan utas. Immutabilitas ini menjelaskan mengapa tipe string berperilaku seperti tipe nilai dalam penggunaan sehari-hari meskipun merupakan tipe referensi.

Saat Anda membangun string dari banyak potongan kecil dalam perulangan, gunakan StringBuilder untuk menambahkan di tempat dan menghasilkan satu string di akhir:

// For many sequential edits, StringBuilder avoids allocating a new string each time.
var builder = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    builder.Append("item ").Append(i).Append(';');
}
string result = builder.ToString();
Console.WriteLine(result);    // item 1;item 2;item 3;

Teks literal

C# menawarkan empat bentuk harfiah. Setiap formulir cocok dengan konten yang berbeda. Sebagai panduan singkat:

• Gunakan literal biasa untuk teks pendek dan sederhana yang memuat paling banyak beberapa sekuens escape.
• Gunakan literal verbatim saat backslash lebih banyak muncul dalam konten, seperti path Windows atau pola regex.
• Gunakan literal string raw untuk teks multi-baris atau teks yang diformat secara terstruktur, seperti JSON sebaris, SQL, XML, atau blok pesan berformat.
• $ Tambahkan awalan ke salah satu literal yang disebutkan di atas untuk mendapatkan string terinterpolasi saat Anda perlu menyematkan nilai.
• Tambahkan sufiks u8 ke literal untuk menghasilkan urutan byte UTF-8 (yaitu ReadOnlySpan<T> dari byte) untuk API yang berorientasi pada byte. Lihat literal string UTF-8 pada referensi bahasa untuk detail selengkapnya.

Literal biasa dan sekuens escape

Literal string biasa ditulis di antara tanda kutip ganda. Garis miring balik memulai sekuens escape:

// Common escape sequences inside a regular string literal.
string tabbed   = "name:\tAda";          // \t  tab
string twoLines = "line 1\nline 2";      // \n  newline
string quoted   = "She said \"hi\".";    // \"  literal quote
string path     = "C:\\src\\app";        // \\  literal backslash

Console.WriteLine(tabbed);
Console.WriteLine(twoLines);
Console.WriteLine(quoted);
Console.WriteLine(path);

Urutan escape umum termasuk \n (baris baru), \t (tab), \" (kutipan harfiah), \\ (garis miring terbalik harfiah), \0 (karakter null), dan escape Unicode (\uXXXX, \UXXXXXXXX).

Dimulai dari C# 13, \e mewakili karakter kontrol ESC (U+001B). Ini adalah byte awal untuk urutan escape terminal ANSI:

// Beginning in C# 13, \e represents the ESC control character (U+001B).
// It's used to start ANSI terminal escape sequences.
string esc = "\e[31mError\e[0m: file missing";

Console.WriteLine(esc);                  // ESC[31mError ESC[0m: file missing
Console.WriteLine((int)'\e');          // 27

Gunakan literal biasa jika teksnya pendek dan hanya berisi beberapa sekuens escape. Setelah jumlah karakter escape mulai melebihi jumlah karakter yang terlihat, gunakan literal verbatim atau literal mentah.

Literal verbatim

Harfiah verbatim diawali dengan @. Backslash ditafsirkan secara harfiah, yang berguna untuk path Windows dan pola ekspresi reguler:

// A verbatim string literal (@) treats backslashes literally.
// Useful for Windows paths and regular expressions.
string winPath = @"C:\src\app\readme.md";
string pattern = @"\d{3}-\d{4}";

Console.WriteLine(winPath);
Console.WriteLine(pattern);

Untuk menyematkan kutipan harfiah di dalam string verbatim, gandakan: @"She said ""hi"".". String verbatim juga dapat mencakup beberapa baris fisik.

Literal verbatim adalah pilihan yang tepat ketika backslash merupakan bagian dari konten, tetapi Anda tidak memiliki banyak tanda kutip yang disisipkan. Untuk teks atau konten multibaris dengan tanda kutip, literal string mentah biasanya lebih jelas.

Literal string mentah

Untuk literal apa pun yang berisi tanda kutip, garis miring terbalik, atau beberapa baris, sebaiknya gunakan literal string mentah. Mereka menghilangkan kebisingan escape sepenuhnya, yang membuatnya paling cocok untuk JSON sebaris, SQL, XML, pola regex, dan blok teks yang diformat di mana sumber akan terlihat seperti output:

// Raw string literals use three or more quotes and need no escaping.
// The source looks like the output, which is ideal for inline JSON, SQL, XML, and the like.
string json = """
    {
        "name": "Ada",
        "roles": ["admin", "editor"]
    }
    """;

string sql = """
    SELECT Id, Name
    FROM   Users
    WHERE  Name = 'O''Brien'
    """;

Console.WriteLine(json);
Console.WriteLine(sql);

Literal string mentah hampir sepenuhnya menghilangkan urutan escape dan memungkinkan format serta tanda kutip apa pun yang Anda perlukan. Lihat Literal string mentah untuk aturan lengkap.

String yang diinterpolasi

Prefiks $ mengubah literal menjadi string interpolasi. Ekspresi dalam {} lubang dievaluasi dan hasilnya dimasukkan, dan Anda dapat menerapkan penentu format standar dan penyelarasan di dalam lubang. Interpolasi juga dapat dikombinasikan dengan bentuk literal lainnya—gunakan $@"..." untuk menginterpolasi literal verbatim, atau $"""...""" untuk menginterpolasi literal string mentah guna menghasilkan output dengan pemformatan kaya:

// The $ prefix evaluates expressions inside { } and inserts their values.
string name = "Ada";
int score = 92;

string greeting = $"Hello, {name}! Your score is {score}.";
// Format specifiers and alignment work inside the holes.
string formatted = $"pi = {Math.PI:F3}, padded = |{name,10}|";

// Combine $ and """ for richly formatted multiline output.
string report = $"""
    Report for {name}
    -----------------
    Score : {score}
    Grade : {(score >= 90 ? "A" : "B")}
    """;

Console.WriteLine(greeting);
Console.WriteLine(formatted);
Console.WriteLine(report);

Interpolasi adalah cara yang direkomendasikan untuk menyusun string dari nilai dalam kode sehari-hari.

Pengindeksan dan char

string adalah urutan unit kode UTF-16. Pengindeks mengembalikan satu System.Char, yang mewakili satu unit kode UTF-16, belum tentu titik kode Unicode lengkap. Length mengembalikan jumlah unit kode.

// A string is a sequence of UTF-16 code units. s[i] returns one char.
string word = "café";

Console.WriteLine(word.Length);          // 4
Console.WriteLine(word[0]);              // c

foreach (char c in word)
{
    Console.Write($"{c} ");              // c a f é
}
Console.WriteLine();

Untuk teks yang mungkin berisi emoji atau karakter di luar Basic Multilingual Plane, lakukan iterasi per rune menggunakan Rune, atau per klaster grafem menggunakan StringInfo. Iterasi biasa char berfungsi untuk sebagian besar teks Barat dan konten dominan ASCII.

Kesetaraan string

Kesetaraan pada string membandingkan urutan karakter, bukan referensi:

// String equality compares character sequences, not references.
string left  = "hello";
string right = string.Concat("hel", "lo");

Console.WriteLine(left == right);                                      // True
Console.WriteLine(left.Equals(right, StringComparison.Ordinal));       // True

Untuk perbandingan yang perlu memperhatikan setelan lokal atau huruf besar/kecil, berikan nilai StringComparison secara eksplisit. Gunakan StringComparison.Ordinal untuk nilai protokol, pengidentifikasi, dan teks non-linguistik lainnya.

Operasi string umum

Gunakan tabel berikut sebagai panduan cepat untuk operasi string sehari-hari di C#:

Permukaan API penuh — setiap kelebihan beban, setiap metode — didokumenkan dalam String referensi.

Baca juga

• Literal string mentah
• nameof operator
• String
• StringBuilder
• Char
• ReadOnlySpan<T>