Operator C# yang Harus Diketahui di Unity

Unity adalah mesin permainan yang melakukan banyak hal "heavy-lifting" bagi pengembang dalam hal fungsionalitas dan memungkinkan mereka untuk fokus sepenuhnya pada proses pengembangan. Mesin ini menggunakan C# sebagai bahasa pemrograman utama.

Seperti bahasa pemrograman lainnya, C# terdiri dari serangkaian fungsi khusus, tipe, kelas, pustaka, dll., tetapi juga memiliki daftar simbol khusus (operator) yang masing-masing memiliki fungsinya sendiri. Dalam posting ini, saya akan mencantumkan simbol-simbol tersebut dan menjelaskan fungsinya, sehingga saat Anda membuka skrip berikutnya, Anda dapat dengan cepat memahami arti setiap bagiannya.

Operator dalam C# adalah beberapa simbol khusus yang melakukan beberapa tindakan pada operan.

Dalam C#, terdapat 6 jenis operator bawaan: Operator aritmatika, Operator perbandingan, Operator logika Boolean, Operator bitwise dan shift, Operator kesetaraan, dan Operator lain-lain. Mengetahui semuanya akan membuat Anda langsung menjadi programmer yang lebih baik.

1. Operator Aritmatika

Operator berikut melakukan operasi aritmatika dengan operan bertipe numerik:

Operator unary ++ (bertambah), -- (berkurang), + (tambah), dan - (kurang)
Operator biner * (perkalian), / (pembagian), % (sisa), + (penambahan), dan - (pengurangan).

Operator Peningkatan ++

Operator "add one" (atau ++) berarti += 1, dengan kata lain, ini adalah cara cepat untuk menambahkan satu bilangan bulat ke nilai numerik, tanpa harus mengetik kode tambahan. Operator ini dapat ditambahkan sebelum atau sesudah nilai, yang akan menghasilkan perilaku yang berbeda:

//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i);   // output: 5

//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a);   // output: 3.5

Operator Penurunan --

Operator "subtract one" adalah kebalikan dari ++ (-= 1), yang berarti operator ini mengurangi satu bilangan bulat dari sebuah nilai numerik. Operator ini juga dapat ditambahkan sebelum atau sesudah sebuah nilai:

The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i);   // output: 3

The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a);   // output: 1.5

Operator Unary + dan -

Operator unary + mengembalikan nilai operannya, sedangkan operator unary - menghitung negasi numerik dari operannya.

Debug.Log(+5);     // output: 5

Debug.Log(-5);     // output: -5
Debug.Log(-(-5));  // output: 5

uint a = 6;
var b = -a;
Debug.Log(b);            // output: -6
Debug.Log(b.GetType());  // output: System.Int64

Debug.Log(-double.NaN);  // output: NaN

Operator perkalian *

Operator perkalian * menghitung hasil perkalian dari operan-operannya:

Debug.Log(6 * 3);         // output: 18
Debug.Log(1.5 * 3.5);     // output: 5.25
Debug.Log(0.1m * 24.4m);  // output: 2.44

Operator divisi /

Operator pembagian / membagi operan sebelah kirinya dengan operan sebelah kanannya.

Jika salah satu operan adalah desimal, operan lainnya tidak boleh berupa float maupun double, karena baik float maupun double tidak dapat dikonversi secara implisit ke desimal. Anda harus secara eksplisit mengonversi operan float atau double ke tipe desimal.

