Операторы 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 не преобразуются неявно в decimal. Вы должны явно преобразовать float или double операнд в decimal тип.

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

Оператор «меньше или равно» <=

Оператор <= возвращает значение true, если его левый операнд меньше или равен правому операнду, в противном случае — 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. Булевы логические операторы

Следующие операторы выполняют логические операции с операндами bool:

  • Унарный оператор ! (логическое отрицание).
  • Бинарные операторы & (логическое И), | (логическое ИЛИ) и ^ (логическое исключающее ИЛИ). Эти операторы всегда оценивают оба операнда.
  • Бинарные операторы && (условное логическое И) и || (условное логическое ИЛИ). Эти операторы оценивают правый операнд только в случае необходимости.

Логический оператор отрицания !

Унарный префиксный оператор ! вычисляет логическое отрицание своего операнда. То есть, он выдает true, если операнд оценивается как false, и false, если операнд оценивается как true.

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

Логический оператор И &

Оператор & вычисляет логическое И своих операндов. Результат x & y равен true, если и x, и y равны true. В противном случае результат равен 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 оценивается как истина, а y оценивается как ложь, или x оценивается как ложь, а y оценивается как истина. В противном случае результат является ложным. То есть для операндов bool оператор ^ вычисляет тот же результат, что и оператор неравенства !=.

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 оценивается как истинный, в противном случае результат является ложным.

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

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 оценивается как ложный, 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

Логический оператор исключающего ИЛИ ^

Оператор ^ вычисляет побитовое логическое исключающее ИЛИ, также известное как побитовое логическое XOR, своих целочисленных операндов.

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

$ оператор

Специальный символ $ идентифицирует строковый литерал как интерполированную строку. Интерполированная строка — это строковый литерал, который может содержать интерполяционные выражения. Когда интерполированная строка разрешается в результирующую строку, элементы с интерполяционными выражениями заменяются строковыми представлениями результатов выражений.

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

Чтобы идентифицировать строковый литерал как интерполированную строку, добавьте к нему символ $. Между $ и ", с которого начинается строковый литерал, не должно быть пробелов.

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.
единствоunity3dcsharpпрограммированиеоператорыmicrosoftwindowsdotnet
Рекомендуемые статьи
Введение в язык сценариев Unity C#
Как перезапустить игру в Unity
Реализация условия выигрыша в Unity
Создание игры в стиле Clash of Clans в Unity. Часть 2
Как устранить проблемы с вводом в Unity
Настройка и использование визуальных скриптов в Unity
Сохранение и загрузка логики для Unity
Популярные статьи
Работа с массивами и списками в коде Unity
Создание инвентаря и системы создания предметов в Unity
Как запустить кат-сцену в Unity
Руководство по MonoBehavior в Unity
Unity реализует звуки шагов
Создание 2D-шипов в Unity
Создание пошаговых игр в Unity
Ссылки
Unity 6