Unity C# Must-Know Operatører

Unity er en spilmotor, der gør en masse "heavy-lifting" for udviklere med hensyn til funktionalitet og lader dem fokusere helt på udviklingsprocessen. Det bruger C# som det primære programmeringssprog.

Som med ethvert programmeringssprog består C# af en række specielle funktioner, typer, klasser, biblioteker osv., men det har også en liste over specielle symboler (operatorer), der hver har sin egen funktion. I dette indlæg vil jeg liste disse symboler og vil forklare, hvad de gør, så næste gang du åbner et script, vil du hurtigt kunne forstå, hvad hver del betyder.

Operatorer i C# er nogle specielle symboler, der udfører nogle handlinger på operander.

I C# er der 6 typer indbyggede operatorer: Aritmetiske operatorer, sammenligningsoperatorer, boolske logiske operatorer, Bitwise og shift operatorer, Equality operatorer og Diverse operatorer. At kende dem alle vil med det samme gøre dig til en bedre programmør.

1. Aritmetiske operatorer

Følgende operatorer udfører aritmetiske operationer med operander af numeriske typer:

Unære ++ (inkrementer), -- (reducerer), + (plus) og - (minus) operatorer
Binære * (multiplikation), / (division), % (rest), + (addition) og - (subtraktion) operatorer

Øg operatør++

Operatoren "add one" (eller ++) betyder += 1, med andre ord er det en hurtig måde at tilføje et heltal til en numerisk værdi uden at skulle indtaste ekstra kode. Denne operator kan tilføjes enten før værdien eller efter værdien, hvilket ville resultere i en anden adfærd:

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

Reducer operatør --

Operatoren "subtract one" er det modsatte af ++ (-= 1), hvilket betyder, at den trækker et heltal fra en numerisk værdi. Det kan også tilføjes før eller efter en værdi:

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

Unære + og - operatorer

Operatoren unær + returnerer værdien af dens operand, og unær - operatoren beregner den numeriske negation af dens operande.

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

Multiplikationsoperator *

Multiplikationsoperatoren * beregner det multiplicerede produkt af dens operander:

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

Divisionsoperatør /

Divisionsoperatøren / deler sin venstre operand med sin højre operand.

Hvis en af operanderne er decimal, kan en anden operand hverken være float eller double, fordi hverken float eller double implicit kan konverteres til decimal. Du skal eksplicit konvertere float- eller dobbeltoperanden til decimaltypen.

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

Resten operatør %

Den resterende operator % beregner resten efter at have divideret dens venstre operand med dens højre operand.

For operanderne af heltalstyper er resultatet af a % b værdien produceret af 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

For decimaloperanderne svarer den resterende operator % til den resterende operator af typen 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

Tilføjelsesoperator +

Adderingsoperatoren + beregner summen af sine operander. Du kan også bruge operatoren + til strengsammenkædning og delegeret kombination.

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

Subtraktionsoperatør -

Subtraktionsoperatoren - trækker sin højre operand fra sin venstre operand. Du kan også bruge operatoren - til at fjerne delegerede.

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

2. Sammenligningsoperatører

< (less than), > (greater than), <= (less than or equal), and >= (større end eller lig med) sammenligningen, også kendt som relationel, sammenligner deres operander. Disse operatører understøttes af alle integrale og flydende numeriske typer.

Mindre end operatør <

Operatoren < returnerer sand, hvis dens venstre operand er mindre end dens højre operand, ellers falsk.

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

Større end operator >

Operatoren > returnerer sand, hvis dens venstre operand er større end dens højre operand, ellers falsk.

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

Mindre end eller lig operator <=

Operatoren <= returnerer sand, hvis dens venstre operand er mindre end eller lig med dens højre operand, ellers falsk.

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

Større end eller lig operator >=

Operatoren >= returnerer sand, hvis dens venstre operand er større end eller lig med dens højre operand, ellers falsk.

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. Booleske logiske operatorer

Følgende operatorer udfører logiske operationer med booloperander:

Unært! (logisk negation) operatør.
Binær & (logisk OG), | (logisk OR) og ^ (logisk eksklusiv OR) operatorer. Disse operatører evaluerer altid begge operander.
Binær && (betinget logisk OG) og || (betinget logisk ELLER) operatorer. Disse operatører evaluerer den højre operand kun, hvis det er nødvendigt.

Logisk negationsoperatør!

Det unære præfiks! operatoren beregner den logiske negation af sin operand. Det vil sige, at den producerer sand, hvis operanden evalueres til falsk, og falsk, hvis operanden evalueres til sand.

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

Logisk OG operator &

Operatoren & beregner den logiske OG af dens operander. Resultatet af x & y er sandt, hvis både x og y evalueres til sand. Ellers er resultatet falsk.

&-operatoren evaluerer begge operander, selvom venstre-operand evalueres til falsk, så operationsresultatet er falsk uanset værdien af højre-operand.

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

Logisk eksklusiv ELLER-operator ^

Operatoren ^ beregner den logiske eksklusive OR, også kendt som den logiske XOR, for dens operander. Resultatet af x ^ y er sandt, hvis x evalueres til sandt, og y evalueres til falsk, eller x evalueres til falsk, og y evalueres til sandt. Ellers er resultatet falsk. Det vil sige, at for bool-operanderne beregner ^-operatoren det samme resultat som ulighedsoperatoren !=.

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

Logisk ELLER-operator |

