Операторы 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

Оператор отдела /

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

Если один из операндов десятичный, другой операнд не может быть ни плавающим, ни двойным, поскольку ни число с плавающей запятой, ни двойное не могут быть неявно преобразованы в десятичные. Вы должны явно преобразовать операнд с плавающей запятой или двойной точностью в десятичный тип.

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 passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

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

Оператор & вычисляет логическое И своих операндов. Результат x и y является истинным, если и x, и y имеют значение true. В противном случае результат будет ложным.

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

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

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

Оператор ^ вычисляет логическое исключающее ИЛИ, также известное как логическое исключающее ИЛИ, для своих операндов. Результат 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

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

| Оператор вычисляет логическое ИЛИ своих операндов. Результат х | y истинно, если значение x или y равно true, в противном случае результат будет ложным.

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

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 равно true. В противном случае результат будет ложным. Если x оценивается как true, 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. Разные операторы

Распространенными различными операторами являются ?: для проверки условий, :: для доступа к члену пространства имен с псевдонимами и $ для интерполяции строк.

?: оператор

Условный оператор ?:, также известный как тернарный условный оператор, оценивает логическое выражение и возвращает результат одного из двух выражений, в зависимости от того, имеет ли логическое выражение значение true или false, как показано в следующем примере:

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.
единствоunity3dcsharpпрограммированиеоператорыMicrosoftWindowsDotNet
Рекомендуемые статьи
Введение в язык сценариев Unity C#
Понимание функций и вызовов методов
Реализация основных арифметических операций в коде Unity
Как стать лучшим программистом в Unity
Скрипт для захвата объектов в Unity
Сохранение и загрузка логики для Unity
Компиляция Unity для конкретной платформы
Еще сообщения »
Популярные статьи
Unity реализует звуки шагов
Создание инвентаря и системы создания предметов в Unity
Введение в переменные и типы данных в программировании в Unity
Руководство по MonoBehavior в Unity
Создание 2D-шипов в Unity
Обработка исключений и ошибок в коде Unity
Создание симулятора дорожного движения в Unity