Unity C#-operatoren die u moet kennen

Unity is een game-engine die qua functionaliteit veel "heavy-lifting" doet voor ontwikkelaars en hen volledig laat focussen op het ontwikkelingsproces. Het gebruikt C# als de belangrijkste programmeertaal.

Zoals elke programmeertaal bestaat C# uit een reeks speciale functies, typen, klassen, bibliotheken, enz., maar het heeft ook een lijst met speciale symbolen (operatoren) die elk hun eigen functie hebben. In dit bericht zal ik die symbolen opsommen en uitleggen wat ze doen, zodat je de volgende keer dat je een script opent, snel kunt begrijpen wat elk onderdeel betekent.

Operators in C# zijn enkele speciale symbolen die een actie uitvoeren op operanden.

In C# zijn er 6 soorten ingebouwde operators: Rekenkundige operatoren, Vergelijkingsoperatoren, Booleaanse logische operatoren, Bitwise- en shift-operatoren, Gelijkheidsoperatoren en Diverse operatoren. Als u ze allemaal kent, wordt u meteen een betere programmeur.

1. Rekenkundige operatoren

De volgende operators voeren rekenkundige bewerkingen uit met operanden van numerieke typen:

Unaire ++ (verhogen), -- (verlagen), + (plus) en - (min) operatoren
Binaire * (vermenigvuldigen), / (delen),% (rest), + (optellen) en - (aftrekken) operatoren

Operator++ verhogen

De operator "add one" (of ++) betekent += 1, met andere woorden, het is een snelle manier om één geheel getal toe te voegen aan een numerieke waarde, zonder dat je extra code hoeft te typen. Deze operator kan vóór de waarde of na de waarde worden toegevoegd, wat tot ander gedrag zou leiden:

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

Operator verlagen --

De operator "subtract one" is het tegenovergestelde van ++ (-= 1), wat betekent dat hij één geheel getal aftrekt van een numerieke waarde. Het kan ook vóór of na een waarde worden toegevoegd:

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

Unaire + en - operatoren

De unaire operator + retourneert de waarde van zijn operand en de unaire - operator berekent de numerieke negatie van zijn 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

Vermenigvuldigingsoperator *

De vermenigvuldigingsoperator * berekent het vermenigvuldigde product van zijn operanden:

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

Divisie-operator /

De delingsoperator / deelt zijn linker operand door zijn rechter operand.

Als een van de operanden decimaal is, kan een andere operand noch float noch double zijn, omdat noch float noch double impliciet converteerbaar is naar decimaal. U moet de float- of dubbeloperand expliciet naar het decimale type converteren.

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

De restoperator % berekent de rest na het delen van de linker operand door de rechter operand.

Voor de operanden van typen gehele getallen is het resultaat van a % b de waarde geproduceerd door 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

Voor de decimale operanden is de restoperator % gelijk aan de restoperator van het type 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

Optellingsoperator +

De opteloperator + berekent de som van zijn operanden. U kunt ook de operator + gebruiken voor het samenvoegen van tekenreeksen en het combineren van deelnemers.

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

Aftrekkingsoperator -

De aftrekkingsoperator - trekt de rechter operand af van de linker operand. U kunt ook de operator - gebruiken voor het verwijderen van deelnemers.

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

2. Vergelijkende operatoren

De < (less than), > (greater than), <= (less than or equal), and >= (groter dan of gelijk) vergelijking, ook wel relationele operatoren genoemd, vergelijken hun operanden. Deze operatoren worden ondersteund door alle numerieke typen integralen en drijvende komma's.

Minder dan operator <

De operator < retourneert waar als de linker operand kleiner is dan de rechter operand, anders false.

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

Groter dan operator >

De operator > retourneert waar als de linker operand groter is dan de rechter operand, anders false.

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

Operator kleiner dan of gelijk <=

De operator <= retourneert waar als de linker operand kleiner is dan of gelijk is aan de rechter operand, anders false.

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

Groter dan of gelijk-operator >=

De operator >= retourneert waar als de linker operand groter is dan of gelijk is aan de rechter operand, anders false.

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. Booleaanse logische operatoren

De volgende operators voeren logische bewerkingen uit met bool-operands:

Unair! (logische negatie) operator.
Binair & (logische AND), | (logische OR) en ^ (logische exclusieve OR) operatoren. Deze operatoren evalueren altijd beide operanden.
Binair && (voorwaardelijke logische AND) en || (voorwaardelijke logische OR)-operatoren. Deze operators evalueren de rechter operand alleen als dat nodig is.

Logische ontkenningsoperator!

Het unaire voorvoegsel! operator berekent de logische negatie van zijn operand. Dat wil zeggen dat het waar oplevert als de operand naar onwaar evalueert, en onwaar als de operand naar waar evalueert.

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

Logische AND-operator &

De operator & berekent de logische AND van zijn operanden. Het resultaat van x & y is waar als zowel x als y waar zijn. Anders is het resultaat false.

De operator & evalueert beide operanden, zelfs als de linker operand wordt geëvalueerd als false, zodat het resultaat van de bewerking false is, ongeacht de waarde van de rechter operand 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

Logische exclusieve OR-operator ^

De operator ^ berekent de logische exclusieve OR, ook bekend als de logische XOR, van zijn operanden. Het resultaat van x ^ y is waar als x evalueert tot waar en y evalueert tot onwaar, of x evalueert tot onwaar en y evalueert tot waar. Anders is het resultaat onwaar. Dat wil zeggen dat voor de bool-operands de operator ^ hetzelfde resultaat berekent als de ongelijkheidsoperator !=.

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

Logische OR-operator |

De | operator berekent de logische OR van zijn operanden. Het resultaat van x | y is waar als x of y resulteert in waar, anders is het resultaat onwaar.