Debug.Log(13 / 5);    // output: 2
Debug.Log(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Debug.Log((double)a / b);  // output: 2.6

Debug.Log(16.8f / 4.1f);   // output: 4.097561
Debug.Log(16.8d / 4.1d);   // output: 4.09756097560976
Debug.Log(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Operator sisa %

Operator sisa % menghitung sisa setelah membagi operan sebelah kiri dengan operan sebelah kanannya.

Untuk operan bertipe integer, hasil dari a %b adalah nilai yang dihasilkan oleh a - (a / b) * b

Debug.Log(5 % 4);   // output: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.Log(-5 % -4); // output: -1

Untuk operan desimal, operator sisa % setara dengan operator sisa tipe System.Decimal.

Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 2.8

Operator penjumlahan +

Operator penjumlahan + menghitung jumlah operannya. Anda juga dapat menggunakan operator + untuk penggabungan string dan kombinasi delegasi.

Debug.Log(6 + 5);       // output: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3

Operator pengurangan -

Operator pengurangan - mengurangi operan sebelah kanannya dari operan sebelah kirinya. Anda juga dapat menggunakan operator - untuk penghapusan delegasi.

Debug.Log(48 - 4);      // output: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. Operator perbandingan

Operator perbandingan < (less than), > (greater than), <= (less than or equal), and >= (lebih besar dari atau sama dengan), yang juga dikenal sebagai operator relasional, membandingkan operannya. Operator tersebut didukung oleh semua tipe numerik integral dan floating-point.

Operator kurang dari <

Operator < mengembalikan nilai true jika operan sebelah kirinya lebih kecil dari operan sebelah kanannya, dan false jika tidak.

Debug.Log(8.0 < 6.1);   // output: False
Debug.Log(6.1 < 6.1);   // output: False
Debug.Log(1.0 < 6.1);   // output: True

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

Operator lebih besar dari >

Operator > mengembalikan true jika operan sebelah kirinya lebih besar daripada operan sebelah kanannya, dan false jika tidak.

Debug.Log(8.0 > 6.1);   // output: True
Debug.Log(6.1 > 6.1);   // output: False
Debug.Log(1.0 > 6.1);   // output: False

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Operator kurang dari atau sama dengan <=

Operator <= mengembalikan nilai true jika operan sebelah kirinya kurang dari atau sama dengan operan sebelah kanannya, dan false jika tidak.

Debug.Log(8.0 <= 6.1);   // output: False
Debug.Log(6.1 <= 6.1);   // output: True
Debug.Log(1.0 <= 6.1);   // output: True

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Operator lebih besar atau sama dengan >=

Operator >= mengembalikan nilai true jika operan sebelah kirinya lebih besar atau sama dengan operan sebelah kanannya, dan false jika tidak.

Debug.Log(8.0 >= 6.1);   // output: True
Debug.Log(6.1 >= 6.1);   // output: True
Debug.Log(1.0 >= 6.1);   // output: False

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

3. Operator logika Boolean

Operator berikut melakukan operasi logika dengan operan bool:

Operator unary ! (negasi logika).
Operator biner & (logika AND), | (logika OR), dan ^ (logika eksklusif OR). Operator tersebut selalu mengevaluasi kedua operan.
Operator biner && (logika AND bersyarat) dan || (logika OR bersyarat). Operator tersebut mengevaluasi operan sisi kanan hanya jika diperlukan.

Operator negasi logika !

Operator prefiks unary ! menghitung negasi logis dari operannya. Yaitu, operator ini menghasilkan true, jika operan bernilai false, dan false, jika operan bernilai true.

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

Operator logika AND &

Operator & menghitung logika AND dari operan-operan tersebut. Hasil dari x & y adalah benar jika x dan y keduanya bernilai benar. Jika tidak, hasilnya adalah salah.

Operator & mengevaluasi kedua operan meskipun operan di sebelah kiri bernilai salah, sehingga hasil operasi adalah salah terlepas dari nilai operan di sebelah kanan.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Operator logika eksklusif OR ^

Operator ^ menghitung logika eksklusif OR, yang juga dikenal sebagai logika XOR, dari operan-operannya. Hasil dari x ^ y adalah benar jika x bernilai benar dan y bernilai salah, atau x bernilai salah dan y bernilai benar. Jika tidak, hasilnya adalah salah. Artinya, untuk operan bool, operator ^ menghitung hasil yang sama dengan operator pertidaksamaan !=.

Debug.Log(true ^ true);    // output: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

Operator logika ATAU |

Operator | menghitung logika OR dari operan-operannya. Hasil dari x | y adalah true jika x atau y bernilai true, jika tidak, hasilnya adalah false.

Operator | mengevaluasi kedua operan meskipun operan di sebelah kiri bernilai true, sehingga hasil operasi adalah true tanpa mempedulikan nilai operan di sebelah kanan.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Operator logika AND bersyarat &&

Operator logika AND bersyarat &&, juga dikenal sebagai operator logika AND "short-circuiting", menghitung logika AND dari operannya. Hasil dari x && y adalah benar jika x dan y bernilai benar, jika tidak, hasilnya salah. Jika x bernilai salah, y tidak dievaluasi.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False

bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Operator logika OR bersyarat ||

Operator logika OR bersyarat ||, juga dikenal sebagai operator logika OR "short-circuiting", menghitung logika OR dari operannya. Hasil dari x || y adalah benar jika x atau y bernilai benar. Jika tidak, hasilnya adalah salah. Jika x bernilai benar, y tidak dievaluasi.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True

bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

4. Operator bitwise dan shift

Operator berikut melakukan operasi bitwise atau shift dengan operan tipe numerik integral atau tipe char:

Operator unary ~ (pelengkap bitwise)
Operator shift biner << (left shift) and >> (shift kanan)
Operator biner & (logika AND), | (logika OR), dan ^ (logika eksklusif OR)

Operator pelengkap bitwise ~

Operator ~ menghasilkan pelengkap bitwise dari operannya dengan membalikkan setiap bit.

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

Operator pergeseran kiri <<

Operator << menggeser operan sebelah kirinya ke kiri sejumlah bit yang ditentukan oleh operan sebelah kanannya. Untuk informasi tentang bagaimana operan sebelah kanan menentukan jumlah pergeseran, lihat Jumlah pergeseran pada bagian operator pergeseran.

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

Operator geser kanan >>

Operator >> menggeser operan sebelah kirinya ke kanan sebanyak jumlah bit yang ditentukan oleh operan sebelah kanannya.

uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

Posisi bit kosong tingkat tinggi ditetapkan berdasarkan jenis operan sebelah kiri sebagai berikut:

Jika operan kiri bertipe int atau long, operator geser kanan melakukan pergeseran aritmatika: nilai bit paling signifikan (bit tanda) dari operan kiri disebarkan ke posisi bit kosong orde tinggi. Artinya, posisi bit kosong orde tinggi ditetapkan ke nol jika operan kiri non-negatif dan ditetapkan ke satu jika negatif.

int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Debug.Log($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

Jika operan sebelah kiri bertipe uint atau ulong, operator pergeseran kanan melakukan pergeseran logis: posisi bit kosong tingkat tinggi selalu ditetapkan ke nol.

uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Debug.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

Operator logika AND &

Operator & menghitung logika AND bitwise dari operan integralnya.

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

Operator logika eksklusif OR ^

Operator ^ menghitung logika eksklusif bitwise OR, juga dikenal sebagai logika XOR bitwise, dari operan integralnya.

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

Operator logika ATAU |

Operator | menghitung logika bitwise ATAU dari operan integralnya.

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

5. Operator kesetaraan

Operator == (kesetaraan) dan != (ketidaksetaraan) memeriksa apakah operannya sama atau tidak.

Operator kesetaraan ==

Operator kesetaraan == mengembalikan nilai true jika operannya sama, dan false jika tidak.

int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

Operator pertidaksamaan !=

Operator pertidaksamaan != mengembalikan true jika operannya tidak sama, false jika tidak. Untuk operan tipe bawaan, ekspresi x != y menghasilkan hasil yang sama dengan ekspresi !(x == y).

int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2);  // output: False

object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2);  // output: True

6. Operator lain-lain

Operator lain-lain yang umum adalah ?: untuk pemeriksaan bersyarat, :: untuk mengakses anggota namespace alias, dan $ untuk interpolasi string.

?: operator

Operator kondisional ?:, juga dikenal sebagai operator kondisional terner, mengevaluasi ekspresi Boolean dan mengembalikan hasil dari salah satu dari dua ekspresi, tergantung pada apakah ekspresi Boolean tersebut bernilai benar atau salah, seperti yang ditunjukkan contoh berikut:

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: operator

Gunakan kualifikasi alias namespace:: untuk mengakses anggota namespace yang diberi alias. Anda dapat menggunakan kualifikasi:: hanya di antara dua pengenal. Pengenal sebelah kiri dapat berupa salah satu alias berikut:

Alias namespace yang dibuat dengan menggunakan arahan alias:

using forwinforms = System.Drawing;
using forwpf = System.Windows;

public class Converters
{
    public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}

Alias eksternal.
Alias global, yang merupakan alias namespace global. Namespace global adalah namespace yang berisi namespace dan tipe yang tidak dideklarasikan di dalam namespace bernama. Bila digunakan dengan kualifikasi::, alias global selalu merujuk ke namespace global, meskipun ada alias namespace global yang ditentukan pengguna.

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

$ operator

Karakter khusus $ mengidentifikasi string literal sebagai string yang diinterpolasi. String yang diinterpolasi adalah string literal yang mungkin berisi ekspresi interpolasi. Ketika string yang diinterpolasi diubah menjadi string hasil, item dengan ekspresi interpolasi diganti dengan representasi string dari hasil ekspresi.

Dalam Interpolated Strings, tanda dolar ($) digunakan untuk memberi tahu kompiler C# bahwa string setelahnya harus ditafsirkan sebagai Interpolated String. Tanda kurung kurawal merangkum nilai (variabel) yang akan disertakan dalam teks.

Untuk mengidentifikasi string literal sebagai string yang disisipkan, tambahkan simbol $ di depannya. Anda tidak boleh menggunakan spasi antara $ dan " yang mengawali string literal.

string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.

kesatuan unity3d csharp pemrograman operator microsoft windows dotnet