Оператори Unity C#, які потрібно знати

Unity це ігровий движок, який робить багато "heavy-lifting" для розробників з точки зору функціональності та дозволяє їм повністю зосередитися на процесі розробки. Він використовує C# як основну мову програмування.

Як і будь-яка мова програмування, C# складається з масиву спеціальних функцій, типів, класів, бібліотек тощо, але також має список спеціальних символів (операторів), кожен з яких має свою функцію. У цій публікації я перелічу ці символи та поясню, що вони роблять, щоб наступного разу, коли ви відкриватимете сценарій, ви могли швидко зрозуміти значення кожної частини.

Оператори в C# — це спеціальні символи, які виконують певну дію над операндами.

У C# є 6 типів вбудованих операторів: арифметичні оператори, оператори порівняння, логічні логічні оператори, порозрядні оператори та оператори зсуву, оператори рівності та інші оператори. Знання всіх них одразу зробить вас кращим програмістом.

1. Арифметичні оператори

Наступні оператори виконують арифметичні операції з операндами числових типів:

Унарні оператори ++ (збільшення), -- (зменшення), + (плюс) і - (мінус)
Двійкові оператори * (множення), / (ділення), % (залишок), + (додавання) і - (віднімання)

Оператор приросту++

Оператор "add one" (або ++) означає += 1, іншими словами, це швидкий спосіб додати одне ціле число до числового значення без необхідності вводити додатковий код. Цей оператор можна додати перед значенням або після нього, що призведе до іншої поведінки:

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

Оператор зменшення --

Оператор "subtract one" протилежний ++ (-= 1), тобто він віднімає одне ціле число від числового значення. Його також можна додати до або після значення:

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

Унарні оператори + і -

Унарний оператор + повертає значення свого операнда, а унарний оператор - обчислює числове заперечення свого операнда.

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

Оператор множення *

Оператор множення * обчислює добуток своїх операндів:

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

Оператор ділення /

Оператор ділення / ділить свій лівий операнд на правий.

Якщо один із операндів є десятковим, інший операнд не може бути ні float, ні double, оскільки ні float, ні double неявно конвертуються в десятковий. Ви повинні явно перетворити операнд з плаваючою точкою або подвійний на десятковий тип.

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

Оператор залишку %

Оператор залишку % обчислює залишок після ділення лівого операнда на правий.

Для операндів цілочисельних типів результатом a % b є значення, створене 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

Для десяткових операндів оператор залишку % еквівалентний оператору залишку типу 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

Оператор додавання +

Оператор додавання + обчислює суму своїх операндів. Ви також можете використовувати оператор + для конкатенації рядків і комбінації делегатів.

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

Оператор віднімання -

Оператор віднімання - віднімає правий операнд від лівого операнда. Ви також можете використовувати оператор - для видалення делегатів.

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

2. Оператори порівняння

Оператори порівняння < (less than), > (greater than), <= (less than or equal), and >= (більше або рівно), також відомі як реляційні, порівнюють свої операнди. Ці оператори підтримуються всіма числовими типами інтегралів і чисел з плаваючою комою.

Менше ніж оператор <

Оператор < повертає true, якщо його лівий операнд менший за правий операнд, і 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

Більше ніж оператор >

Оператор > повертає true, якщо його лівий операнд більший за правий операнд, і 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

Оператор менше або рівно <=

Оператор <= повертає істину, якщо його лівий операнд менший або дорівнює правому операнду, інакше повертає хибність.

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

Оператор «більше або рівно» >=

Оператор >= повертає true, якщо його лівий операнд більший або дорівнює правому операнду, і 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. Логічні логічні оператори

Наступні оператори виконують логічні операції з логічними операндами:

Унарний ! (логічне заперечення) оператор.
Двійковий & (логічне І), | оператори (логічне АБО) і ^ (логічне виключаюче АБО). Ці оператори завжди оцінюють обидва операнди.
Двійковий && (умовне логічне І) і || (умовне логічне АБО) оператори. Ці оператори обчислюють правий операнд, лише якщо це необхідно.

Логічний оператор заперечення!

Унарний префікс! оператор обчислює логічне заперечення свого операнда. Тобто, він створює істину, якщо операнд оцінюється як false, і false, якщо операнд оцінює як істину.

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

Логічний оператор І &

Оператор & обчислює логічне І своїх операндів. Результат x & y є істинним, якщо і x, і y мають значення істини. В іншому випадку результат буде false.

Оператор & обчислює обидва операнди, навіть якщо лівий операнд має значення false, тому результат операції є false незалежно від значення правого операнда.

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

Логічний оператор виключаючого АБО ^

Оператор ^ обчислює логічне виключаюче АБО, також відоме як логічне XOR, своїх операндів. Результат x ^ y є істинним, якщо x має значення true, а y — false, або x обчислюється як false, а y — як true. В іншому випадку результат буде помилковим. Тобто для логічних операндів оператор ^ обчислює той самий результат, що й оператор нерівності !=.

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

Логічний оператор АБО |

| Оператор обчислює логічне АБО своїх операндів. Результат x | y є істинним, якщо x або y обчислюється як істина, інакше результат є хибним.

