Unity C# måste känna till operatörer (2023)

Enhetär en spelmotor som gör mycket "heavy-lifting" för utvecklare vad gäller funktionalitet och låter dem fokusera helt på utvecklingsprocessen. Det utnyttjarC#som huvudprogrammeringsspråk.

Som med alla programmeringsspråk består C# av en rad specialfunktioner, typer, klasser, bibliotek etc., men den har också en lista med specialsymboler (operatorer) som var och en har sin egen funktion. I det här inlägget kommer jag att lista dessa symboler och förklara vad de gör, så att nästa gång du öppnar ett skript, skulle du snabbt kunna förstå vad varje del betyder.

Operatörer i C# är några speciella symboler som utför vissa åtgärder på operander.

IC#, det finns 6 typer av inbyggda operatorer: aritmetiska operatorer, jämförelseoperatorer, booleska logiska operatorer, bitvisa och skiftoperatorer, likhetsoperatorer och diverse operatorer. Att känna till dem alla kommer att göra dig omedelbart till en bättre programmerare.

1. Aritmetiska operatorer

Följande operatorer utför aritmetiska operationer med operander av numeriska typer:

• Unära ++ (öka), -- (minska), + (plus) och - (minus) operatorer
• Binära * (multiplikation), / (division), % (rest), + (addition) och - (subtraktion) operatorer

Öka Operatör++

Operatorn "lägg till en" (eller ++) betyder += 1, med andra ord, det är ett snabbt sätt att lägga till ett heltal till ett numeriskt värde, utan att behöva skriva in extra kod. Denna operator kan läggas till antingen före värdet eller efter värdet, vilket skulle resultera i ett annat beteende:

//Resultatet av x++ är värdet av x före operationen, som följande exempel visar:int i = 4;Debug.Log(i); // output: 4Debug.Log(i++); // output: 4Debug.Log(i); // output: 5//Resultatet av ++x är värdet av x efter operationen, som följande exempel visar:double a = 2.5;Debug.Log(a); // output: 2.5Debug.Log(++a); // output: 3.5Debug.Log(a); // utgång: 3,5

Minska operatör --

Operatorn "subtrahera en" är motsatsen till ++ (-= 1), vilket betyder att den subtraherar ett heltal från ett numeriskt värde. Det kan också läggas till före eller efter ett värde:

Resultatet av x-- är värdet av x före operationen, som följande exempel visar:int i = 4;Debug.Log(i); // output: 4Debug.Log(i--); // output: 4Debug.Log(i); // output: 3Resultatet av --x är värdet på x efter operationen, som följande exempel visar:double a = 2.5;Debug.Log(a); // output: 2.5Debug.Log(--a); // output: 1.5Debug.Log(a); // utgång: 1,5

Unära + och - operatorer

Operatorn unary + returnerar värdet på sin operand och unary - operatorn beräknar den numeriska negationen av sin operand.

Debug.Log(+5); // output: 5Debug.Log(-5); // output: -5Debug.Log(-(-5)); // output: 5uint a = 6;var b = -a;Debug.Log(b); // output: -6Debug.Log(b.GetType()); // output: System.Int64Debug.Log(-double.NaN); // output: NaN

Multiplikationsoperator *

Multiplikationsoperatorn * beräknar den multiplicerade produkten av dess operander:

Debug.Log(6 * 3); // output: 18Debug.Log(1.5 * 3.5); // output: 5.25Debug.Log(0.1m * 24.4m); // utgång: 2,44

Divisionsoperatör /

Divisionsoperatören / delar sin vänstra operand med sin högra operand.

Om en av operanderna är decimal kan en annan operand varken vara float eller dubbel, eftersom varken float eller dubbel är implicit konverterbar till decimal. Du måste uttryckligen konvertera float- eller dubbeloperanden till decimaltypen.

Debug.Log(13 / 5); // output: 2Debug.Log(13 / 5.0); // output: 2.6int a = 13;int b = 5;Debug.Log((dubbel)a/b); // output: 2.6Debug.Log(16.8f / 4.1f); // output: 4.097561Debug.Log(16.8d / 4.1d); // output: 4,09756097560976Debug.Log(16,8m / 4,1m); // utgång: 4,0975609756097560975609756098

Resterande operatör %

Resterande operator % beräknar resten efter att ha dividerat sin vänstra operand med sin högra operand.

• För operanderna för heltalstyper är resultatet av a % b värdet som produceras av a - (a / b) * b

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

• För decimaloperanderna är restoperatorn % ekvivalent med resterande operator av typen System.Decimal.

Debug.Log(-5.2f % 2.0f); // output: -1.2Debug.Log(5.9 % 3.1); // output: 2,8Debug.Log(5,9m % 3,1m); // utgång: 2,8

Tilläggsoperator +

Adderingsoperatorn + beräknar summan av dess operander. Du kan också använda operatorn + för strängsammansättning och delegatkombination.

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

Subtraktionsoperator -

Subtraktionsoperatorn - subtraherar sin högra operand från sin vänstra operand. Du kan också använda operatorn - för att ta bort delegater.

