Setelah kita belajar tentang variabel dan tipe data, berikutnya kita akan belajar tentang operator. Variabel berfungsi sebagai tempat kita menyimpan data. Lalu untuk memproses data, kita membutuhkan bantuan operator.
Operator
Operator adalah simbol atau karakter khusus yang digunakan untuk melakukan operasi pada satu atau lebih nilai (operand). Operator membantu programmer untuk melakukan berbagai jenis perhitungan, manipulasi data, atau pengambilan keputusan di dalam kode program.
Misalnya kita ingin menjumlahkan nilai dari variabel x dan y, maka kita bisa menggunakan operator penjumlahan (+).
x + y
x dan y disebut operan, sedangkan + disebut operator.
Berdasarkan banyaknya operan, operator dikelompokkan menjadi tiga macam, yaitu : Unary, Binary, dan Ternary.
Lalu berdasarkan operasi yang dilakukan, operator dibagi lagi menjadi beberapa bagian. Ada yang namanya operator aritmatika, logika, perbandingan, assignment dan bitwise.
Jenis-Jenis Operator di C#
C# memiliki banyak jenis operator, namun yang akan kita bahas di sini adalah operator dasar yang sering digunakan, diantaranya :
- Operator Aritmatika
- Operator Penugasan (Assignment)
- Operator Perbandingan
- Operator Logika (Boolean Logical)
- Operator Bitwise
- Operator Kondisional (Ternary)
1. Operator Aritmatika
Operator aritmatika adalah jenis operator yang digunakan untuk melakukan operasi matematika dasar seperti penjumlahan, pengurangan, perkalian, pembagian, dan sebagainya. Operator ini bekerja dengan operand berupa angka atau nilai numerik.
Operator Aritmatika terdiri dari :
Operator | Deskripsi | Contoh | Hasil |
---|---|---|---|
+ |
Penjumlahan | 5 + 3 |
8 |
- |
Pengurangan | 5 - 3 |
2 |
* |
Perkalian | 5 * 3 |
15 |
/ |
Pembagian | 6 / 3 |
2 |
% |
Modulus (sisa hasil pembagian) | 5 % 2 |
1 |
++ |
Increment | 6++ |
7 |
-- |
Decrement | 6-- |
5 |
Operator Penjumlahan
Silakan buat program baru bernama AritmatikaPenjumlahan.cs, dengan kode sebagai berikut:
using System; class AritmatikaPenjumlahan { public static void Main(string[] args) { int angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi penjumlahan dengan operator + hasil = angka1 + angka2; Console.WriteLine($"Hasil penjumlahan angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Hasilnya :
Pada contoh ini, kita memberikan input untuk variabel angka1 adalah 10 dan angka2 adalah 6, maka 10+6 hasilnya 16.
Operasi penjumlahan dapat kita lakukan untuk tipe data numerik atau angka. Jika kita melakukan penjumlahan pada tipe data string, maka yang terjadi adalah penggabungan, bukan penjumlahan.
Contoh :
string nama = "Agus" + "Suratna"
Maka variabel nama akan berisi AgusSuratna.
Operator Pengurangan
Berikutnya kita coba untuk menggunakan operator yang lainnya. Sekarang kita coba untuk operator pengurangan. Buatlah program baru dengan nama AritmatikaPengurangan.cs, kemudian isi dengan kode berikut :
class AritmatikaPengurangan { public static void Main(string[] args) { int angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi pengurangan dengan operator - hasil = angka1 - angka2; Console.WriteLine($"Hasil pengurangan angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Setelah itu kita compile dan jalankan, maka hasilnya :
Selain pengurangan tanda – juga berfungsi sebagai tanda minus. Cara penggunaannya sama seperti pada matematika.
Contoh :
int a = -10; int b = -(-6);
Operator Perkalian
Sekarang lanjut ke operator aritmatika berikutnya, yakni perkalian. Buatlah program baru dengan nama AritmatikaPerkalian.cs, kemudian isi dengan kode berikut :
class AritmatikaPerkalian { public static void Main(string[] args) { int angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi perkalian dengan operator * hasil = angka1 * angka2; Console.WriteLine($"Hasil perkalian angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Setelah itu compile dan jalankan. maka hasilnya :
Untuk perkalian di pemrograman C# menggunakan simbol * (asterisk / bintang). Perkaian pada bahasa pemrograman tidak menggunakan x, karena x sendiri merupakan sebuah huruf yang akan dianggap sebagai karakter, bukan operator perkalian.
Operator Pembagian
Buatlah program baru dengan nama AritmatikaPembagian.cs dengan kode sebagai berikut :
using System; class AritmatikaPembagian { public static void Main(string[] args) { int angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi pembagiann dengan operator / hasil = angka1 / angka2; Console.WriteLine($"Hasil pembagian angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Sama seperti perkalian, untuk pembagian kita menggunakan simbol / (slash atau garis miring). Bukan simbol bagi ➗ seperti pada kalkulator.
Setelah itu kita coba compile dan jalankan, maka hasilnya :
Hasilnya 1, bukan 1.66666. Ini disebabkan karena kita menggunakan tipe data integer untuk variabel angka1 dan angka2. Sekarang kita coba kita ubah tipe datanya menjadi float :
using System; class AritmatikaPembagian { public static void Main(string[] args) { float angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi pembagian dengan operator / hasil = angka1 / angka2; Console.WriteLine($"Hasil pembagian angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Hasilnya:
Operator Modulus / Sisa Pembagian
Operator ini akan menghasilkan sisa dari hasil pembagian, misalnya 20 bagi 3 maka sisanya 1.
Biar lebih jelas kita coba buat program baru dengan nama AritmatikaSisabagi.cs dengan kode sebagai berikut :
using System; class AritmatikaSisabagi { public static void Main(string[] args) { int angka1, angka2, hasil = 0; Console.Write("Masukan angka ke-1 : "); angka1 = int.Parse(Console.ReadLine()); Console.Write("Masukan angka ke-2 : "); angka2 = int.Parse(Console.ReadLine()); // operasi sisa pembagian dengan operator % hasil = angka1 % angka2; Console.WriteLine($"Hasil sisa pembagian angka ke-1 dan angka ke-2 adalah {hasil}"); } }
Setelah itu compile dan jalankan, maka hasilnya :
Variable angka1 bernilai 20, kemudian dibagi dengan variable angka2 yang bernilai 3, maka sisa variable angka1 yang gak bisa dibagi tinggal 2.
Operator Increment dan Decrement
Increment
Increment adalah operasi dalam pemrograman yang digunakan untuk menambahkan nilai 1 ke sebuah variabel. Operasi ini biasanya digunakan untuk memperbarui nilai dalam suatu proses perulangan atau logika lainnya.
Biasanya kita melakukannya seperti ini :
int nilai = 2; nilai = nilai + 1; // increment
Nah, dengan operator Increment kita bisa buat lebih singkat.
int nilai = 2; nilai = nilai++; // increment
Increment menggunakan operator ++
dan dapat digunakan dalam dua bentuk utama:
- Pre-Increment (
++variabel
)
Nilai variabel akan ditingkatkan sebelum digunakan dalam ekspresi. - Post-Increment (
variabel++
)
Nilai variabel akan ditingkatkan setelah digunakan dalam ekspresi.
Contoh Increment
- Pre-Increment (
++variabel
)int a = 5; int b = ++a; // a meningkat menjadi 6, kemudian nilai b = 6 Console.WriteLine(a); // Output: 6 Console.WriteLine(b); // Output: 6
- Post-Increment (
variabel++
)int a = 5; int b = a++; // b = 5 (nilai awal a), kemudian a meningkat menjadi 6 Console.WriteLine(a); // Output: 6 Console.WriteLine(b); // Output: 5
Cara Kerja Increment
Tipe | Proses | Hasil |
---|---|---|
Pre-Increment | Tambah nilai dulu, lalu gunakan variabel. | ++a |
Post-Increment | Gunakan nilai variabel dulu, lalu tambah nilai. | a++ |
Decrement
Decrement adalah operasi dalam pemrograman yang digunakan untuk mengurangi nilai 1 dari sebuah variabel. Operasi ini sering digunakan dalam pengolahan logika, perulangan, atau algoritma tertentu yang memerlukan pengurangan nilai secara bertahap.
Sintaks Decrement
Decrement menggunakan operator --
dan, seperti increment, memiliki dua bentuk utama:
- Pre-Decrement (
--variabel
)
Nilai variabel akan dikurangi sebelum digunakan dalam ekspresi. - Post-Decrement (
variabel--
)
Nilai variabel akan dikurangi setelah digunakan dalam ekspresi.
Contoh Decrement
- Pre-Decrement (
--variabel
)int a = 5; int b = --a; // a berkurang menjadi 4, kemudian nilai b = 4 Console.WriteLine(a); // Output: 4 Console.WriteLine(b); // Output: 4
- Post-Decrement (
variabel--
)int a = 5; int b = a--; // b = 5 (nilai awal a), kemudian a berkurang menjadi 4 Console.WriteLine(a); // Output: 4 Console.WriteLine(b); // Output: 5
Cara Kerja Decrement
Tipe | Proses | Hasil |
---|---|---|
Pre-Decrement | Kurangi nilai dulu, lalu gunakan variabel. | --a |
Post-Decrement | Gunakan nilai variabel dulu, lalu kurangi nilai. | a-- |
Berikut contohnya, buatlah program baru dengan nama IncrementDecrement.cs, kemudian isi dengan kode berikut.
class IncrementDecrement { public static void Main(string[] args) { int ipa = 90; int bahasa = 85; Console.WriteLine($"ipa = {ipa}"); Console.WriteLine($"bahasa = {bahasa}"); // increment ipa++; ++bahasa; Console.WriteLine($"ipa+1 = {ipa}"); Console.WriteLine($"bahasa+1 = {bahasa}"); // decrement ipa--; --bahasa; Console.WriteLine($"ipa-1 = {ipa}"); Console.WriteLine($"bahasa-1 = {bahasa}"); } }
Setelah itu compile dan jalankan, maka hasilnya :
Operator increment dan decrement dapat ditulis di depan maupun belakang operan/variabel.
2. Operator Penugasan
Operator penugasan (Assignment Operator) merupakan operator untuk memberikan tugas pada variabel, biasanya digunakan untuk mengisi nilai.
Nama Operator | Sombol |
---|---|
Pengisian Nilai | = |
Pengisian dan Penambahan | += |
Pengisian dan Pengurangan | -= |
Pengisian dan Perkalian | *= |
Pengisian dan Pembagian | /= |
Pengisian dan Sisa bagi | %= |
Pengisian dan shift left | <<= |
Pengisian dan shift right | >>= |
Pengisian dan bitwise AND | &= |
Pengisian dan bitwise OR | |= |
Pengisian dan bitwise XOR | ^= |
Sekarang kita coba dalam program, buatlah program baru dengan nama ProgramPenugasan.cs dengan kode sebagai berikut :
class ProgramPenugasan { public static void Main(String[] args) { // menggunakan operator = untuk mengisi nilai int ipa = 90; int bahasa = 85; // mengisi ulang nilai variabel ipa ipa = 95; Console.WriteLine($"ipa = {ipa}"); // menggunakan += untuk mengisi dan menjumlahkan bahasa += 4; Console.WriteLine($"bahasa = {bahasa}"); } }
Coba compile dan jalankan, maka hasilnya :
Pada contoh tersebut kita mengisi ulang nilai variabel ipa menjadi 95 dengan operator pengisian (=). Lalu untuk variabel bahasa kita menambahkannya dengan 4.
bahasa += 4;
Sebenarnya ini bentuk sederhana dari operasi aritmatika:
bahasa = bahasa + 4;
Untuk operator penugasan yang lainnya, silahkan bisa dicoba sendiri. Misalnya untuk pengurangan, ubah saja += menjadi -=.
bahasa -= 4;
Tapi harap hati-hati, jangan sampai kebalik seperti ini:
bahasa =- 4;
Karena ini akan membuat variabel bahasa diisi ulang dengan nilai -4, bukan dikurangi 4. Pada dasarnya operator penugasan sama seperti aritmatika, hanya saja lebih singkat dan fungsinya untuk mengisi nilai.
3. Operator Perbandingan
Operator pembanding adalah operator untuk membandingkan dua buah nilai. Operator ini juga dikenal dengan operator relasi.
Nilai yang dihasilkan dari operasi pembanding akan berupa boolean True dan False.
Untuk lebih jelasnya kita coba dalam program, buatlah program baru dengan nama ProgramPerbandingan.cs dengan kode sebagai berikut :
using System; class ProgramPerbandingan { public static void Main(String[] args) { int ipa, bahasa = 0; Console.Write("jumlah ipa = "); ipa = int.Parse(Console.ReadLine()); Console.Write("jumlah bahasa = "); bahasa = int.Parse(Console.ReadLine()); Console.WriteLine("Hasil perbandingan: "); Console.WriteLine($"ipa > bahasa : {ipa > bahasa}"); Console.WriteLine($"ipa >= bahasa : {ipa >= bahasa}"); Console.WriteLine($"ipa < bahasa : {ipa < bahasa}"); Console.WriteLine($"ipa <= bahasa : {ipa <= bahasa}"); Console.WriteLine($"ipa == bahasa : {ipa == bahasa}"); Console.WriteLine($"ipa != bahasa : {ipa != bahasa}"); } }
Setelah itu coba compile dan jalankan, maka hasilnya :
Operator perbandingan nanti akan banyak kita pakai untuk membuat logika program di materi percabangan.
Contohnya seperti ini :
if ( ipa > bahasa ) { Console.WriteLine("Nilai IPA lebih tinggi dari nilai Bahasa"); }
Kita bisa bandingkan tipe data apa saja dengan operator perbandingan.
Contoh :
Membandingkan tipe data string.
string password = "admin"; Console.WriteLine(password == "admin"); // True
Membandingkan tipe data integer dengan float.
Console.WriteLine(0.1f == 1); // False
Membandingkan tipe data boolean.
Console.WriteLine(True != False); // True
4. Operator Logika
Operator logika adalah jenis operator dalam pemrograman yang digunakan untuk melakukan operasi logika pada nilai boolean (true atau false). Operator ini biasanya digunakan dalam pengambilan keputusan (conditional statements) atau perulangan untuk menggabungkan atau memodifikasi kondisi logika.
Jenis-Jenis Operator Logika
Operator | Nama | Fungsi |
---|---|---|
&& |
AND | Menghasilkan true jika kedua kondisi bernilai true . |
|| |
OR | Menghasilkan true jika salah satu kondisi bernilai true |
! |
NOT | Membalikkan nilai boolean: true menjadi false dan sebaliknya. |
Hasil operasi dari operator logika sama seperti operator perbandingan, yakni boolean True dan False. Namun perlu diingat operan harus bertipe boolean, karena jika tidak maka akan terjadi error. Operator Logika digunakan untuk membuat operasi logika.
Penjelasan Operator Logika
- AND (
&&
)- Menghasilkan
true
hanya jika kedua kondisi bernilaitrue
. - Contoh:
bool a = true; bool b = false; Console.WriteLine(a && b); // Output: False (karena salah satu kondisi false)
- Menghasilkan
- OR (
||
)- Menghasilkan
true
jika salah satu atau kedua kondisi bernilaitrue
. - Contoh:
bool a = true; bool b = false; Console.WriteLine(a || b); // Output: True (karena salah satu kondisi true)
- Menghasilkan
- NOT (
!
)- Membalikkan nilai boolean.
- Contoh:
bool a = true; Console.WriteLine(!a); // Output: False (true dibalik menjadi false)
Tabel Kebenaran (Truth Table)
1. AND (&&
)
Kondisi 1 | Kondisi 2 | Hasil (&& ) |
---|---|---|
true |
true |
true |
true |
false |
false |
false |
true |
false |
false |
false |
false |
2. OR (||
)
Kondisi 1 | Kondisi 2 | Hasil (|| ) |
---|---|---|
true |
true |
true |
true |
false |
true |
false |
true |
true |
false |
false |
false |
3. NOT (!
)
Kondisi | Hasil (! ) |
---|---|
true |
false |
false |
true |
Untuk lebih jelasnya mari kita coba dalam program, buatlah program baru dengan nama ProgramLogika.cs, kemudian isi dengan kode berikut :
using System; class ProgramLogika { public static void Main(String[] args) { Console.Write("Enter your age: "); int age = int.Parse(Console.ReadLine()); Console.Write("Password: "); string password = Console.ReadLine(); bool isAdult = age >= 17; // pernyataan 1 bool isPasswordValid = password == "admin"; // pernyataan 2 // menggunakan logika AND if (isAdult && isPasswordValid) { Console.WriteLine("Anda sudah layak dapat KTP"); } else { Console.WriteLine("Maaf anda belum layak dapat KTP"); } } }
Pada contoh program ini, kita menggunakan logika AND untuk mengecek apakah user sudah dewasa dan password yang diinputkan benar.
Maka hasilnya :
Dan jika logika AND tidak terpenuhi, maka akan menghasilkan :
5. Operator Bitwise
Operator bitwise adalah operator dalam pemrograman yang bekerja pada tingkat bit dari angka biner. Operator ini memungkinkan manipulasi langsung terhadap representasi biner angka, seperti melakukan operasi AND, OR, XOR, dan lainnya.
Jenis-Jenis Operator Bitwise
Operator | Nama | Deskripsi |
---|---|---|
& |
Bitwise AND | Menghasilkan 1 jika kedua bit pada posisi yang sama bernilai 1. |
| | Bitwise OR | Menghasilkan 1 jika salah satu bit pada posisi yang sama bernilai 1. |
^ |
Bitwise XOR | Menghasilkan 1 jika salah satu bit bernilai 1 tetapi tidak keduanya (exclusive OR). |
~ |
Bitwise NOT | Membalik semua bit (0 menjadi 1, dan 1 menjadi 0). |
<< |
Left Shift | Menggeser bit ke kiri, mengisi dengan nol di posisi yang kosong. |
>> |
Right Shift | Menggeser bit ke kanan, mengisi dengan 0 untuk unsigned dan dengan nilai bit sign untuk signed. |
Buat kamu yang sudah pernah belajar sistem bilangan dan sistem digital akan mudah memahami cara kerja operator ini.
Misalkan kita punya nilai 6 dan 3, nilai 6 dan 3 kemudian kita ubah ke dalam bentuk bilangan biner, sehingga akan menjadi seperti ini :
6 = 0110
3 = 0011
Operator bitwise akan melakukan operasi berdasarkan biner-biner tersebut.
a. Bitwise AND (&)
Bitwise AND merupakan operasi bit berdasarkan logika AND, perhatikan gambar ini.
Perhatikan bilangan biner untuk nilai 6 dan 3. Apabila kita melakukan operasi AND di sana, maka akan menghasilkan bilangan biner baru. Kemudian biner yang dihasilkan tersebut diubah kembali ke dalam bilangan desimal, maka hasilnya adalah 2.
Sekarang kita coba dalam program, buatlah program baru bernama BitwiseAnd.cs, kemudian isi dengan kode berikut :
using System; class BitwiseAnd { public static void Main(String[] args) { int a = 6; int b = 3; // menggunakan operator bitwise and (&) int hasil = a & b; Console.WriteLine($"a & b = {hasil}"); } }
Hasil outputnya:
a & b = 2
b. Bitwise OR (|)
Operator bitwise OR juga sama seperti bitwise AND. Operator bitwise OR akan menghasilkan nilai false atau 0 saat
Contoh Program: BitwsieOr.cs
using System; class BitwiseOr { public static void Main(String[] args) { int a = 6; int b = 3; // menggunakan operator bitwise or (|) int hasil = a | b; Console.WriteLine($"a | b = {hasil}"); } }
Hasil outputnya:
a | b = 7
c. Bitwise XOR (^)
Operator XOR (Exclusive OR) akan menghasilkan nilai 1 saat kedua nilai tidak sama.
Contoh Program: BitwiseXor.cs
using System; class BitwiseXOr { public static void Main(String[] args) { int a = 6; int b = 3; // menggunakan operator bitwise xor (^) int hasil = a ^ b; Console.WriteLine($"a | b = {hasil}"); } }
Hasil outputnya:
a ^ b = 5
d. Bitwise NOT (~)
Bitwise NOT dikenal juga dengan komplemen. Operator ini akan menghasilkan nilai biner yang terbalik dari biner aslinya. Kemudian direpresentasikan dengan komplemen dua.
Contoh program BitwiseNot.cs
using System; class BitwiseNot { public static void Main(String[] args) { int a = 6; // menggunakan operator bitwise not (~) int hasil = ~a; Console.WriteLine($"~a = {hasil}"); } }
Hasil outputnya:
~a = -7
e. Bitwise Left Shift (<<)
Operator bitwise left shift akan menghasilkan nilai biner yang digeser ke kiri.
Contoh:
6 << 1
Maka nilai biner dari 6 akan digeser sebanyak 1 bit ke arah kiri.
Contoh program: BitwiseLeft.cs
using System; class BitwiseLeft { public static void Main(String[] args) { int a = 6; // menggunakan operator bitwise left shift (<<) int hasil = a << 1; Console.WriteLine($"a << 1 = {hasil}"); } }
Hasilnya:
a << 1 = 12
e. Bitwise Right Shift (>>)
Bitwise right shift sama seperti left shift, perbedaannya terletak pada arahnya. Right shift akan menggeser bit ke arah kanan.
Contoh :
6 >> 1
Maka nilai biner dari 6 akan digeser ke arah kanan sebanyak 1 bit.
Contoh program BitwiseRight.cs
using System; class BitwiseRight { public static void Main(String[] args) { int a = 6; // menggunakan operator bitwise right shift (>>) int hasil = a >> 1; Console.WriteLine($"a >> 1 = {hasil}"); } }
Hasilnya:
a >> 1 = 3
6. Conditional Operator (Ternary)
Conditional operator adalah operator yang membentuk logika jika/maka atau if/else. Conditional Operator disebut juga operator ternary karena memiliki tiga operan.
Operan pertama adalah kondisi yang akan dicek, pada bagian ini kita bisa membuat ekspresi dengan operator perbandingan dan logika. Lalu operan berikutnya adalah ekspresi jika kondisi benar dan sisanya ekspresi yang akan dipakai jika kondisi salah.
Untuk lebih jelasnya, kita buat program baru dengan nama ProgramCoditional.cs, kemudian isi dengan kode berikut :
using System; class ProgramConditional { static void Main(string[] args) { Console.Write("Berapa usia anda : "); int age = int.Parse(Console.ReadLine()); // menggunakan conditional operator string message = age < 17 ? "Belum cukup umur" : "Sudah cukup umur untuk dapat KTP"; Console.WriteLine(message); } }
Setelah itu compile dan jalankan, maka hasilnya jika kita input nilai di bawah 17 akan menghasilkan :
Belum cukup umur
Jika kita input nilai di lebih besar atau sama dengan 17 akan menghasilkan :
Sudah cukup umur untuk dapat KTP
Bisa dibilang conditional operator ini adalah bentuk singkat dari if/else.
Urutan Operasi (Operator precedence)
Satu hal lagi yang harus kita ketahui tentang operator , yaitu urutan operasi. Hal ini penting, karena nantinya kita bisa tentukan prioritas operasi, mana yang didahulukan dan mana operasi yang dilakukan belakangan.
Coba perhatikan contoh berikut :
var a = 2 + 2 * 2; Console.WriteLine(a);
Maka hasilnya 6, bukan 8. Secara alami operasi perkalian lebih dahulu dikerjakan barulah penjumlahan. Namun jika kita ingin memberikan prioritas agar operasi penjumlahan didahului juga bisa. Caranya tambahkan kurung pada operasi yang ingin dihitung duluan.
var a = (2 + 2) * 2; Console.WriteLine(a);
Sekarang hasilnya akan 8, karena 2+2 dihitung terlebih dahulu, barulah kemudian di kali.
Berikut ini tabel urutan prioritas operator :
Operator | Nama |
---|---|
x.y , f(x) , a[i] , x?.y , x?[y] , x++ , x-- , x! , new , typeof , checked , unchecked , default , nameof , delegate , sizeof , stackalloc , x->y |
Primary |
+x , -x , !x , ~x , ++x , --x , ^x , (T)x , await , &x , *x , true and false |
Unary |
x..y |
Range |
switch |
switch expression |
with |
with expression |
x * y , x / y , x % y |
Multiplicative |
x + y , x – y |
Additive |
x << y , x >> y |
Shift |
x < y , x > y , x <= y , x >= y , is , as |
Relational and type-testing |
x == y , x != y |
Equality |
x & y |
Boolean logical AND or bitwise logical AND |
x ^ y |
Boolean logical XOR or bitwise logical XOR |
`x | y` |
x && y |
Conditional AND |
`x | |
x ?? y |
Null-coalescing operator |
c ? t : f |
Conditional operator |
x = y , x += y , x -= y , x *= y , x /= y , x %= y , x &= y , `x |
= y, x ^= y, x «= y, x »= y, x ??= y, =>` |
Untuk operator bitwise, berdaarkan pengalaman saya dalam membuat program, operator bitwise jarang digunakan. Lalu untuk operator ternary atau conditional operator boleh dipakai boleh juga tidak, karena merupakan bentuk lain dari if/else.
Demikian tutorial tentang operator pada C#, jika ada pertanyaan silahkan tuliskan dikolom komentar. Selanjutny kita akan mempelajari tentang :
Referensi :
- https://www.petanikode.com/cs-operator/