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

Unity är en spelmotor som gör mycket av "heavy-lifting" för utvecklare när det gäller funktionalitet och låter dem fokusera helt på utvecklingsprocessen. Den använder C# 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.

I C# finns det 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 "add one" (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:

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

Minska operatör --

Operatorn "subtract one" ä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:

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ä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: 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 *

Multiplikationsoperatorn * beräknar den multiplicerade produkten av dess 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 / 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: 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

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: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.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.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 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: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 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: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. Jämförelseoperatörer

Jämförelsen med < (less than), > (greater than), <= (less than or equal), and >= (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: 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 ä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: 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 ä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: 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 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: 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. 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 passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

Logisk AND operator &

Operatorn & beräknar den logiska OCH för dess operander. Resultatet av x & y är sant om både x och y evalueras till sanna. Annars är resultatet falskt.

operatorn & utvärderar båda operanderna även om den vänstra operanden utvärderas till falsk, så att operationsresultatet är falskt oavsett värdet på den högra handen 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 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: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

Logisk ELLER-operator |

Den | operatorn beräknar det logiska ELLER för sina operander. Resultatet av x | y är sant om antingen x eller y utvärderas till sant, annars är resultatet falskt.

Den | operatorn utvärderar båda operanderna även om den vänstra operanden utvärderas till sann, så att operationsresultatet är sant oavsett värdet på den högra 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

Villkorlig logisk AND-operator &&

Den villkorliga logiska AND-operatorn &&, även känd som den logiska AND-operatorn "short-circuiting", 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("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

Villkorlig logisk ELLER-operator ||

Den villkorliga logiska ELLER-operatorn ||, även känd som den logiska ELLER-operatorn "short-circuiting", 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("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. 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 << (left shift) and >> (högerskift) 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:
// 11110000111100001111000011110011

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.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

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($"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 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 högerskiftsoperatorn ett aritmetiskt skift: värdet på den mest signifikanta biten (teckenbiten) i den vänstra operanden fortplantas till den tomma biten av hög ordning positioner. 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:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

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.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

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: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

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

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); // output: 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 => "Consider renaming this class";
    }
}

$-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 som följer 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($"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