Unity C# må-kjenne operatører

Unity er en spillmotor som gjør mye "heavy-lifting" for utviklere når det gjelder funksjonalitet og lar dem fokusere helt på utviklingsprosessen. Den bruker C# som hovedprogrammeringsspråk.

Som med alle programmeringsspråk, består C# av en rekke spesielle funksjoner, typer, klasser, biblioteker, etc., men den har også en liste med spesielle symboler (operatører) som hver har sin egen funksjon. I dette innlegget vil jeg liste opp disse symbolene og forklare hva de gjør, slik at neste gang du åpner et skript, vil du raskt kunne forstå hva hver del betyr.

Operatorer i C# er noen spesielle symboler som utfører noen handlinger på operander.

I C# er det 6 typer innebygde operatorer: aritmetiske operatorer, sammenligningsoperatorer, boolske logiske operatorer, bitvise og skiftoperatorer, likhetsoperatorer og diverse operatorer. Å kjenne dem alle vil gjøre deg til en bedre programmerer umiddelbart.

1. Aritmetiske operatorer

Følgende operatorer utfører aritmetiske operasjoner med operander av numeriske typer:

  • Unære ++ (økning), -- (minus), + (pluss) og - (minus) operatorer
  • Binære * (multiplikasjon), / (divisjon), % (rest), + (addisjon) og - (subtraksjon) operatorer

Øk operatør++

Operatoren "add one" (eller ++) betyr += 1, med andre ord, det er en rask måte å legge til ett heltall til en numerisk verdi, uten å måtte skrive inn ekstra kode. Denne operatoren kan legges til enten før verdien eller etter verdien, noe som vil resultere i en annen oppførsel:

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

Reduser operatør --

Operatoren "subtract one" er det motsatte av ++ (-= 1), noe som betyr at den trekker ett heltall fra en numerisk verdi. Den kan også legges til før eller etter en verdi:

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

Den unære +-operatoren returnerer verdien av sin operande, og den unære --operatoren beregner den numeriske negasjonen av sin 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

Multiplikasjonsoperator *

Multiplikasjonsoperatoren * beregner det multipliserte produktet av operandene:

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

Divisjonsoperatør /

Divisjonsoperatøren / deler sin venstre operand med sin høyre operand.

Hvis en av operandene er desimal, kan en annen operand verken være float eller dobbel, fordi verken float eller dobbel er implisitt konverterbare til desimal. Du må eksplisitt konvertere float- eller dobbeloperanden til desimaltypen.

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

Resterende operatør %

Restoperatoren % beregner resten etter å ha delt venstreoperanden med høyreoperand.

  • For operandene til heltallstyper er resultatet av a % b verdien produsert 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
  • For desimaloperanderene tilsvarer den resterende operatoren % den resterende operatoren av typen System.Desimal.
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

Tilleggsoperatør +

Addisjonsoperatoren + beregner summen av operandene. Du kan også bruke +-operatoren for strengsammenkobling og delegatkombinasjon.

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

Subtraksjonsoperatør -

Subtraksjonsoperatøren - trekker sin høyreoperand fra sin venstreoperand. Du kan også bruke operatoren - for å fjerne 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. Sammenligningsoperatører

< (less than), > (greater than), <= (less than or equal), and >= (større enn eller lik) sammenligning, også kjent som relasjonsoperatorer, sammenligner operandene sine. Disse operatørene støttes av alle integrerte og flytende numeriske typer.

Mindre enn operatør <

Operatoren < returnerer sann hvis venstreoperanden er mindre enn høyreoperand, ellers usant.

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 enn operatør >

Operatoren > returnerer sann hvis venstreoperanden er større enn høyreoperand, ellers usant.

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 enn eller lik operator <=

Operatoren <= returnerer sann hvis venstreoperanden er mindre enn eller lik den høyre operanden, ellers usann.

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 enn eller lik operator >=

Operatoren >= returnerer sann hvis venstreoperanden er større enn eller lik den høyre operanden, ellers usann.

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

Følgende operatører utfører logiske operasjoner med booloperander:

  • Unært! (logisk negasjon) operatør.
  • Binær & (logisk OG), | (logisk ELLER) og ^ (logisk eksklusiv ELLER) operatorer. Disse operatørene evaluerer alltid begge operandene.
  • Binær && (betinget logisk OG) og || (betinget logisk ELLER) operatorer. Disse operatørene evaluerer høyreoperanden bare hvis det er nødvendig.

Logisk negasjonsoperatør!

Det unære prefikset! operatør beregner den logiske negasjonen av operanden. Det vil si at den produserer sann, hvis operanden evalueres til usann, og usann, hvis operanden evalueres til sann.

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

Logisk OG operatør &

Operatoren & beregner den logiske OG for operandene. Resultatet av x og y er sant hvis både x og y vurderes til sanne. Ellers er resultatet usant.

&-operatoren evaluerer begge operandene selv om venstreoperanden evalueres til usann, slik at operasjonsresultatet er usant uavhengig av verdien på høyrehånden 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-operatør ^

^-operatoren beregner den logiske eksklusive ELLER, også kjent som den logiske XOR, til operandene. Resultatet av x ^ y er sant hvis x evalueres til sant og y evalueres til usant, eller x evalueres til usant og y evalueres til sant. Ellers er resultatet falskt. Det vil si at for bool-operanden beregner ^-operatoren det samme resultatet som ulikhetsoperatoren !=.

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 OR-operator |

Den | operatør beregner den logiske ELLER for operandene sine. Resultatet av x | y er sann hvis enten x eller y evalueres til sann, ellers er resultatet usant.

