Operatorii Unity C# trebuie să cunoască

Unity este un motor de joc care face o mulțime de "heavy-lifting" pentru dezvoltatori în ceea ce privește funcționalitatea și le permite să se concentreze în întregime pe procesul de dezvoltare. Utilizează C# ca limbaj de programare principal.

Ca și în cazul oricărui limbaj de programare, C# constă dintr-o serie de funcții speciale, tipuri, clase, biblioteci etc., dar are și o listă de simboluri (operatori) speciale, fiecare având propria funcție. În această postare, voi enumera acele simboluri și voi explica ce fac ele, astfel încât data viitoare când deschideți un script, veți putea înțelege rapid ce înseamnă fiecare parte.

Operatorii în C# sunt niște simboluri speciale care efectuează anumite acțiuni asupra operanzilor.

În C#, există 6 tipuri de operatori încorporați: Operatori aritmetici, Operatori de comparație, Operatori logici booleeni, Operatori pe biți și de deplasare, Operatori de egalitate și Operatori diversi. Cunoașterea lor pe toate te va face instantaneu un programator mai bun.

1. Operatori aritmetici

Următorii operatori efectuează operații aritmetice cu operanzi de tipuri numerice:

Operatori unari ++ (incrementare), -- (scădere), + (plus) și - (minus).
Operatori binari * (înmulțire), / (diviziune), % (restul), + (adunare) și - (scădere)

Increment Operator++

Operatorul "add one" (sau ++) înseamnă += 1, cu alte cuvinte, este o modalitate rapidă de a adăuga un număr întreg la o valoare numerică, fără a fi nevoie să tastați cod suplimentar. Acest operator poate fi adăugat fie înainte de valoare, fie după valoare, ceea ce ar duce la un comportament diferit:

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

Decrement Operator --

Operatorul "subtract one" este opusul lui ++ (-= 1), ceea ce înseamnă că scade un număr întreg dintr-o valoare numerică. De asemenea, poate fi adăugat înainte sau după o valoare:

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

Operatori unari + și -

Operatorul unar + returnează valoarea operandului său, iar operatorul unar - calculează negația numerică a operandului său.

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 de multiplicare *

Operatorul de multiplicare * calculează produsul înmulțit al operanzilor săi:

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

Operatorul de împărțire / își împarte operandul din stânga la operandul din dreapta.

Dacă unul dintre operanzi este zecimal, un alt operand nu poate fi nici float, nici double, deoarece nici float, nici double nu este implicit convertibil în zecimal. Trebuie să convertiți în mod explicit operandul float sau dublu la tipul zecimal.

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

Restul operatorului %

Operatorul rest % calculează restul după ce împarte operandul din stânga la operandul din dreapta.

Pentru operanzii de tipuri întregi, rezultatul a % b este valoarea produsă de 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

Pentru operanzii zecimali, operatorul rest % este echivalent cu operatorul rest al tipului 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 de adaos +

Operatorul de adunare + calculează suma operanzilor săi. De asemenea, puteți utiliza operatorul + pentru concatenarea șirurilor și combinarea delegaților.

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

Operatorul de scădere -

Operatorul de scădere - scade operandul său din dreapta din operandul din stânga. De asemenea, puteți utiliza operatorul - pentru eliminarea delegatului.

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

2. Operatori de comparare

Comparația < (less than), > (greater than), <= (less than or equal), and >= (mai mare sau egală), cunoscută și ca relațională, operatorii își compară operanzii. Acești operatori sunt acceptați de toate tipurile numerice integrale și în virgulă mobilă.

Mai puțin decât operatorul <

Operatorul < returnează adevărat dacă operandul său din stânga este mai mic decât operandul din dreapta, fals în caz contrar.

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

Mai mare decât operatorul >

Operatorul > returnează true dacă operandul său din stânga este mai mare decât operandul din dreapta, fals în caz contrar.

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

Operatorul mai mic sau egal <=

Operatorul <= returnează adevărat dacă operandul său din stânga este mai mic sau egal cu operandul din dreapta, fals în caz contrar.

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 mai mare sau egal >=

Operatorul >= returnează adevărat dacă operandul său din stânga este mai mare sau egal cu operandul din dreapta, fals în caz contrar.

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. Operatori logici booleeni

Următorii operatori efectuează operații logice cu operanzi bool:

Unar! operator (negație logică).
Binar & (ȘI logic), | (SAU logic) și ^ (SAU logic exclusiv). Acei operatori evaluează întotdeauna ambii operanzi.
&& binar (ȘI logic condiționat) și || operatori (SAU logic condiționat). Acei operatori evaluează operandul din dreapta doar dacă este necesar.

Operator logic de negație!

Prefixul unar ! operatorul calculează negația logică a operandului său. Adică produce adevărat, dacă operandul este evaluat ca fals, și fals, dacă operandul este evaluat ca adevărat.

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

operator logic și

Operatorul & calculează AND-ul logic al operanzilor săi. Rezultatul lui x & y este adevărat dacă atât x, cât și y se evaluează drept adevărat. În caz contrar, rezultatul este fals.

Operatorul & evaluează ambii operanzi chiar dacă operandul din stânga este fals, astfel încât rezultatul operației este fals indiferent de valoarea operandului din dreapta.

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

Operatorul SAU exclusiv logic ^

Operatorul ^ calculează OR exclusiv logic, cunoscut și ca XOR logic, al operanzilor săi. Rezultatul lui x ^ y este adevărat dacă x evaluează adevărat și y evaluează fals, sau x evaluează fals și y evaluează adevărat. În caz contrar, rezultatul este fals. Adică, pentru operanzii bool, operatorul ^ calculează același rezultat ca și operatorul de inegalitate !=.

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 logic SAU |