The | Оператор обчислює обидва операнди, навіть якщо лівий операнд має значення істини, так що результат операції є істинним незалежно від значення правого операнда.

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

Умовний логічний оператор І &&

Умовний логічний оператор І &&, також відомий як "short-circuiting" логічний оператор І, обчислює логічне І своїх операндів. Результат x && y є істинним, якщо і x, і y мають значення істини, інакше результат є хибним. Якщо x має значення false, 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

Умовний логічний оператор АБО ||

Умовний логічний оператор АБО ||, також відомий як "short-circuiting" логічний оператор АБО, обчислює логічне АБО своїх операндів. Результат x || y є істинним, якщо x або y оцінюється як істинне. В іншому випадку результат буде помилковим. Якщо x оцінюється як істина, 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. Порозрядні оператори та оператори зсуву

Наступні оператори виконують порозрядні операції або операції зсуву з операндами інтегральних числових типів або типу char:

Унарний оператор ~ (порозрядне доповнення).
Двійкові оператори зсуву << (left shift) and >> (правий зсув).
Двійковий & (логічне І), | оператори (логічне АБО) і ^ (логічне виключаюче АБО).

Оператор побітового доповнення ~

Оператор ~ виробляє порозрядне доповнення свого операнда шляхом інверсії кожного біта.

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

Оператор зсуву вліво <<

Оператор << зсуває свій лівий операнд вліво на кількість бітів, визначену його правим операндом. Щоб отримати інформацію про те, як правий операнд визначає лічильник зсуву, перегляньте розділ «Лічильник зсуву» операторів зсуву.

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

Оператор правого зсуву >>

Оператор >> зсуває свій лівий операнд праворуч на кількість бітів, визначену його правим операндом.

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

Позиції порожніх бітів старшого порядку встановлюються на основі типу лівого операнда наступним чином:

Якщо лівий операнд має тип int або long, оператор правого зсуву виконує арифметичний зсув: значення старшого біта (біта знака) лівого операнда поширюється на порожній біт старшого порядку позиції. Тобто позиції пустих бітів старшого порядку встановлюються на нуль, якщо лівий операнд невід’ємний, і в одиницю, якщо він від’ємний.

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

Якщо лівий операнд має тип uint або ulong, оператор правого зсуву виконує логічний зсув: позиції порожніх бітів старшого порядку завжди встановлюються на нуль.

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

Логічний оператор І &

Оператор & обчислює порозрядне логічне І своїх інтегральних операндів.

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

Логічний оператор виключаючого АБО ^

Оператор ^ обчислює порозрядне логічне виключаюче АБО, також відоме як порозрядне логічне виключаюче АБО, своїх інтегральних операндів.

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

Логічний оператор АБО |

| Оператор обчислює порозрядне логічне АБО своїх інтегральних операндів.

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

5. Оператори рівності

Оператори == (рівність) і != (нерівність) перевіряють, чи їхні операнди рівні чи ні.

Оператор рівності ==

Оператор рівності == повертає true, якщо його операнди рівні, і 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

Оператор нерівності !=

Оператор нерівності != повертає true, якщо його операнди не є рівними, або false в іншому випадку. Для операндів вбудованих типів вираз x != y дає той самий результат, що й вираз !(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. Різні оператори

Поширеними різними операторами є ?: для умовних перевірок, :: для доступу до члена псевдонімного простору імен і $ для інтерполяції рядків.

?: оператор

Умовний оператор ?:, також відомий як тернарний умовний оператор, обчислює логічний вираз і повертає результат одного з двох виразів залежно від того, чи логічний вираз обчислюється як істинне чи хибне, як показано в наведеному нижче прикладі:

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

:: оператор

Використовуйте кваліфікатор псевдоніма простору імен:: для доступу до члена псевдонімного простору імен. Ви можете використовувати кваліфікатор:: лише між двома ідентифікаторами. Лівий ідентифікатор може бути будь-яким із наведених нижче псевдонімів:

Псевдонім простору імен, створений за допомогою директиви using alias:

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

Зовнішній псевдонім.
Глобальний псевдонім, який є глобальним псевдонімом простору імен. Глобальний простір імен — це простір імен, який містить простори імен і типи, які не оголошені в іменованому просторі імен. При використанні з кваліфікатором:: глобальний псевдонім завжди посилається на глобальний простір імен, навіть якщо існує визначений користувачем глобальний псевдонім простору імен.

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

оператор $

Спеціальний символ $ ідентифікує рядковий літерал як інтерпольований рядок. Інтерпольований рядок — це рядковий літерал, який може містити вирази інтерполяції. Коли інтерпольований рядок перетворюється на рядок результату, елементи з виразами інтерполяції замінюються рядковими представленнями результатів виразу.

В інтерпольованих рядках знак долара ($) використовується, щоб повідомити компілятору C#, що наступний за ним рядок має інтерпретуватися як інтерпольований рядок. Фігурні дужки інкапсулюють значення (змінних) для включення в текст.

Щоб ідентифікувати рядковий літерал як інтерпольований рядок, додайте перед ним символ $. Ви не можете мати пробіли між $ і ", які починають рядковий літерал.

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 програмування оператори microsoft windows dotnet