Den | operatoren beregner den logiske ELLER af sine operander. Resultatet af x | y er sand, hvis enten x eller y evalueres til sand, ellers er resultatet falsk.

Den | operator evaluerer begge operander, selvom den venstre operand evalueres til sand, så operationsresultatet er sandt uanset værdien af højre operanden.

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

Betinget logisk OG-operator &&

Den betingede logiske AND-operator &&, også kendt som den "short-circuiting" logiske AND-operator, beregner den logiske AND af dens operander. Resultatet af x && y er sandt, hvis både x og y evalueres til sand, ellers er resultatet falsk. Hvis x evalueres til falsk, evalueres y ikke.

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

Betinget logisk ELLER-operator ||

Den betingede logiske ELLER-operator ||, også kendt som "short-circuiting" logiske ELLER-operator, beregner den logiske ELLER for dens operander. Resultatet af x || y er sand, hvis enten x eller y evalueres til sand. Ellers er resultatet falsk. Hvis x evalueres til sand, evalueres y ikke.

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. Bitvise og skiftende operatører

Følgende operatorer udfører bitvise eller skiftende operationer med operander af de integrale numeriske typer eller char-typen:

Unær ~ (bitvist komplement) operator
Binære << (left shift) and >> (højre skift) skiftoperatorer
Binær & (logisk OG), | (logisk OR) og ^ (logisk eksklusiv OR) operatorer

Bitvis komplementoperator ~

Operatoren ~ producerer et bitvis komplement af sin operand ved at vende hver bit.

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

Venstre-skift operator <<

Operatoren << flytter sin venstre operand til venstre med det antal bit, der er defineret af dens højre operand. For information om, hvordan højrehåndsoperand definerer skifttælleren, se afsnittet Skifttæller for skiftoperatører.

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

Højreskiftsoperatør >>

>> operatoren flytter sin venstre operand til højre med antallet af bit defineret af sin højre operand.

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

De tomme bitpositioner af høj orden indstilles baseret på typen af venstre operand som følger:

Hvis venstre operand er af typen int eller long, udfører højreskiftoperatoren et aritmetisk skift: værdien af den mest signifikante bit (fortegnsbitten) af venstre operanden forplantes til den tomme bit af høj orden stillinger. Det vil sige, at de tomme bitpositioner af høj orden sættes til nul, hvis den venstre operande er ikke-negativ, og sættes til én, hvis den er 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

Hvis den venstre operand er af typen uint eller ulong, udfører højreskiftsoperatoren et logisk skift: de tomme bitpositioner af høj orden er altid sat til nul.

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

Logisk OG operator &

Operatoren & beregner den bitvise logiske OG af dens integraloperander.

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

Logisk eksklusiv ELLER-operator ^

Operatoren ^ beregner den bitvise logiske eksklusive ELLER, også kendt som den bitvise logiske XOR, af dens integraloperander.

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

Logisk ELLER-operator |

Den | operatoren beregner den bitvise logiske OR af dens integraloperander.

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

5. Ligestillingsoperatører

Operatørerne == (lighed) og != (ulighed) kontrollerer, om deres operander er ens eller ej.

Ligestillingsoperatør ==

Lighedsoperatoren == returnerer sand, hvis dens operander er ens, ellers falsk.

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

Ulighedsoperatør !=

Ulighedsoperatoren != returnerer sand, hvis dens operander ikke er ens, ellers falsk. For operanderne af de indbyggede typer giver udtrykket x != y det samme resultat som udtrykket !(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. Diverse operatører

Almindelige diverse operatorer er ?: for betingede kontroller,:: for at få adgang til et medlem af et aliaseret navneområde og $ for strenginterpolation.

?: operatør

Den betingede operator ?:, også kendt som den ternære betingede operator, evaluerer et boolsk udtryk og returnerer resultatet af et af de to udtryk, afhængigt af om det boolske udtryk evalueres til sand eller falsk, som følgende eksempel viser:

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

:: operatør

Brug navneområdets alias-kvalifikation:: for at få adgang til et medlem af et aliaseret navneområde. Du kan kun bruge::-kvalifikationen mellem to identifikatorer. Det venstre id kan være et af følgende aliasser:

Et navneområde-alias oprettet med et bruger-alias-direktiv:

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

Et eksternt alias.
Det globale alias, som er det globale navnerums alias. Det globale navneområde er det navneområde, der indeholder navnerum og typer, der ikke er erklæret inde i et navngivet navnerum. Når det bruges sammen med::-kvalifikationen, refererer det globale alias altid til det globale navneområde, selvom der er det brugerdefinerede globale navnerumsalias.

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

Specialtegnet $ identificerer en streng literal som en interpoleret streng. En interpoleret streng er en streng-literal, der kan indeholde interpolationsudtryk. Når en interpoleret streng er løst til en resultatstreng, erstattes elementer med interpolationsudtryk af strengrepræsentationerne af udtryksresultaterne.

I interpolerede strenge bruges dollartegnet ($) til at fortælle C#-kompileren, at strengen efter den skal fortolkes som en interpoleret streng. De krøllede klammeparenteser indkapsler værdierne (af variablerne), der skal inkluderes i teksten.

For at identificere en streng som en interpoleret streng, skal du sætte $-symbolet foran den. Du kan ikke have et mellemrum mellem $ og ", der starter en streng bogstavelig.

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 programmering operatører microsoft windows dotnet