| operatorul calculează OR logic al operanzilor săi. Rezultatul lui x | y este adevărat dacă fie x, fie y evaluează drept adevărat, în caz contrar, rezultatul este fals.

The | operatorul evaluează ambii operanzi chiar dacă operandul din stânga este adevărat, astfel încât rezultatul operației este adevărat, indiferent de valoarea operandului din dreapta.

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

Operatorul AND logic condiționat &&

Operatorul ȘI logic condiționat &&, cunoscut și ca operatorul ȘI logic "short-circuiting", calculează ȘI logic al operanzilor săi. Rezultatul lui x && y este adevărat dacă atât x, cât și y evaluează drept adevărat, în caz contrar, rezultatul este fals. Dacă x este evaluat ca fals, y nu este evaluat.

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

Operatorul SAU logic condiționat ||

Operatorul OR logic condiționat ||, cunoscut și sub numele de operatorul OR logic "short-circuiting", calculează OR logic al operanzilor săi. Rezultatul lui x || y este adevărat dacă fie x, fie y evaluează drept adevărat. În caz contrar, rezultatul este fals. Dacă x este evaluat la adevărat, y nu este evaluat.

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. Operatori pe biți și deplasare

Următorii operatori efectuează operații pe biți sau deplasare cu operanzi de tipuri numerice integrale sau de tip char:

Operator unar ~ (complement pe biți).
Operatori binari << (left shift) and >> (schimba la dreapta).
Binar & (ȘI logic), | (SAU logic) și ^ (SAU logic exclusiv).

Operatorul complement pe biți ~

Operatorul ~ produce un complement pe bit al operandului său inversând fiecare bit.

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

Operatorul de schimbare la stânga <<

Operatorul << își mută operandul din stânga la stânga cu numărul de biți definit de operandul din dreapta. Pentru informații despre modul în care operandul din dreapta definește numărul de schimburi, consultați secțiunea Numărul de schimburi al operatorilor de schimbare.

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 de schimbare la dreapta >>

Operatorul >> își mută operandul din stânga la dreapta cu numărul de biți definit de operandul din dreapta.

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

Pozițiile de ordin superior ale biților gol sunt setate pe baza tipului de operand din stânga, după cum urmează:

Dacă operandul din stânga este de tip int sau long, operatorul de deplasare la dreapta efectuează o schimbare aritmetică: valoarea bitului cel mai semnificativ (bitul de semn) al operandului din stânga este propagată la bitul gol de ordin superior. pozitii. Adică, pozițiile de biți goale de ordin înalt sunt setate la zero dacă operandul din stânga este nenegativ și setat la unu dacă este negativ.

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

Dacă operandul din stânga este de tip uint sau ulong, operatorul de deplasare la dreapta efectuează o deplasare logică: pozițiile biților goale de ordin înalt sunt întotdeauna setate la zero.

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 logic și

Operatorul & calculează AND logic pe biți al operanzilor săi integrali.

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

Operatorul SAU exclusiv logic ^

Operatorul ^ calculează OR logic exclusiv pe biți, cunoscut și ca XOR logic pe biți, al operanzilor săi integrali.

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

Operator logic SAU |

| operatorul calculează OR logic pe biți al operanzilor săi integrali.

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

5. Operatori de egalitate

Operatorii == (egalitatea) și != (inegalitatea) verifică dacă operanzii lor sunt egali sau nu.

Operator de egalitate ==

Operatorul de egalitate == returnează adevărat dacă operanzii săi sunt egali, fals în caz contrar.

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 de inegalitate !=

Operatorul de inegalitate != returnează adevărat dacă operanzii săi nu sunt egali, fals în caz contrar. Pentru operanzii tipurilor încorporate, expresia x != y produce același rezultat ca și expresia !(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. Operatori diverși

Operatorii diverși obișnuiți sunt ?: pentru verificări condiționate, :: pentru accesarea unui membru al unui spațiu de nume alias și $ pentru interpolarea șirurilor.

?: operator

Operatorul condiționat ?:, cunoscut și sub numele de operatorul condițional ternar, evaluează o expresie booleană și returnează rezultatul uneia dintre cele două expresii, în funcție de faptul dacă expresia booleană este evaluată la adevărat sau fals, după cum arată următorul exemplu:

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

:: operator

Utilizați calificativul alias al spațiului de nume:: pentru a accesa un membru al unui spațiu de nume alias. Puteți utiliza calificativul:: numai între doi identificatori. Identificatorul din stânga poate fi oricare dintre următoarele pseudonime:

Un alias de spațiu de nume creat cu o directivă de alias folosind:

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

Un alias extern.
Aliasul global, care este aliasul global al spațiului de nume. Spațiul de nume global este spațiul de nume care conține spații de nume și tipuri care nu sunt declarate în interiorul unui spațiu de nume numit. Când este utilizat cu calificativul::, aliasul global face întotdeauna referire la spațiul de nume global, chiar dacă există alias-ul de spațiu de nume global definit de utilizator.

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 $

Caracterul special $ identifică un literal șir ca șir interpolat. Un șir interpolat este un șir literal care ar putea conține expresii de interpolare. Când un șir interpolat este rezolvat într-un șir de rezultat, elementele cu expresii de interpolare sunt înlocuite cu reprezentările șir ale rezultatelor expresiei.

În Interpolated Strings, semnul dolar ($) este folosit pentru a spune compilatorului C# că șirul care îl urmează trebuie interpretat ca un șir interpolat. Acoladele încapsulează valorile (ale variabilelor) de inclus în text.

Pentru a identifica un șir literal ca șir interpolat, adăugați-l înainte simbolul $. Nu puteți avea niciun spațiu alb între $ și „ care începe un literal șir.

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.

unity unity3d csharp programare operatori microsoft windows dotnet