Bagikan melalui

Jenis bawaan dan literal

Petunjuk / Saran

Baru mengembangkan perangkat lunak? Mulai dengan tutorial Memulai terlebih dahulu. Mereka memperkenalkan jenis saat Anda menulis program pertama Anda.

Berpengalaman dalam bahasa lain? Tipe bawaan C# berhubungan erat dengan tipe dalam Java, C++, dan bahasa lainnya. Lewati sintaks harfiah dan ketik bagian inferensi untuk detail C#-spesifik.

C# menyediakan sekumpulan jenis bawaan yang dapat Anda gunakan dalam program apa pun tanpa referensi tambahan. Jenis ini mencakup data paling umum yang Anda kerjakan: angka, nilai true/false, karakter individual, dan teks. Untuk tabel referensi lengkap pemetaan kata kunci C# ke jenis .NET, lihat Jenis bawaan (referensi C#).

Jenis numerik

C# memiliki jenis bawaan untuk bilangan bulat, angka floating-point, dan angka desimal. Jenis yang paling umum digunakan adalah int, , doubledan decimal:

int population = 67_000_000;
long distance = 384_400_000L;
short temperature = -40;
byte red = 255;

double pi = 3.141592653589793;
float gravity = 9.81f;
decimal price = 19.99m;

Setiap jenis numerik memiliki ukuran dan rentang tetap. int menyimpan bilangan bulat 32-bit (kira-kira ±2,1 miliar), long menyimpan bilangan bulat 64-bit, dan shortbyte menyimpan nilai yang lebih kecil. Untuk daftar lengkap ukuran dan rentang, lihat Jenis Numerik Integral dan Jenis Numerik Titik Mengambang.

Gunakan double untuk matematika floating-point umum, float ketika memori dibatasi, dan decimal ketika Anda membutuhkan presisi desimal yang tepat (seperti perhitungan keuangan). Tambahkan akhiran f untuk float literal dan m untuk decimal literal. Tanpa akhiran, pengkompilasi memperlakukan angka dengan titik desimal sebagai double.

Jenis yang tidak ditandatangani

Setiap jenis bilangan bulat yang ditandatangani memiliki mitra yang tidak ditandatangani yang hanya menyimpan nilai non-negatif dengan dua kali rentang positif:

uint fileSize = 4_294_967_295;
ulong totalBytes = 18_446_744_073_709_551_615;
ushort port = 443;

Anda mungkin menggunakan jenis yang tidak ditandatangani saat nilai negatif tidak valid untuk data, seperti ukuran file atau port jaringan. Dalam praktiknya, banyak aplikasi menggunakan int atau long bahkan untuk nilai positif-saja karena jenis yang ditandatangani adalah default di seluruh API .NET.

Bilangan bulat berukuran asli

Jenis nint dan nuint mewakili bilangan bulat yang ukurannya cocok dengan ukuran pointer asli platform: 32 bit pada platform 32-bit, 64 bit pada platform 64-bit:

nint bufferSize = 1024;
nuint elementCount = 256;

Anda tidak mungkin membutuhkan nint atau nuint dalam kode sehari-hari. Mereka ada untuk skenario interop dan operasi memori tingkat rendah di mana pencocokan ukuran pointer platform penting. Tetap gunakan int atau long kecuali Anda memiliki alasan khusus untuk menggunakan tipe dengan ukuran asli. Untuk informasi lebih lanjut, lihat nint dan nuint.

bool, char, dan string

Di luar angka, C# menyediakan tiga jenis bawaan lain yang sering digunakan:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Menyimpan true atau false. Gunakan dalam kondisi, perulangan, dan ekspresi logis.
  • char — Menyimpan satu karakter Unicode (unit kode UTF-16), diapit dalam tanda kutip tunggal.
  • string — Menyimpan urutan karakter, diapit tanda kutip ganda. String tidak dapat diubah. Setelah membuat string, Anda tidak dapat mengubah kontennya. Operasi yang tampaknya mengubah string sebenarnya menciptakan string yang baru.

String adalah salah satu jenis yang paling banyak digunakan di C#. Untuk cakupan mendalam operasi string, termasuk interpolasi, literal string mentah, pencarian, pemisahan, dan perbandingan, lihat bagian String .

Sintaksis harfiah

Literal adalah nilai yang Anda tulis langsung dalam kode Anda. Pengkompilasi menetapkan setiap jenis harfiah berdasarkan formatnya dan akhiran apa pun yang Anda berikan. C# mendukung jenis literal berikut:

  • Literal bilangan bulat — Desimal (42), heksadesimal (0x2A), dan biner (0b_0010_1010).
  • Floating-point literal — double secara bawaan (3.14), float dengan akhiran f (3.14f), dan decimal dengan m (3.14m).
  • Literal karakter — Satu karakter dalam tanda kutip tunggal ('A'), termasuk urutan escape ('\n').
  • Literal string — Reguler ("hello"), verbatim (@"C:\path"), mentah (""" ... """), dan terinterpolasi ($"value: {x}").
  • Literal Boolean — true dan false.
  • Literal null — Mewakili ketiadaan nilai untuk jenis referensi dan jenis nilai nullable.
  • Literal default — Menghasilkan nilai default untuk jenis apa pun (tercakup dalam default ekspresi).

Bagian berikut mencakup bentuk harfiah yang paling umum secara rinci.

Literal bilangan bulat