De | De operator evalueert beide operanden, zelfs als de linkeroperand evalueert naar waar, zodat het resultaat van de bewerking waar is, ongeacht de waarde van de rechteroperand.

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

Voorwaardelijke logische AND-operator &&

De voorwaardelijke logische AND-operator &&, ook bekend als de logische AND-operator "short-circuiting", berekent de logische AND van zijn operanden. Het resultaat van x && y is waar als zowel x als y waar zijn, anders is het resultaat onwaar. Als x de waarde false oplevert, wordt y niet geëvalueerd.

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

Voorwaardelijke logische OR-operator ||

De voorwaardelijke logische OR-operator ||, ook bekend als de logische OR-operator "short-circuiting", berekent de logische OR van zijn operanden. Het resultaat van x || y is waar als x of y waar oplevert. Anders is het resultaat onwaar. Als x resulteert in waar, wordt y niet geëvalueerd.

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. Bitwise- en shift-operators

De volgende operators voeren bitsgewijze of shift-bewerkingen uit met operanden van het integrale numerieke type of het char-type:

Unaire ~ (bitsgewijze complement) operator
Binaire << (left shift) and >> (shift naar rechts) shift-operatoren
Binair & (logische AND), | (logische OR) en ^ (logische exclusieve OR) operatoren

Bitsgewijze complementoperator ~

De ~-operator produceert een bitsgewijze aanvulling van zijn operand door elke bit om te keren.

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

Linkershift-operator <<

De <<-operator verschuift zijn linker operand naar links met het aantal bits gedefinieerd door zijn rechter operand. Voor informatie over hoe de rechter operand de ploegtelling definieert, zie de sectie Ploegentelling van de ploegoperatoren.

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

Rechtershift-operator >>

De >> operator verschuift zijn linker operand naar rechts met het aantal bits gedefinieerd door zijn rechter 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 lege bitposities van hoge orde worden als volgt ingesteld op basis van het type linker operand:

Als de linker operand van het type int of long is, voert de rechter shift-operator een rekenkundige verschuiving uit: de waarde van het meest significante bit (het tekenbit) van de linker operand wordt doorgegeven aan het lege bit van hoge orde posities. Dat wil zeggen dat de lege bitposities van hoge orde op nul worden gezet als de linker operand niet-negatief is en op één worden gezet als deze negatief is.

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

Als de linker operand van het type uint of ulong is, voert de rechter shift-operator een logische verschuiving uit: de lege bitposities van hoge orde worden altijd op nul gezet.

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

Logische AND-operator &

De operator & berekent de bitsgewijze logische AND van zijn integrale operanden.

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

Logische exclusieve OR-operator ^

De operator ^ berekent de bitsgewijze logische exclusieve OR, ook bekend als de bitsgewijze logische XOR, van zijn integrale operanden.

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

Logische OR-operator |

De | operator berekent de bitsgewijze logische OR van zijn integrale operanden.

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

5. Gelijkheidsoperatoren

De operatoren == (gelijkheid) en != (ongelijkheid) controleren of hun operanden gelijk zijn of niet.

Gelijkheidsoperator ==

De gelijkheidsoperator == retourneert waar als de operanden gelijk zijn, en anders false.

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

Ongelijkheidsoperator !=

De ongelijkheidsoperator != retourneert waar als de operanden niet gelijk zijn, en anders false. Voor de operanden van de ingebouwde typen levert de uitdrukking x != y hetzelfde resultaat op als de uitdrukking !(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 exploitanten

Veelgebruikte diverse operatoren zijn ?: voor voorwaardelijke controles,:: voor toegang tot een lid van een aliasnaamruimte, en $ voor tekenreeksinterpolatie.

?: exploitant

De voorwaardelijke operator ?:, ook wel de ternaire voorwaardelijke operator genoemd, evalueert een Booleaanse expressie en retourneert het resultaat van een van de twee expressies, afhankelijk van of de Booleaanse expressie waar of onwaar oplevert, zoals uit het volgende voorbeeld blijkt:

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

:: exploitant

Gebruik de naamruimtealiaskwalificatie:: om toegang te krijgen tot een lid van een aliasnaamruimte. U kunt de kwalificatie:: alleen tussen twee ID's gebruiken. De linker-ID kan een van de volgende aliassen zijn:

Een naamruimtealias gemaakt met een aliasinstructie:

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

Een externe alias.
De globale alias. Dit is de globale naamruimtealias. De globale naamruimte is de naamruimte die naamruimten en typen bevat die niet binnen een benoemde naamruimte worden gedeclareerd. Bij gebruik met de kwalificatie:: verwijst de globale alias altijd naar de globale naamruimte, zelfs als er een door de gebruiker gedefinieerde globale naamruimtealias bestaat.

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

Het speciale teken $ identificeert een letterlijke tekenreeks als een geïnterpoleerde tekenreeks. Een geïnterpoleerde tekenreeks is een letterlijke tekenreeks die interpolatie-expressies kan bevatten. Wanneer een geïnterpoleerde tekenreeks wordt omgezet in een resultaatreeks, worden items met interpolatie-expressies vervangen door de tekenreeksrepresentaties van de uitdrukkingsresultaten.

In geïnterpoleerde strings wordt het dollarteken ($) gebruikt om de C#-compiler te vertellen dat de daaropvolgende string moet worden geïnterpreteerd als een geïnterpoleerde string. De accolades omvatten de waarden (van de variabelen) die in de tekst moeten worden opgenomen.

Om een letterlijke tekenreeks te identificeren als een geïnterpoleerde tekenreeks, plaatst u er het $-symbool voor. Er mag geen witruimte zijn tussen $ en " waarmee een letterlijke tekenreeks begint.

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 programmeren operators microsoft windows dotnet