Operator C#

Tip

Artikel ini adalah bagian dari bagian Dasar-Dasar untuk pengembang yang sudah mengetahui setidaknya satu bahasa pemrograman dan mempelajari C#. Jika Anda baru menggunakan pemrograman, mulailah dengan tutorial Memulai terlebih dahulu.

Berasal dari bahasa lain? Sebagian besar operator dalam artikel ini (+, , -, /*, %, &&||, , !, ==, !=, <, >, , operator perbandingan, dan =) bekerja sama seperti di Java, C++, dan JavaScript. Kejutan utama bagi pemula adalah perilaku pembagian bilangan bulat, perbedaan antara prefix dan postfix untuk ++/--, dan cara penugasan majemuk mengonversi kembali ke tipe di sisi kiri.

Operator menggabungkan satu atau beberapa operand ke dalam satu nilai. Anda sudah tahu tentang ekspresi dan prioritas operator dari ekspresi C#; artikel ini masuk lebih dalam ke operator tertentu yang akan Anda gunakan setiap hari.

Operasi Aritmatika

Lima operator aritmatika melakukan perhitungan numerik.

Operator Nama Example Hasil
+ Penambahan 10 + 3 13
- Pengurangan 10 - 3 7
* Perkalian 10 * 3 30
/ Divisi 10 / 3 3
% Remainder 10 % 3 1 
int apples = 10;
int oranges = 3;

Console.WriteLine(apples + oranges);  // => 13  (addition)
Console.WriteLine(apples - oranges);  // => 7   (subtraction)
Console.WriteLine(apples * oranges);  // => 30  (multiplication)
Console.WriteLine(apples / oranges);  // => 3   (integer division: truncates toward zero)
Console.WriteLine(apples % oranges);  // => 1   (remainder)

// Integer division always truncates toward zero — the fractional part is discarded
int result = 7 / 2;
Console.WriteLine(result); // => 3, not 3.5

// Truncation applies to negative results too: -7 / 2 is -3, not -4
int negResult = -7 / 2;
Console.WriteLine(negResult); // => -3

// To get a decimal result, at least one operand must be a double or float
double precise = 7.0 / 2;
Console.WriteLine(precise); // => 3.5

// Remainder with negative operands: the sign of the result matches the dividend
Console.WriteLine(-7 % 3);  // => -1  (-7 = 3 × -2 + (-1))
Console.WriteLine(7 % -3);  // => 1   ( 7 = -3 × -2 + 1)

Pembagian bilangan bulat dibulatkan ke arah nol. Ketika kedua operan adalah bilangan bulat, / membuang bagian pecahan: 7 / 2 adalah 3, bukan 3.5. Pemotongan menuju nol, bukan menuju angka yang lebih kecil: -7 / 2 adalah -3 (bukan -4). Untuk mendapatkan hasil desimal, buat setidaknya satu operan jenis floating-point: 7.0 / 2 adalah 3.5. Ini berbeda dari beberapa bahasa di mana / selalu menghasilkan hasil floating-point.

Sisanya (%) mengembalikan apa yang tersisa setelah pembagian bilangan bulat: 10 % 3 adalah 1 karena 10 = 3 × 3 + 1. Ini berguna untuk melakukan iterasi pada rentang tetap (index % length), menguji keterbagian (n % 2 == 0), dan mengekstrak digit. Dengan operan negatif, tanda hasil cocok dengan tanda dividen (operand kiri): -7 % 3 adalah -1 dan 7 % -3 adalah 1.

Operator Tunggal

Operator unary bertindak pada satu operand.

int temperature = 20;
int windChill = -5;

int heatIndex = +temperature;   // unary +: value unchanged (rarely needed)
int coldFactor = -windChill;    // unary -: negates the value → 5

Console.WriteLine(heatIndex);   // => 20
Console.WriteLine(coldFactor);  // => 5

bool isRaining = false;
bool isSunny = !isRaining;     // logical NOT: flips true/false
Console.WriteLine(isSunny);    // => True
  • +x (unary plus) — membiarkan nilai tidak berubah; jarang ditulis secara eksplisit tetapi valid.
  • -x (unary minus) — mengubah nilai menjadi negatif.
  • !x (negasi logis) — mengubah true menjadi false dan false menjadi true. Anda akan sering menggunakan ! : if (!list.Contains(item)).

Kenaikan dan penurunan

++ menambahkan 1 dan -- mengurangi 1. Keduanya memiliki formulir awalan dan formulir postfix yang berbeda di mana nilai dikembalikan:

int counter = 5;

// Prefix: increment first, then use the new value
int a = ++counter;
Console.WriteLine(a);       // => 6
Console.WriteLine(counter); // => 6

// Postfix: use the current value first, then increment
int b = counter++;
Console.WriteLine(b);       // => 6  (value before increment)
Console.WriteLine(counter); // => 7  (incremented after)

// Decrement works the same way
int score = 10;
Console.WriteLine(score--); // => 10 (current value; score becomes 9)
Console.WriteLine(score);   // => 9
  • Prefiks (++i, --i): menaikkan atau menurunkan nilai variabel terlebih dahulu, lalu mengembalikan nilai baru.
  • Postfix (i++, i--): mengembalikan nilai saat ini terlebih dahulu, lalu kenaikan atau penurunan variabel.

Ketika ++ atau -- muncul sebagai pernyataan mandiri (bukan bagian dari ekspresi yang lebih besar), awalan dan postfiks memiliki efek yang sama. Perbedaan hanya penting ketika hasilnya digunakan — misalnya, dalam penugasan atau sebagai argumen metode.

Operator relasional

Operator relasional membandingkan dua nilai dan mengembalikan bool.

Operator Meaning Example
< Kurang dari speed < limit
> Lebih besar dari speed > limit
<= Kurang dari atau sama dengan score <= 100
>= Lebih besar dari atau sama dengan score >= 0 
int speed = 75;
int limit = 60;

Console.WriteLine(speed > limit);   // => True   (greater than)
Console.WriteLine(speed < limit);   // => False  (less than)
Console.WriteLine(speed >= limit);  // => True   (greater than or equal)
Console.WriteLine(speed <= limit);  // => False  (less than or equal)

// Relational operators work on all numeric types and char
// char comparison uses the character's numeric Unicode code point, not alphabetical position
// 'B' (U+0042, value 66) is less than 'A' (U+0041, value 65)? No — 'A' (65) < 'B' (66)
char grade = 'B';
Console.WriteLine(grade >= 'A' && grade <= 'C'); // => True  ('A'=65 <= 'B'=66 <= 'C'=67)

Operator relasional bekerja pada semua jenis numerik dan char. Untuk char, perbandingan menggunakan nilai titik kode Unicode numerik karakter, bukan urutan alfabet atau khusus domain. Dalam contoh nilai di atas, 'B' lebih besar dari atau sama dengan 'A' karena 'B' memiliki nilai Unicode 66 dan 'A' memiliki nilai Unicode 65 — angka menentukan perbandingan, bukan arti dari nilai huruf.

Operator Kesetaraan

== dan != periksa apakah dua nilai sama atau tidak. != adalah true ketika operan tidak sama, dan false ketika keduanya sama.

int expected = 42;
int actual = 42;

Console.WriteLine(actual == expected);  // => True   (values are equal)
Console.WriteLine(actual != expected);  // => False  (true when values are not equal)

string name = "Alice";
Console.WriteLine(name == "Alice");  // => True   (string content matches)
Console.WriteLine(name == "alice");  // => False  (case-sensitive)

int x = 5;
Console.WriteLine(x == 10);  // => False

Untuk jenis numerik dan string, kesetaraan menguji nilai. Untuk jenis referensi, defaultnya adalah identitas (apakah dua variabel menunjuk ke objek yang sama), tetapi banyak jenis termasuk string dan record mengambil alih ini untuk membandingkan konten. Untuk gambar lengkap — cara kerja kesetaraan di seluruh jenis nilai, jenis referensi, rekaman, dan struktur — lihat Perbandingan kesetaraan.

Note

C# tidak memiliki === operator. Menulis === adalah kesalahan waktu kompilasi:

// This does not compile — C# has no === operator
bool same = (x === 10);

Jika Anda berasal dari JavaScript, gunakan == untuk perbandingan nilai (C# == sudah dibandingkan dengan nilai untuk jenis dan string primitif). Bug terkait yang umum terjadi adalah tidak sengaja menulis = (penugasan) padahal yang dimaksud adalah == (pengecekan kesamaan). Kompiler menangkap bentuk yang paling umum, tetapi periksa kembali kondisi apa pun if yang berisi =.

Operator logika kondisional

&& (AND) dan || (OR) menggabungkan bool ekspresi.

int age = 20;
bool hasTicket = true;

// && (AND): both sides must be true
bool canEnter = age >= 18 && hasTicket;
Console.WriteLine(canEnter); // => True

// || (OR): at least one side must be true
bool freeEntry = age < 5 || age >= 65;
Console.WriteLine(freeEntry); // => False

// Short-circuit: right side is skipped when the result is already determined
// Here, items.Count is never called if items is null
List<string>? items = null;
bool hasItems = items != null && items.Count > 0;
Console.WriteLine(hasItems); // => False  (short-circuits; no NullReferenceException)

Kedua operator short-circuit: operator tersebut tidak mengevaluasi operand kanan ketika hasilnya telah dapat ditentukan.

  • && mengembalikan false segera setelah sisi kiri bernilai false. Sisi kanan tidak pernah dievaluasi.
  • || mengembalikan true segera setelah sisi kiri bernilai true. Sisi kanan tidak pernah dievaluasi.

Perilaku sirkuit pendek memiliki manfaat praktis: Anda dapat dengan aman menjaga operasi di sisi kanan dengan pemeriksaan null di sisi kiri, seperti yang ditunjukkan contoh di atas. Jika items adalah null, && berhenti di situ — items.Count tidak pernah dipanggil, jadi tidak ada NullReferenceException yang dilemparkan.

Operator kondisional ?:

Operator bersyarat (juga disebut operator terner ) mengevaluasi salah satu dari dua ekspresi berdasarkan kondisi:

condition ? value-when-true : value-when-false

int temperature2 = 35;

// condition ? value-when-true : value-when-false
string weather = temperature2 > 30 ? "hot" : "comfortable";
Console.WriteLine(weather); // => hot

// Only the matching branch evaluates — the other branch is never run
int divisor = 0;
// The division 10 / divisor is never evaluated because divisor == 0 is true
int safe = divisor == 0 ? -1 : 10 / divisor;
Console.WriteLine(safe); // => -1

Operator ?: selalu mengevaluasi tepat satu cabang — sisi yang tidak cocok dengan kondisi tidak pernah dievaluasi. Ini membuatnya aman untuk menggunakan ekspresi di satu sisi yang akan gagal untuk input lain, selama kondisi menjaganya dengan benar.

Gunakan ?: untuk pilihan sebaris yang sederhana. Untuk kondisi dengan banyak cabang atau blok kode, statemen if/else biasanya lebih jelas.

Operator Penugasan

Operator = penugasan sederhana menyimpan nilai dalam variabel:

int level = 1;  // declaration + initialization
level = 5;      // reassignment

Penugasan dalam C# bersifat asosiatif kanan, yang berarti a = b = c = 0 mengevaluasi kanan ke kiri: c mendapatkan 0, lalu b mendapatkan 0, lalu a mendapatkan 0.

Penugasan gabungan

Operator penugasan majemuk menggabungkan operasi biner dengan penugasan:

Operator Setara dengan
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y 
int level = 1;
level = 5;          // simple assignment: replaces the value
Console.WriteLine(level); // => 5

// Compound assignment: short form of binary operation + assignment
int hp = 100;
hp += 20;   // same as: hp = hp + 20
Console.WriteLine(hp); // => 120
hp -= 10;   // same as: hp = hp - 10
Console.WriteLine(hp); // => 110
hp *= 2;    // same as: hp = hp * 2
Console.WriteLine(hp); // => 220
hp /= 3;    // same as: hp = hp / 3 (integer division)
Console.WriteLine(hp); // => 73
hp %= 7;    // same as: hp = hp % 7
Console.WriteLine(hp); // => 3

Penugasan gabungan lebih dari sekadar bentuk singkat. Ini mengevaluasi sisi kiri tepat sekali dan kemudian mengonversi hasilnya kembali ke jenis sisi kiri. Ini penting ketika sisi kiri memiliki efek samping (seperti pengindeks array), dan itulah sebabnya penugasan gabungan pada variabel byte berhasil dikompilasi tanpa cast eksplisit, sementara bentuk yang diperluas tidak.

// Assignment is right-associative: evaluated right to left
int a2, b2, c2;
a2 = b2 = c2 = 0;     // c2 = 0 first, then b2 = 0, then a2 = 0
Console.WriteLine($"{a2} {b2} {c2}"); // => 0 0 0

// Compound assignment evaluates the left side once and converts back to the LHS type
byte small = 200;
small += 10;  // equivalent to: small = (byte)(small + 10); result is 210
Console.WriteLine(small); // => 210

small += 10 dikompilasi karena pengkompilasi menyisipkan konversi penyempitan secara otomatis — hasilnya, 210, pas dalam byte rentang 0–255. small = small + 10 akan memerlukan cast eksplisit (byte), karena aritmetika mempromosikan kedua operan menjadi int.

Operator C# lainnya

Artikel ini membahas operator yang paling sering Anda temui dalam kode sehari-hari. Bahasa C# mencakup lebih banyak operator yang berguna dalam skenario tertentu:

  • Operator shift (<<, >>, >>>) — geser bit nilai bilangan bulat ke kiri atau kanan dengan jumlah posisi tertentu. Operator logika bitwise dan bilangan bulat (&, |, ^, ~) — menggabungkan atau menginversi nilai bilangan bulat, satu bit pada satu waktu, berguna dalam flag, mask, dan kode level rendah: Operator bitwise dan shift
  • checked dan unchecked — mengontrol apakah luapan bilangan bulat melempar pengecualian (checked) atau membungkus secara diam-diam (unchecked): Diperiksa dan tidak dicentang
  • Operator null (??, ??=, ?., ?[]) — menangani nilai null secara aman dengan menyediakan nilai default atau menghentikan akses anggota lebih awal: Operator null
  • Operator uji tipe dan konversi (is, as, typeof, cast (T)) — memeriksa atau mengonversi tipe runtime suatu nilai: Operator pengujian tipe dan cast
  • Operator rentang dan indeks (.., ^) — membuat rentang dan indeks relatif terhadap akhir untuk pemotongan array dan span: Akses anggota dan operator bersyarat null
  • Penugasan dekonstruksi — menguraikan tuple atau tipe menjadi variabel-variabel individual dalam satu ekspresi: Mendekonstruksi tuple dan tipe lainnya

Baca juga

  • Last updated on