Debug.Log(48 - 4); // output: 44Debug.Log(6 - 5.3); // output: 0,7Debug.Log(8,5m - 3,3m); // output: 5.2

2. Jämförelseoperatörer

Jämförelsen < (mindre än), > (större än), <= (mindre än eller lika) och >= (större än eller lika), även känd som relationell, jämför sina operander. Dessa operatörer stöds av alla numeriska typer av integrerad och flyttal.

Mindre än operatör <

Operatorn < returnerar sant om dess vänstra operand är mindre än dess högra operand, annars falskt.

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

Större än operator >

Operatorn > returnerar sant om dess vänstra operand är större än dess högra operand, annars falskt.

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

Mindre än eller lika operator <=

Operatorn <= returnerar sant om dess vänstra operand är mindre än eller lika med dess högra operand, annars falskt.

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

Operator större än eller lika med >=

Operatorn >= returnerar sant om dess vänstra operand är större än eller lika med dess högra operand, annars falskt.

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

3. Booleska logiska operatorer

Följande operatorer utför logiska operationer med booloperander:

• Unary ! (logisk negation) operatör.
• Binär & (logisk OCH), | (logiskt ELLER) och ^ (logiskt exklusivt ELLER) operatorer. Dessa operatörer utvärderar alltid båda operanderna.
• Binär && (villkorlig logisk AND) och || (villkorliga logiska ELLER) operatorer. Dessa operatörer utvärderar den högra operand endast om det är nödvändigt.

Logisk negationsoperatör!

Det unära prefixet! operatorn beräknar den logiska negationen av sin operand. Det vill säga, den producerar sant, om operanden utvärderas till falskt, och falskt, om operanden utvärderas till sant.

bool passerat = false;Debug.Log(!godkänd); // output: TrueDebug.Log(!true); // output: False

Logisk AND operator &

bool SecondOperand(){ Debug.Log("Andra operand utvärderas."); return true;}bool a = false & SecondOperand();Debug.Log(a);// Output:// Andra operand utvärderas.// Falsebool b = true & SecondOperand();Debug.Log(b);// Output:// Andra operand utvärderas.// True

Logisk exklusiv ELLER-operator ^

Operatorn ^ beräknar det logiska exklusiva ELLER, även känt som det logiska XOR, för dess operander. Resultatet av x ^ y är sant om x evalueras till sant och y evalueras till falskt, eller x evalueras till falskt och y evalueras till sant. Annars är resultatet falskt. Det vill säga, för booloperanderna beräknar ^-operatorn samma resultat som olikhetsoperatorn !=.

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

Logisk ELLER-operator |

bool SecondOperand(){ Debug.Log("Andra operand utvärderas."); return true;}bool a = sant | SecondOperand();Debug.Log(a);// Output:// Andra operand utvärderas.// Truebool b = false | SecondOperand();Debug.Log(b);// Output:// Andra operand utvärderas.// True

Villkorlig logisk AND-operator &&

Den villkorliga logiska AND-operatorn &&, även känd som den "kortslutande" logiska OCH-operatorn, beräknar den logiska OCH för dess operander. Resultatet av x && y är sant om både x och y utvärderas till sant, annars är resultatet falskt. Om x utvärderas till falskt utvärderas inte y.

bool SecondOperand(){ Debug.Log("Andra operand utvärderas."); return true;}bool a = false && SecondOperand();Debug.Log(a);// Output:// Falsebool b = true && SecondOperand();Debug.Log(b);// Output:// Andra operanden utvärderas.// True

Villkorlig logisk ELLER-operator ||

Den villkorliga logiska ELLER-operatorn ||, även känd som den "kortslutande" logiska ELLER-operatorn, beräknar det logiska ELLER för dess operander. Resultatet av x || y är sant om antingen x eller y utvärderas till sant. Annars är resultatet falskt. Om x utvärderas till sant, utvärderas inte y.

bool SecondOperand(){ Debug.Log("Andra operand utvärderas."); return true;}bool a = sant || SecondOperand();Debug.Log(a);// Output:// Truebool b = false || SecondOperand();Debug.Log(b);// Output:// Andra operand utvärderas.// True

4. Bitvis och skiftoperatorer

Följande operatorer utför bitvisa eller skiftoperationer med operander av integral numeriska typer eller char-typ:

• Unär ~ (bitvis komplement) operator
• Binära << (vänster skift) och >> (höger skift) skiftoperatorer
• Binär & (logisk OCH), | (logiskt ELLER) och ^ (logiskt exklusivt ELLER) operatorer

Bitvis komplementoperator ~

Operatorn ~ producerar ett bitvis komplement av sin operand genom att vända varje bit.

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

Vänsterskiftsoperatör <<

Operatorn << flyttar sin vänstra operand åt vänster med antalet bitar som definieras av sin högra operand. För information om hur högeroperanden definierar skifträkningen, se avsnittet Skifträkning för 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.ToStringy(Convert.ToStringy) ");// Utdata:// Före: 110010010000000000000000000010001// Efter: 100100000000000000000000100010000

Högerväxlingsoperatör >>

Operatorn >> flyttar sin vänstra operand åt höger med antalet bitar som definieras av sin högra operand.