int dec = 42;
int hex = 0x2A;
int bin = 0b_0010_1010;
long big = 1_000_000_000L;

Gunakan awalan 0x untuk heksadesimal dan 0b untuk biner. Tambahkan L untuk long, U untuk uint, atau UL untuk ulong.

Tempatkan pemisah digit pada angka di posisi mana pun untuk mempermudah pembacaan. Pola umum termasuk ribuan pemisah dalam literal desimal (1_000_000_000), batas byte atau kata dalam heksadesimal (0xFF_FF), dan batas nibble dalam biner (0b_0010_1010).

Harfiah titik mengambang

double d = 3.14;
float f = 3.14f;
decimal m = 3.14m;
double scientific = 1.5e6; // 1,500,000

Tanpa akhiran, harfiah numerik dengan titik desimal adalah double. Tambahkan f untuk float dan m untuk decimal. Notasi ilmiah (1.5e6) juga didukung.

Karakter dan string literal

char newline = '\n';
char unicode = '\u0041'; // 'A'

string message = $"Found {dec} items";            // interpolated string
string path = @"C:\Users\docs\file.txt";        // verbatim string
string json = """
    { "name": "Alice", "age": 30 }
    """;                                           // raw string literal
string raw = $"""
    Found {dec} items in "{greeting}"
    """;                                           // raw + interpolated

Literal karakter menggunakan tanda kutip tunggal dan mendukung urutan escape (\n, \t, \u). Literal string menggunakan tanda kutip ganda.

Awalan string dengan $ untuk interpolasi. Saat string berisi tanda kutip, garis miring terbalik, atau JSON atau XML yang disematkan, gunakan literal string mentah (dibatasi oleh """) alih-alih menghindari setiap karakter. Literal string mentah juga dikombinasikan dengan interpolasi ($""").

Kode yang lebih lama menggunakan @ string verbatim untuk menghindari pemrosesan escape. Literal string mentah lebih mudah dibaca dan ditulis, jadi sebaiknya digunakan untuk kode baru.

default Ekspresi

default Ekspresi menghasilkan nilai default untuk jenis: 0 untuk jenis numerik, false untuk bool, dan null untuk jenis referensi:

int defaultInt = default;          // 0
bool defaultBool = default;        // false
string? defaultString = default;   // null

// Use default in a conditional:
var limit = (args.Length > 0) ? int.Parse(args[0]) : default(int);

Ekspresi default ini paling berguna dalam kode generik, di mana Anda tidak tahu jenis konkret dan tidak dapat mengkodekan nilai tertentu seperti 0 atau null. Tulis default (tanpa argumen jenis) ketika pengkompilasi dapat menyimpulkan jenis dari konteks, atau default(T) ketika jenisnya tidak jelas. Untuk daftar lengkap nilai default menurut jenis, lihat Nilai default jenis C#.

Variabel yang ditik secara implisit dengan var

Kata kunci var memberi tahu kompiler untuk menyimpulkan tipe variabel lokal dari penginisialisasinya.

var count = 10;              // compiler infers int
var name = "C#";             // compiler infers string
var items = new List<int>(); // compiler infers List<int>

// var requires an initializer — the compiler needs a value to infer the type.
// The following line wouldn't compile:
// var unknown;

Variabel masih bertiped kuat; var tidak membuatnya menjadi dinamis. Pengkompilasi menentukan jenis pada waktu kompilasi dan memberlakukan keamanan jenis seperti biasa. Gunakan var ketika jenisnya jelas dari sisi kanan untuk mengurangi kebisingan visual. Tulis jenis secara lengkap ketika itu membuat kode lebih jelas. Untuk informasi selengkapnya, lihat Variabel lokal yang ditik secara implisit.

Ekspresi berjenis new target

Ketika Anda sudah mengetahui jenis target dari konteks, seperti deklarasi variabel atau parameter metode, Anda dapat menghilangkan nama jenis dari new ekspresi:

List<string> names = new() { "Alice", "Bob", "Charlie" };
Dictionary<string, int> scores = new()
{
    ["Alice"] = 95,
    ["Bob"] = 87
};

Jenis target new mengurangi pengulangan saat nama jenis panjang atau muncul di sisi kiri penugasan. Ini berfungsi di mana saja pengkompilasi dapat menentukan jenis target, termasuk argumen metode dan pernyataan pengembalian. Untuk informasi selengkapnya, lihat new operator — bertipe target new.

Jenis dynamic

dynamic Tipe ini melewati pemeriksaan tipe pada waktu kompilasi. Pengkompilasi menyelesaikan operasi pada dynamic variabel pada waktu proses sebagai gantinya:

dynamic value = 42;
Console.WriteLine(value.GetType()); // System.Int32

value = "Now I'm a string";
Console.WriteLine(value.GetType()); // System.String

// The compiler doesn't check operations on dynamic at compile time.
// Errors surface at run time instead.

Gunakan dynamic saat berinteraksi dengan API COM, bahasa dinamis, atau skenario refleksi-berat di mana jenis tidak dikenal pada waktu kompilasi. Hindari dynamic di sebagian besar kode aplikasi karena Anda kehilangan keamanan waktu kompilasi. Kesalahan yang biasanya ditangkap kompilator menjadi pengecualian run-time sebagai gantinya. Untuk informasi selengkapnya, lihat Jenis dinamis.

Baca juga

  • Last updated on