Unity C#'ta Bilinmesi Gereken Operatörler

Unity geliştiricilere işlevsellik açısından birçok "heavy-lifting" sağlayan ve onların tamamen geliştirme sürecine odaklanmasına olanak tanıyan bir oyun motorudur. Ana programlama dili olarak C#'ü kullanır.

Herhangi bir programlama dilinde olduğu gibi, C# da bir dizi özel işlev, tür, sınıf, kitaplık vb.'den oluşur, ancak aynı zamanda her birinin kendi işlevi olan özel sembollerin (operatörlerin) bir listesi de vardır. Bu yazıda bu sembolleri listeleyeceğim ve ne işe yaradıklarını açıklayacağım, böylece bir dahaki sefere bir betiği açtığınızda her bir parçanın ne anlama geldiğini hızlı bir şekilde anlayabileceksiniz.

C#'taki operatörler, işlenenler üzerinde bazı eylemleri gerçekleştiren bazı özel sembollerdir.

C#'te 6 tür yerleşik operatör vardır: Aritmetik operatörler, Karşılaştırma operatörleri, Boole mantıksal operatörleri, Bit bazında ve kaydırma operatörleri, Eşitlik operatörleri ve Çeşitli operatörler. Hepsini bilmek sizi anında daha iyi bir programcı yapacaktır.

1. Aritmetik operatörler

Aşağıdaki operatörler sayısal türdeki işlenenlerle aritmetik işlemler gerçekleştirir:

• Tekli ++ (artırma), -- (azaltma), + (artı) ve - (eksi) operatörleri
• İkili * (çarpma), / (bölme), % (kalan), + (toplama) ve - (çıkarma) operatörleri

Artış Operatörü++

"add one" operatörü (veya ++) += 1 anlamına gelir; başka bir deyişle, fazladan kod yazmaya gerek kalmadan sayısal bir değere bir tamsayı eklemenin hızlı bir yoludur. Bu operatör değerden önce veya değerden sonra eklenebilir; bu da farklı bir davranışa neden olur:

//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

Azaltma Operatörü --

"subtract one" operatörü ++ (-= 1) ifadesinin tersidir, yani sayısal bir değerden bir tamsayı çıkarır. Ayrıca bir değerin önüne veya arkasına da eklenebilir:

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

Tekli + ve - operatörleri

Tekli + operatörü, işleneninin değerini döndürür ve tekli - operatörü, işleneninin sayısal olumsuzluğunu hesaplar.

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

Çarpma operatörü *

Çarpma operatörü *, işlenenlerinin çarpımını hesaplar:

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

Bölüm operatörü /

Bölme operatörü /, sol taraftaki işleneni sağ taraftaki işlenene böler.

İşlenenlerden biri ondalık sayıysa, başka bir işlenen ne kayan nokta ne de çift olamaz, çünkü ne kayan nokta ne de çift dolaylı olarak ondalık sayıya dönüştürülebilir. Kayan noktalı veya çift işleneni açıkça ondalık türe dönüştürmeniz gerekir.

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

Kalan operatör %'si

Kalan operatörü %, sol taraftaki işleneni sağ taraftaki işlenene böldükten sonra kalanı hesaplar.

• Tam sayı türlerinin işlenenleri için a % b'nin sonucu, a - (a / b) * b tarafından üretilen değerdir.

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

• Ondalık işlenenler için, kalan işleç %, System.Decimal türünün kalan işlecine eşdeğerdir.

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

Toplama operatörü +

Toplama operatörü +, işlenenlerinin toplamını hesaplar. Ayrıca + operatörünü dize birleştirme ve temsilci birleşimi için de kullanabilirsiniz.

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

Çıkarma operatörü -

Çıkarma operatörü - sağ taraftaki işleneni sol taraftaki işlenenden çıkarır. Temsilciyi kaldırmak için - operatörünü de kullanabilirsiniz.

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

2. Karşılaştırma operatörleri

İlişkisel olarak da bilinen < (less than), > (greater than), <= (less than or equal), and >= (büyük veya eşittir) karşılaştırması, operatörlerin işlenenlerini karşılaştırır. Bu operatörler tüm integral ve kayan noktalı sayısal türler tarafından desteklenir.

Operatörden daha az <

< operatörü, sol taraftaki işlenen sağ taraftaki işlenenden küçükse doğru, aksi halde yanlış değerini döndürür.

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

Operatörden büyük >

> operatörü, eğer sol taraftaki işlenen sağ taraftaki işlenenden büyükse true değerini, aksi takdirde false değerini döndürür.

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

Küçük veya eşittir operatörü <=