Den | operator evaluerer begge operandene selv om venstreoperanden evalueres til sann, slik at operasjonsresultatet er sant uavhengig av verdien av høyreoperanden.

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-operatoren &&, også kjent som "short-circuiting" logiske AND-operatoren, beregner den logiske AND av operandene. Resultatet av x && y er sant hvis både x og y evalueres til sann, ellers er resultatet usant. Hvis x evalueres til usant, evalueres ikke 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

Betinget logisk OR-operator ||

Den betingede logiske ELLER-operatoren ||, også kjent som "short-circuiting" logiske ELLER-operatoren, beregner den logiske ELLER for operandene. Resultatet av x || y er sann hvis enten x eller y evalueres til sann. Ellers er resultatet falskt. Hvis x evalueres til sann, evalueres ikke 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 og skiftoperatører

Følgende operatører utfører bitvise eller skiftoperasjoner med operander av integrerte numeriske typer eller char-typen:

  • Unær ~ (bitvis komplement) operator
  • Binære << (left shift) and >> (høyre skift) skiftoperatører
  • Binær & (logisk OG), | (logisk ELLER) og ^ (logisk eksklusiv ELLER) operatorer

Bitvis komplementoperatør ~

Operatoren ~ produserer et bitvis komplement av operanden ved å reversere 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

Venstreskiftoperatør <<

Operatoren << flytter venstreoperanden til venstre med antall biter definert av høyreoperand. For informasjon om hvordan høyreoperanden definerer skifttellingen, se seksjonen Skifttelling 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øyreskiftoperatør >>

>>-operatoren forskyver sin venstreoperand til høyre med antall biter definert av sin høyreoperand.

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 bitposisjonene av høy orden settes basert på typen venstreoperand som følger:

  • Hvis venstreoperanden er av typen int eller long, utfører høyreskiftoperatoren et aritmetisk skift: verdien av den mest signifikante biten (tegnbiten) i venstreoperanden forplantes til den tomme biten av høy orden stillinger. Det vil si at de tomme bitposisjonene av høy orden settes til null hvis venstreoperanden er ikke-negativ og satt 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 operanden er av typen uint eller ulong, utfører høyreskiftoperatoren et logisk skift: de tomme bitposisjonene av høy orden er alltid satt til null.
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 operatør &

&-operatoren beregner den bitvise logiske OG for dens integrerte operander.

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-operatør ^

^-operatoren beregner den bitvise logiske eksklusive ELLER, også kjent som den bitvise logiske XOR, av dens integrerte operander.

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

Logisk OR-operator |

Den | operatoren beregner den bitvise logiske ELLER for sine integrerte operander.

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

5. Likestillingsoperatører

Operatorene == (likhet) og != (ulikhet) sjekker om operandene deres er like eller ikke.

Likhetsoperatør ==

Likhetsoperatoren == returnerer sann hvis operandene er like, ellers usant.

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

Ulikhetsoperatør !=

Ulikhetsoperatoren != returnerer sann hvis operandene ikke er like, ellers usant. For operandene til de innebygde typene gir uttrykket x != y det samme resultatet som uttrykket !(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

Vanlige diverse operatorer er ?: for betingede kontroller,:: for tilgang til et medlem av et aliasert navneområde, og $ for strenginterpolasjon.

?: operatør

Den betingede operatoren ?:, også kjent som den ternære betingede operatoren, evaluerer et boolsk uttrykk og returnerer resultatet av ett av de to uttrykkene, avhengig av om det boolske uttrykket evalueres til sant eller usant, som følgende eksempel viser:

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

:: operatør

Bruk navneområde-alias-kvalifiseringen:: for å få tilgang til et medlem av et alias-navneområde. Du kan bare bruke::-kvalifiseringen mellom to identifikatorer. Den venstre identifikatoren kan være et av følgende aliaser:

  • Et navneområdealias opprettet med en bruksalias-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 aliaset, som er det globale navneromsaliaset. Det globale navneområdet er navneområdet som inneholder navnerom og typer som ikke er deklarert i et navngitt navneområde. Når det brukes med::-kvalifiseringen, refererer det globale aliaset alltid til det globale navneområdet, selv om det er det brukerdefinerte globale navneromaliaset.
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

Spesialtegnet $ identifiserer en streng bokstavelig som en interpolert streng. En interpolert streng er en strengliteral som kan inneholde interpolasjonsuttrykk. Når en interpolert streng blir løst til en resultatstreng, erstattes elementer med interpolasjonsuttrykk med strengrepresentasjonene til uttrykksresultatene.

I interpolerte strenger brukes dollartegnet ($) for å fortelle C#-kompilatoren at strengen som følger den skal tolkes som en interpolert streng. De krøllete klammeparentesene kapsler inn verdiene (av variablene) som skal inkluderes i teksten.

For å identifisere en streng som en interpolert streng, setter du $-symbolet foran den. Du kan ikke ha noe mellomrom mellom $ og " som starter en streng bokstavelig.

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.
unityunity3dcsharpprogrammeringoperatørermicrosoftwindowsdotnet
Foreslåtte artikler
Forstå funksjoner og metodeanrop
Introduksjon til Unity C# Scripting Language
Implementering av grunnleggende aritmetiske operasjoner i Unity Code
Hvordan bli en bedre programmerer i Unity
Opprette interaktive objekter i Unity
Implementering av kinetiske interaksjoner i enhet
Åpning av skuffer og skap med spesifikke nøkler i Unity
Flere innlegg »
Populære artikler
Forstå Unitys komponentbaserte arkitektur
Opprette klasser og objekter i Unity Code
Implementering av arv og polymorfisme i enhetskode
Unity C# Interface nybegynnerveiledning
Oppdatering vs FixedUpdate vs LateUpdate
Opprette betingede erklæringer (hvis annet) i Unity Code
Introduksjon til Unity C# Scripting Language