Bagikan melalui

String dan literal string

  • Artikel

String adalah objek jenis String yang nilainya berupa teks. Secara internal, teks disimpan sebagai kumpulan objek Char baca-saja yang berurutan. Tidak ada karakter null-terminating di akhir string C#; oleh karena itu string C# dapat berisi sejumlah karakter null yang disematkan ('\0'). Properti Length dari string mewakili jumlah objek Char yang dimuatnya, bukan jumlah karakter Unicode. Untuk mengakses titik kode Unicode individual dalam string, gunakan objek StringInfo.

string vs. System.String

Dalam C#, kata kunci string adalah alias untuk String. Oleh karena itu, String dan string setara, terlepas dari saran untuk menggunakan alias string yang disediakan karena berfungsi bahkan tanpa using System;. Kelas String ini menyediakan banyak metode untuk membuat, memanipulasi, dan membandingkan string dengan aman. Selain itu, bahasa C# memenuhi beberapa operator untuk menyederhanakan operasi string umum. Untuk informasi selengkapnya tentang kata kunci, lihat string. Untuk informasi selengkapnya tentang jenis dan metodenya, lihat String.

Mendeklarasikan dan menginisialisasi string

Anda dapat mendeklarasikan dan menginisialisasi string dengan berbagai cara, seperti yang ditunjukkan dalam contoh berikut:

// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

// Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Anda tidak menggunakan operator baru untuk membuat objek string kecuali saat menginisialisasi string dengan array karakter.

Menginisialisasi string dengan nilai konstanta Empty untuk membuat objek Stringbaru yang panjang stringnya nol. Representasi literal string dari string panjang nol adalah "". Dengan menginisialisasi string dengan nilai Empty alih-alih null, Anda dapat mengurangi kemungkinan terjadinya NullReferenceException. Gunakan metode statis IsNullOrEmpty(String) untuk memverifikasi nilai string sebelum Anda mencoba mengaksesnya.

Kekekalan string

Objek string tidak dapat diubah: objek string tidak dapat diubah setelah dibuat. Semua metode String dan operator C# yang tampaknya mengubah string sebenarnya mengembalikan hasilnya dalam objek string baru. Dalam contoh berikut, ketika konten s1 dan s2 digabungkan untuk membentuk satu string, dua string asli tidak dimodifikasi. Operator += membuat string baru yang berisi konten gabungan. Objek baru tersebut ditetapkan ke variabel s1, dan objek asli yang ditetapkan ke s1 dilepaskan untuk pengumpulan sampah karena tidak ada variabel lain yang menyimpan referensi pada objek tersebut.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Karena string "modifikasi" sebenarnya adalah pembuatan string baru, Anda harus berhati-hati saat membuat referensi ke string. Jika Anda membuat referensi ke string, lalu "memodifikasi" string aslinya, referensi akan tetap menunjuk ke objek asli alih-alih objek baru yang dibuat saat string itu dimodifikasi. Kode berikut menggambarkan perilaku ini:

string str1 = "Hello ";
string str2 = str1;
str1 += "World";

System.Console.WriteLine(str2);
//Output: Hello

Untuk informasi selengkapnya tentang cara membuat string baru yang didasarkan pada modifikasi seperti operasi pencarian dan penggantian pada string asli, lihat Cara memodifikasi konten string.

Literal string kutipan