uint x = 0b_1001;Debug.Log($"Före: {Convert.ToString(x, toBase: 2), 4}");uint y = x >> 2;Debug.Log($"After: {Convert.ToString(y, toBase: 2), 4}"/:// Efter 1001://Före 1001

De tomma bitpositionerna av hög ordning ställs in baserat på typen av vänsteroperand enligt följande:

• Om den vänstra operanden är av typen int eller long, utför den högra skiftoperatorn ett aritmetiskt skift: värdet på den mest signifikanta biten (teckenbiten) i den vänstra operanden fortplantas till de tomma bitpositionerna av hög ordning. Det vill säga att de tomma bitpositionerna av hög ordning sätts till noll om den vänstra operanden är icke-negativ och sätts till ett om den är 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://Före: 0000000000000000000000000000000000 000// Efter: 1111000000000000000000000000000000

• Om den vänstra operanden är av typen uint eller ulong, utför högerskiftsoperatören ett logiskt skift: de tomma bitpositionerna av hög ordning är alltid nollställda.

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.AfterB,(Debug.AfterB,Log),(Debug.AfterB), 32}");// Utdata:// Före: 1000000000000000000000000000000000000// Efter: 100000000000000000000000000000000

Logisk AND operator &

Operatorn & beräknar den bitvisa logiska OCH för dess 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 exklusiv ELLER-operator ^

Operatorn ^ beräknar det bitvisa logiska exklusiva ELLER, även känt som det bitvisa logiska XOR, för dess 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 | operatorn beräknar det bitvisa logiska ELLER för dess 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. Jämställdhetsaktörer

Operatörerna == (likhet) och != (olikhet) kontrollerar om deras operander är lika eller inte.

Jämställdhetsoperatör ==

Likhetsoperatorn == returnerar sant om dess operander är lika, annars falskt.

int a = 1 + 2 + 3;int b = 6;Debug.Log(a == b); // output: Truechar c1 = 'a';char c2 = 'A';Debug.Log(c1 == c2); // output: FalseDebug.Log(c1 == char.ToLower(c2)); // output: Sant

Ojämlikhetsoperatör !=

Olikhetsoperatorn != returnerar sant om dess operander inte är lika, annars falskt. För operanderna för de inbyggda typerna ger uttrycket x != y samma resultat som uttrycket !(x == y).

int a = 1 + 1 + 2 + 3; int b = 6; Debug.Log(a != b); // output: Truestring s1 = "Hej";string s2 = "Hej";Debug.Log(s1 != s2); // output: Falseobject o1 = 2;object o2 = 2;Debug.Log(o1 != o2); // output: Sant

6. Diverse operatörer

Vanliga olika operatorer är ?: för villkorskontroller, :: för åtkomst till en medlem av ett aliasnamnområde och $ för stränginterpolation.

?: operatör

Den villkorliga operatorn ?:, även känd som den ternära villkorsoperatorn, utvärderar ett booleskt uttryck och returnerar resultatet av ett av de två uttrycken, beroende på om det booleska uttrycket utvärderas till sant eller falskt, som följande exempel visar:

bool condition = true;Debug.Log(condition ? 1 : 2); // utgång: 1

:: operatör

Använd namnutrymmets alias-kvalificerare :: för att komma åt en medlem av ett aliasnamnområde. Du kan bara använda ::-kvalificeraren mellan två identifierare. Den vänstra identifieraren kan vara något av följande alias:

• Ett namnområdesalias skapat med ett use 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);}

• Ett externt alias.
• Det globala aliaset, som är det globala namnrymdsaliaset. Det globala namnområdet är namnområdet som innehåller namnutrymmen och typer som inte deklareras i ett namnområde. När det används med ::-kvalificeraren refererar det globala aliaset alltid till det globala namnområdet, även om det finns det användardefinierade globala namnutrymmesaliaset.

namespace MyCompany.MyProduct.System{ class Program { static void Main() => global::System.Console.WriteLine("Using global alias"); } class Console { string Suggestion => "Överväg att byta namn på den här klassen"; }}

$-operatör

Specialtecknet $ identifierar en bokstavlig sträng som en interpolerad sträng. En interpolerad sträng är en strängliteral som kan innehålla interpolationsuttryck. När en interpolerad sträng löses till en resultatsträng, ersätts objekt med interpolationsuttryck av strängrepresentationerna av uttrycksresultaten.

I interpolerade strängar används dollartecknet ($) för att tala om för C#-kompilatorn att strängen efter den ska tolkas som en interpolerad sträng. De lockiga klammerparenteserna kapslar in värdena (av variablerna) som ska inkluderas i texten.

För att identifiera en bokstavlig sträng som en interpolerad sträng lägger du symbolen $ före den. Du kan inte ha något blanksteg mellan $ och " som startar en bokstavlig sträng.

string name = "John";var date = DateTime.Now;Debug.Log($"Hej, {name}! Idag är det {date.DayOfWeek}, det är {date:HH:mm} nu.");// Output:// Hej, John! Idag är det onsdag, klockan är 19:40 nu.