<= operatörü, sol taraftaki işlenen sağ taraftaki işlenenden küçük veya ona eşitse doğru, aksi halde yanlış değerini döndürür.

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

Büyüktür veya eşittir operatörü >=

>= operatörü, sol taraftaki işlenen sağ taraftaki işlenenden büyük veya ona eşitse doğru, aksi halde yanlış değerini döndürür.

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. Boole mantıksal operatörleri

Aşağıdaki operatörler bool işlenenleriyle mantıksal işlemler gerçekleştirir:

• Tekli! (mantıksal olumsuzlama) operatörü.
• İkili & (mantıksal VE), | (mantıksal OR) ve ^ (mantıksal özel OR) operatörleri. Bu operatörler her zaman her iki işleneni de değerlendirir.
• İkili && (koşullu mantıksal AND) ve || (koşullu mantıksal VEYA) operatörleri. Bu operatörler sağ taraftaki işleneni yalnızca gerekli olması durumunda değerlendirir.

Mantıksal olumsuzlama operatörü !

Tekli önek! operatörü, işleneninin mantıksal olumsuzluğunu hesaplar. Yani, işlenen yanlış olarak değerlendirilirse doğruyu, işlenen doğru olarak değerlendirilirse yanlış değerini üretir.

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

Mantıksal VE operatörü &

& operatörü, işlenenlerinin mantıksal VE değerini hesaplar. Hem x hem de y doğru olarak değerlendirilirse x & y'nin sonucu doğrudur. Aksi halde sonuç yanlıştır.

Sol taraftaki işlenen yanlış olarak değerlendirilse bile & operatörü her iki işleneni de değerlendirir, böylece sağ taraftaki işlenenin değeri ne olursa olsun işlem sonucu yanlış olur.

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

Mantıksal özel VEYA operatörü ^

^ operatörü, işlenenlerinin mantıksal XOR'u olarak da bilinen mantıksal özel VEYA'sını hesaplar. x doğru olarak değerlendirilirse ve y yanlış olarak değerlendirilirse veya x yanlış olarak değerlendirilirse ve y doğru olarak değerlendirilirse x ^ y'nin sonucu doğrudur. Aksi halde sonuç yanlıştır. Yani, bool işlenenleri için ^ operatörü, eşitsizlik operatörü != ile aynı sonucu hesaplar.

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

Mantıksal VEYA operatörü |

| operatörü, işlenenlerinin mantıksal VEYA değerini hesaplar. x'in sonucu | x veya y doğru olarak değerlendirilirse y doğrudur, aksi takdirde sonuç yanlıştır.

| Operatör, sol taraftaki işlenen doğru olarak değerlendirilse bile her iki işleneni de değerlendirir, böylece işlem sonucu sağ taraftaki işlenenin değerinden bağımsız olarak doğrudur.

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

Koşullu mantıksal AND operatörü &&

"short-circuiting" mantıksal AND operatörü olarak da bilinen koşullu mantıksal AND operatörü &&, işlenenlerinin mantıksal AND değerini hesaplar. Hem x hem de y doğru olarak değerlendirilirse x && y'nin sonucu doğrudur, aksi halde sonuç yanlıştır. X yanlış olarak değerlendirilirse y değerlendirilmez.

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

Koşullu mantıksal VEYA operatörü ||

"short-circuiting" mantıksal OR operatörü olarak da bilinen koşullu mantıksal OR operatörü ||, işlenenlerinin mantıksal OR'sini hesaplar. x'in sonucu || Eğer x veya y doğru olarak değerlendirilirse y doğrudur. Aksi halde sonuç yanlıştır. Eğer x doğru olarak değerlendirilirse, y değerlendirilmez.

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. Bitsel ve kaydırma operatörleri

Aşağıdaki operatörler, integral sayısal türlerdeki veya karakter türündeki işlenenlerle bit düzeyinde veya kaydırma işlemleri gerçekleştirir:

• Tekli ~ (bitsel tamamlayıcı) operatörü
• İkili << (left shift) and >> (sağa kaydırma) kaydırma operatörleri
• İkili & (mantıksal VE), | (mantıksal OR) ve ^ (mantıksal özel OR) operatörleri

Bitsel tamamlayıcı operatörü ~

~ operatörü, her bir biti tersine çevirerek işleneninin bit bazında tamamlayıcısını üretir.

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

Sola kaydırma operatörü <<

<< operatörü, sol işlenenini, sağ işleneninin tanımladığı bit sayısı kadar sola kaydırır. Sağ taraftaki işlenenin kaydırma sayısını nasıl tanımladığı hakkında bilgi için kaydırma operatörleri bölümünün Kaydırma sayısı bölümüne bakın.

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