Literal string yang dikutip adalah awal dan akhir dengan satu karakter kutipan ganda (") pada baris yang sama. Literal string yang dikutip paling cocok untuk string yang pas pada satu baris dan tidak menyertakan urutan escape apa pun. Literal string yang dikutip harus menyematkan karakter escape, seperti yang ditunjukkan dalam contoh berikut:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
    Row 1
    Row 2
    Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Harfiah string verbatim

Literal string verbatim lebih nyaman untuk string multibaris, string yang berisi karakter garis miring terbalik, atau tanda kutip ganda yang disematkan. String Verbatim mempertahankan karakter baris baru sebagai bagian dari teks string. Gunakan tanda kutip ganda untuk menyematkan tanda kutip di dalam string verbatim. Contoh berikut menunjukkan beberapa kegunaan umum string verbatim:

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Literal string mentah

Dimulai dengan C# 11, Anda dapat menggunakan literal string mentah untuk membuat string yang multibaris dengan lebih mudah, atau menggunakan karakter apa pun yang memerlukan urutan escape. Literal string mentah menghapus kebutuhan untuk menggunakan urutan escape. Anda dapat menulis string, termasuk pemformatan spasi kosong, bagaimana Anda ingin string muncul dalam output. literal string mentah:

  • Dimulai dan diakhir dengan urutan setidaknya tiga karakter kutipan ganda ("""). Anda bisa menggunakan lebih dari tiga karakter berturut-turt untuk memulai dan mengakhiri urutan untuk mendukung literal string yang berisi tiga (atau lebih) karakter kutipan berulang.
  • Literal string mentah baris tunggal memerlukan karakter kutipan pembuka dan penutup pada baris yang sama.
  • Literal string mentah multibaris memerlukan karakter kutipan pembuka dan penutup pada baris mereka sendiri.
  • Dalam literal string mentah multibaris, spasi kosong apa pun di sebelah kiri tanda kutip penutup dihapus.

Contoh berikut menunjukkan aturan ini:

string singleLine = """Friends say "hello" as they pass by.""";
string multiLine = """
    "Hello World!" is typically the first program someone writes.
    """;
string embeddedXML = """
       <element attr = "content">
           <body style="normal">
               Here is the main text
           </body>
           <footer>
               Excerpts from "An amazing story"
           </footer>
       </element >
       """;
// The line "<element attr = "content">" starts in the first column.
// All whitespace left of that column is removed from the string.

string rawStringLiteralDelimiter = """"
    Raw string literals are delimited 
    by a string of at least three double quotes,
    like this: """
    """";

Contoh berikut menunjukkan kesalahan kompiler yang dilaporkan berdasarkan aturan ini:

// CS8997: Unterminated raw string literal.
var multiLineStart = """This
    is the beginning of a string 
    """;

// CS9000: Raw string literal delimiter must be on its own line.
var multiLineEnd = """
    This is the beginning of a string """;

// CS8999: Line does not start with the same whitespace as the closing line
// of the raw string literal
var noOutdenting = """
    A line of text.
Trying to outdent the second line.
    """;

Dua contoh pertama tidak valid karena literal string mentah multibaris memerlukan urutan kutipan pembukaan dan penutupan pada barisnya sendiri. Contoh ketiga tidak valid karena teks di-outden dari urutan kutipan penutup.

Anda harus mempertimbangkan literal string mentah saat membuat teks yang menyertakan karakter yang memerlukan urutan escape saat menggunakan literal string yang dikutip atau literal string verbatim. Literal string mentah akan lebih mudah dibaca oleh Anda dan orang lain karena akan lebih menyerupai teks output. Misalnya, pertimbangkan kode berikut yang menyertakan string JSON yang diformat:

string jsonString = """
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
            },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}
""";

Bandingkan teks tersebut dengan teks yang setara dalam sampel kami pada serialisasi JSON, yang tidak memanfaatkan fitur baru ini.

Urutan escape string

Urutan escape Nama karakter Pengkodean unicode
\' Kutipan tunggal 0x0027
\" Kutipan ganda 0x0022
\\ Garis miring terbalik 0x005C
\0 Null 0x0000
\a Peringatan 0x0007
\b Backspace 0x0008
\f Umpan formulir 0x000C
\n Baris baru 0x000A
\r Carriage return 0x000D
\t Tab horizontal 0x0009
\v Tab vertikal 0x000B
\u Urutan escape Unicode (UTF-16) \uHHHH (rentang: 0000 - FFFF; contoh: \u00E7 = "ç")
\U Urutan escape Unicode (UTF-32) \U00HHHHHH (rentang: 000000 - 10FFFF; contoh: \U0001F47D = "👽")
\x Urutan escape Unicode mirip dengan "\u" kecuali dengan panjang variabel \xH[H][H][H] (rentang: 0 - FFFF; contoh: \x00E7 atau \x0E7 atau \xE7= "ç")

Peringatan

Saat menggunakan urutan escape \x dan menentukan kurang dari 4 digit hex, jika karakter yang langsung mengikuti urutan escape adalah digit heksa yang valid (yaitu 0-9, A-F, dan a-f), mereka akan ditafsirkan sebagai bagian dari urutan escape. Misalnya, \xA1 menghasilkan "¡", yang merupakan titik kode U+00A1. Namun, jika karakter berikutnya adalah "A" atau "a", maka urutan escape justru akan ditafsirkan sebagai menjadi \xA1A dan menghasilkan "ਚ", yang merupakan titik kode U+0A1A. Dalam kasus seperti itu, menentukan semua 4 digit heksa (misalnya \x00A1 ) akan mencegah kemungkinan salah tafsir.

Catatan

Pada waktu kompilasi, string verbatim dikonversi menjadi string biasa dengan semua urutan escape yang sama. Oleh karena itu, jika Anda melihat string verbatim di jendela pengawasan debugger, Anda akan melihat karakter escape yang ditambahkan oleh kompiler, bukan versi verbatim dari kode sumber Anda. Misalnya, string verbatim @"C:\files.txt" akan muncul di jendela pengawasan sebagai "C:\\files.txt".

String format

String format adalah string yang kontennya ditentukan secara dinamis pada run time. String format dibuat dengan menyematkan ekspresi terinterpolasi atau tempat penampung di dalam kurung kurawal dalam string. Semua yang ada di dalam kurung kurawal ({...}) akan diselesaikan ke nilai dan output sebagai string yang diformat pada run time. Ada dua metode untuk membuat string format: interpolasi string dan pemformatan komposit.

Interpolasi string

Tersedia dalam C# 6.0 dan yang lebih baru, string terinterpolasi diidentifikasi oleh karakter khusus $ dan menyertakan ekspresi terinterpolasi dalam kurung kurawal. Jika Anda baru mengenal interpolasi string, lihat Interpolasi string - tutorial interaktif untuk gambaran umum cepat.

Gunakan interpolasi string untuk meningkatkan keterbacaan dan pemeliharaan kode Anda. Interpolasi string mencapai hasil yang sama dengan metode String.Format, tetapi meningkatkan kemudahan penggunaan dan kejelasan sebaris.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today.

Mulai dari C# 10, Anda dapat menggunakan interpolasi string untuk menginisialisasi string konstan ketika semua ekspresi yang digunakan untuk tempat penampung juga merupakan string konstan.

Mulai dari C# 11, Anda dapat menggabungkan literal string mentah dengan interpolasi string. Anda memulai dan mengakhiri string format dengan tiga tanda kutip ganda berturut-turut atau lebih. Jika string output Anda harus berisi karakter { atau }, Anda dapat menggunakan karakter tambahan $ untuk menentukan berapa banyak karakter { dan } memulai dan mengakhiri interpolasi. Rangkaian apa pun dari karakter { atau } yang lebih sedikit disertakan dalam output. Contoh berikut menunjukkan bagaimana Anda dapat menggunakan fitur tersebut untuk menampilkan jarak titik dari asal, dan menempatkan titik tersebut di dalam kurung kurawal:

int X = 2;
int Y = 3;

var pointMessage = $$"""The point {{{X}}, {{Y}}} is {{Math.Sqrt(X * X + Y * Y)}} from the origin.""";

Console.WriteLine(pointMessage);
// Output:
// The point {2, 3} is 3.605551275463989 from the origin.

Pemformatan komposit

String.Format menggunakan tempat penampung dalam kurung kurawal untuk membuat string format. Contoh ini menghasilkan output yang sama dengan metode interpolasi string yang digunakan di atas.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

Untuk informasi selengkapnya tentang pemformatan jenis .NET, lihat Tipe Pemformatan di .NET.

Substring

Substring adalah rangkaian karakter apa pun yang terkandung dalam string. Gunakan metode Substring untuk membuat string baru dari bagian string asli. Anda dapat mencari satu atau beberapa kemunculan substring dengan menggunakan metode IndexOf. Gunakan metode Replace untuk mengganti semua kemunculan substring tertentu dengan string baru. Seperti metode Substring, Replace benar-benar mengembalikan string baru dan tidak mengubah string aslinya. Untuk informasi selengkapnya, lihat Cara mencari string dan Cara memodifikasi konten string.

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Mengakses karakter individual

Anda dapat menggunakan notasi array dengan nilai indeks untuk memperoleh akses baca-saja ke karakter individual, seperti dalam contoh berikut:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Jika metode String tidak menyediakan fungsionalitas sehingga Anda harus mengubah karakter individual dalam string, Anda dapat menggunakan objek StringBuilder untuk memodifikasi karakter individual "di tempat", lalu membuat string baru untuk menyimpan hasilnya dengan menggunakan metode StringBuilder. Dalam contoh berikut, asumsikan bahwa Anda harus memodifikasi string asli dengan cara tertentu lalu menyimpan hasilnya untuk digunakan di masa mendatang:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?

String null dan string kosong

String kosong adalah instans objek System.String yang berisi nol karakter. String kosong sering digunakan dalam berbagai skenario pemrograman untuk mewakili bidang teks kosong. Anda dapat memanggil metode pada string kosong karena metode adalah objek System.String yang valid. String kosong diinisialisasi sebagai berikut:

string s = String.Empty;

Sebaliknya, string null tidak merujuk ke instans dari objek System.String dan upaya apa pun untuk memanggil metode pada string null menyebabkan NullReferenceException. Namun, Anda dapat menggunakan string null dalam operasi perangkaian dan perbandingan dengan string lain. Contoh berikut mengilustrasikan beberapa kasus di mana referensi ke string null menyebabkan dan tidak menyebabkan pengecualian dilemparkan:

string str = "hello";
string nullStr = null;
string emptyStr = String.Empty;

string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);
// Output of the following line: False
Console.WriteLine(b);

// The following line creates a new empty string.
string newStr = emptyStr + nullStr;

// Null strings and empty strings behave differently. The following
// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);

// The null character can be displayed and counted, like other chars.
string s1 = "\x0" + "abc";
string s2 = "abc" + "\x0";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);

