Unity C# Operator yang Harus Diketahui

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

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

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

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

1. Operator aritmatika

Operator berikut melakukan operasi aritmatika dengan operan tipe numerik:

  • Operator unary ++ (kenaikan), -- (penurunan), + (plus), dan - (minus).
  • Operator biner * (perkalian), / (pembagian), % (sisa), + (penjumlahan), dan - (pengurangan)

Operator Kenaikan++

Operator "add one" (atau ++) berarti += 1, dengan kata lain, ini adalah cara cepat untuk menambahkan satu bilangan bulat ke nilai numerik, tanpa harus mengetikkan kode tambahan. Operator ini dapat ditambahkan sebelum nilai atau sesudah nilai, yang akan menghasilkan perilaku 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 Pengurangan --

Operator "subtract one" adalah kebalikan dari ++ (-= 1), artinya operator ini mengurangkan satu bilangan bulat dari nilai numerik. Itu juga dapat ditambahkan sebelum atau sesudah 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 dan 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 perkalian 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 kirinya dengan operan kanannya.

Jika salah satu operan adalah desimal, operan lainnya tidak boleh berupa float atau double, karena baik float maupun double secara implisit tidak dapat diubah menjadi 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 sisanya setelah membagi operan kirinya dengan operan 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 Sistem.Desimal.
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 kanannya dari operan 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

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

Kurang dari operator <

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

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

Lebih besar dari operator>

Operator > mengembalikan nilai true jika operan kirinya lebih besar dari operan kanannya, dan false jika sebaliknya.

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 kirinya kurang dari atau sama dengan operan kanannya, dan false jika sebaliknya.

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 dari atau sama dengan >=

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

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:

  • Unari! (negasi logis) operator.
  • Biner & (logis DAN), | (logis OR), dan ^ (logis eksklusif OR). Operator tersebut selalu mengevaluasi kedua operan.
  • Biner && (logis bersyarat DAN) dan || (logika bersyarat ATAU) operator. Operator tersebut mengevaluasi operan sebelah kanan hanya jika diperlukan.

Operator negasi logis!

Awalan unary ! operator menghitung negasi logis dari operannya. Artinya, menghasilkan nilai benar jika operan bernilai salah, dan salah jika operan bernilai benar.

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

Logis DAN operator &

Operator & menghitung logika AND dari operannya. Hasil x & y benar jika x dan y bernilai benar. Jika tidak, hasilnya salah.

Operator & mengevaluasi kedua operan meskipun operan sebelah kiri bernilai salah, sehingga hasil operasinya salah terlepas dari nilai operan 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 OR eksklusif yang logis ^

Operator ^ menghitung logika eksklusif OR, juga dikenal sebagai XOR logis, dari operannya. Hasil dari x ^ y bernilai benar jika x bernilai benar dan y bernilai salah, atau x bernilai salah dan y bernilai benar. Kalau tidak, hasilnya 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 OR |

| operator menghitung logika OR dari operannya. Hasil dari x | y benar jika x atau y bernilai benar, jika tidak, hasilnya salah.

The | operator mengevaluasi kedua operan meskipun operan sebelah kiri bernilai benar, sehingga hasil operasi tetap benar, berapa pun nilai operan 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 AND logis bersyarat &&

Operator logika AND bersyarat &&, juga dikenal sebagai operator logika AND "short-circuiting", menghitung logika AND dari operannya. Hasil x && y benar jika x dan y bernilai benar, jika tidak maka 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 x || y benar jika x atau y bernilai benar. Kalau tidak, hasilnya 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).
  • Biner & (logis DAN), | (logis OR), dan ^ (logis eksklusif OR).

Operator komplemen bitwise ~

Operator ~ menghasilkan komplemen 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 shift kiri <<

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

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 shift kanan >>

Operator >> menggeser operan kirinya ke kanan sesuai jumlah bit yang ditentukan oleh operan 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 orde tinggi diatur berdasarkan jenis operan sebelah kiri sebagai berikut:

  • Jika operan sebelah kiri bertipe int atau panjang, operator pergeseran ke kanan melakukan pergeseran aritmatika: nilai bit paling signifikan (bit tanda) dari operan sebelah kiri disebarkan ke bit kosong orde tinggi posisi. Artinya, posisi bit kosong orde tinggi disetel ke nol jika operan sebelah kiri non-negatif dan disetel 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 orde tinggi selalu disetel 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

Logis DAN operator &

Operator & menghitung logika bitwise AND 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 OR eksklusif yang logis ^

Operator ^ menghitung logika bitwise eksklusif OR, juga dikenal sebagai XOR logika 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 OR |

| operator menghitung logika bitwise OR 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 persamaan ==

Operator kesetaraan == mengembalikan nilai benar jika operannya sama, dan salah jika sebaliknya.

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 nilai true jika operannya tidak sama, dan 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 ternary, mengevaluasi ekspresi Boolean dan mengembalikan hasil salah satu dari dua ekspresi tersebut, bergantung pada apakah ekspresi Boolean bernilai benar atau salah, seperti yang ditunjukkan oleh contoh berikut:

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

:: operator

Gunakan kualifikasi alias namespace:: untuk mengakses anggota namespace alias. Anda dapat menggunakan kualifikasi:: hanya di antara dua pengidentifikasi. Pengidentifikasi sebelah kiri dapat berupa salah satu alias berikut:

  • Alias ​​namespace dibuat dengan direktif alias using:
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. Saat digunakan dengan kualifikasi::, alias global selalu mereferensikan 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 diselesaikan menjadi string hasil, item dengan ekspresi interpolasi digantikan oleh representasi string dari hasil ekspresi.

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

Untuk mengidentifikasi string literal sebagai string yang diinterpolasi, tambahkan simbol $ di awal. Anda tidak boleh memiliki spasi antara $ dan " yang memulai 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.
unityunity3dcsharppemrogramanoperatormicrosoftwindowsdotnet
Artikel yang Disarankan
Bagaimana Menjadi Programmer yang Lebih Baik di Unity
Menerapkan Operasi Aritmatika Dasar pada Unity Code
Memahami Fungsi dan Panggilan Metode
Pengantar Bahasa Scripting Unity C#
Pengenalan Variabel dan Tipe Data dalam Pemrograman di Unity
Menambahkan Entri Pemain ke Mobil di Unity
Membuat Pengontrol Turret di Unity
Postingan Lainnya »
Artikel Populer
Menerapkan Input Keyboard dan Mouse di Unity
Tutorial Membuka Pintu dengan Kunci dalam Unity
Mengkodekan Sistem Inventaris Sederhana Dengan UI Drag and Drop di Unity
Pengenalan Variabel dan Tipe Data dalam Pemrograman di Unity
Pengantar Bahasa Scripting Unity C#
Buat ScriptableObjects di Unity
Menggunakan Loop (Untuk, Sementara) untuk Mengulangi Eksekusi Kode