Sağa kaydırma operatörü >>

>> operatörü, sol taraftaki işleneni, sağ taraftaki işlenen tarafından tanımlanan bit sayısı kadar sağa kaydırır.

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

Yüksek dereceli boş bit konumları, sol taraftaki işlenenin türüne göre aşağıdaki gibi ayarlanır:

• Sol taraftaki işlenen int veya long türündeyse, sağa kaydırma operatörü aritmetik bir kaydırma gerçekleştirir: sol taraftaki işlenenin en anlamlı bitinin (işaret biti) değeri yüksek dereceli boş bit'e yayılır pozisyonlar. Yani, sol taraftaki işlenen negatif değilse yüksek dereceli boş bit konumları sıfıra, negatifse bire ayarlanır.

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

• Sol taraftaki işlenen uint veya ulong türündeyse sağa kaydırma operatörü mantıksal bir kaydırma gerçekleştirir: yüksek dereceli boş bit konumları her zaman sıfıra ayarlanır.

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

Mantıksal VE operatörü &

& operatörü, integral işlenenlerinin bit düzeyinde mantıksal VE değerini hesaplar.

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

Mantıksal özel VEYA operatörü ^

^ operatörü, integral işlenenlerinin bit düzeyinde mantıksal özel OR'sini (bit düzeyinde mantıksal XOR olarak da bilinir) hesaplar.

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

Mantıksal VEYA operatörü |

| operatörü, integral işlenenlerinin bit düzeyinde mantıksal VEYA'sını hesaplar.

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

5. Eşitlik operatörleri

== (eşitlik) ve != (eşitsizlik) operatörleri, işlenenlerinin eşit olup olmadığını kontrol eder.

Eşitlik operatörü ==

Eşitlik operatörü ==, işlenenleri eşitse doğru, değilse yanlış değerini döndürür.

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

Eşitsizlik operatörü !=

Eşitsizlik operatörü !=, işlenenleri eşit değilse doğru, değilse yanlış değerini döndürür. Yerleşik türlerin işlenenleri için x != y ifadesi, !(x == y) ifadesiyle aynı sonucu üretir.

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. Çeşitli operatörler

Yaygın olarak kullanılan çeşitli operatörler şunlardır: koşullu kontroller için ?:, takma adlı bir ad alanının bir üyesine erişim için:: ve dize enterpolasyonu için $.

?: Şebeke

Üçlü koşullu operatör olarak da bilinen koşullu operatör ?:, bir Boolean ifadesini değerlendirir ve aşağıdaki örnekte gösterildiği gibi Boolean ifadesinin doğru veya yanlış olarak değerlendirilmesine bağlı olarak iki ifadeden birinin sonucunu döndürür:

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

:: Şebeke

Takma ad verilmiş bir ad alanının bir üyesine erişmek için ad alanı takma ad niteleyicisini:: kullanın.:: niteleyicisini yalnızca iki tanımlayıcı arasında kullanabilirsiniz. Sol taraftaki tanımlayıcı aşağıdaki takma adlardan herhangi biri olabilir:

• Bir takma ad kullanma yönergesiyle oluşturulan bir ad alanı takma adı:

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);
}

• Harici bir takma ad.
• Genel ad alanı takma adı olan genel takma ad. Global ad alanı, adlandırılmış bir ad alanı içinde bildirilmeyen ad alanlarını ve türleri içeren ad alanıdır.:: niteleyicisiyle birlikte kullanıldığında, kullanıcı tanımlı genel ad alanı takma adı olsa bile, genel takma ad her zaman genel ad alanına başvurur.

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

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

$ operatörü

$ özel karakteri, bir dize değişmez değerini enterpolasyonlu bir dize olarak tanımlar. Enterpolasyonlu dize, enterpolasyon ifadeleri içerebilen bir dize değişmezidir. Enterpolasyonlu bir dize bir sonuç dizesine çözümlendiğinde, enterpolasyon ifadelerine sahip öğelerin yerini, ifade sonuçlarının dize temsilleri alır.

Interpolated Strings'de dolar işareti ($), C# derleyicisine, onu takip eden dizenin Interpolated String olarak yorumlanacağını bildirmek için kullanılır. Kıvrımlı parantezler, metne dahil edilecek değerleri (değişkenlerin) içine alır.

Bir dize değişmez değerini enterpolasyonlu bir dize olarak tanımlamak için, bunun başına $ sembolünü ekleyin. Bir dize değişmezini başlatan $ ile " arasında boşluk olamaz.

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.