Menggunakan stringBuilder untuk pembuatan string cepat

Operasi string di .NET sangat dioptimalkan dan dalam banyak kasus tidak berdampak signifikan pada performa. Namun, dalam beberapa skenario seperti perulangan ketat yang mengeksekusi ratusan atau ribuan kali, operasi string dapat memengaruhi performa. Kelas StringBuilder membuat buffer string yang menawarkan performa lebih baik jika program Anda melakukan banyak manipulasi string. String StringBuilder juga memungkinkan Anda menetapkan ulang karakter individual, sesuatu yang tidak didukung oleh jenis data string bawaan. Kode ini, misalnya, mengubah konten string tanpa membuat string baru:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
//Outputs Cat: the ideal pet

Dalam contoh ini, objek StringBuilder digunakan untuk membuat string dari sekumpulan jenis numerik:

var sb = new StringBuilder();

// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
{
    sb.Append(i.ToString());
}
Console.WriteLine(sb);  // displays 0123456789

// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];

Console.WriteLine(sb);  // displays 9123456789

String, metode ekstensi, dan LINQ

Karena jenis String menerapkan IEnumerable<T>, Anda dapat menggunakan metode ekstensi yang ditentukan di kelas Enumerable pada string. Untuk menghindari kekacauan visual, metode ini dikecualikan dari IntelliSense untuk jenis String tersebut, tetapi tetap tersedia. Anda juga bisa menggunakan ekspresi kueri LINQ pada string. Untuk informasi selengkapnya, lihat LINQ dan String.