Operadores que você deve conhecer no Unity C#

Unity é um mecanismo de jogo que faz muito "trabalho pesado" para desenvolvedores em termos de funcionalidade e permite eles se concentram inteiramente no processo de desenvolvimento. Ele utiliza C# como a principal linguagem de programação.

Assim como qualquer linguagem de programação, C# consiste em uma matriz de funções especiais, tipos, classes, bibliotecas, etc., mas também possui uma lista de símbolos especiais (operadores) cada um com sua própria função. Neste post, listarei esses símbolos e explicarei o que eles fazem, para que na próxima vez que você abrir um script, você possa entender rapidamente o que cada parte significa.

Os operadores em C# são alguns símbolos especiais que executam alguma ação nos operandos.

Em C#, existem 6 tipos de operadores integrados: operadores aritméticos, operadores de comparação, operadores lógicos booleanos, operadores bit a bit e de deslocamento, igualdade operadores e operadores diversos. Conhecer todos eles fará de você um programador melhor instantaneamente.

1. Operadores aritméticos

Os seguintes operadores executam operações aritméticas com operandos de tipos numéricos:

Unário ++ (incremento), -- (decremento), + (mais) e - (menos) operadores
Binário * (multiplicação), / (divisão), % (resto), + (adição) e - (subtração) operadores

Incremento Operador++

O operador "add one" (ou ++) significa += 1, ou seja, é uma forma rápida de somar um inteiro a um valor numérico, sem a necessidade de digitar código extra. Este operador pode ser adicionado antes do valor ou depois do valor, o que resultaria em um comportamento diferente:

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

Operador de Decremento --

O operador "subtract one" é o oposto de ++ (-= 1), o que significa que subtrai um inteiro de um valor numérico. Também pode ser adicionado antes ou depois de um valor:

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ário + e - operadores

O operador unário + retorna o valor de seu operando e o operador unário - calcula a negação numérica de seu operando.

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

Operador de multiplicação *

O operador de multiplicação * calcula o produto multiplicado de seus operandos:

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

Operador de divisão /

O operador de divisão / divide seu operando esquerdo pelo seu operando direito.

Se um dos operandos for decimal, outro operando não pode ser float nem double, porque nem float nem double são implicitamente conversíveis em decimal. Você deve converter explicitamente o float ou double operando para o tipo 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

Operador restante %

O operador de resto % calcula o resto depois de dividir o operando esquerdo pelo operando direito.

Para os operandos de tipos inteiros, o resultado de a % b é o valor produzido por 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

Para os operandos decimais, o operador de resto % é equivalente ao operador de resto do tipo 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

Operador de adição +

O operador de adição + calcula a soma de seus operandos. Você também pode usar o operador + para concatenação de strings e combinação delegada.

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

Operador de subtração -

O operador de subtração - subtrai seu operando à direita de seu operando à esquerda. Você também pode usar o operador - para remoção de delegado.

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

2. Operadores de comparação

Os operadores de comparação < (menor que), > (maior que), <= (menor ou igual) e >= (maior que ou igual), também conhecidos como relacionais, comparam seus operandos. Esses operadores são suportados por todos os tipos numéricos integrais e de ponto flutuante.

Menos que operador <

O operador < retorna verdadeiro se o operando esquerdo for menor que o operando direito, caso contrário, falso.

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

Maior que o operador >

O operador > retorna verdadeiro se o operando esquerdo for maior que o operando direito, caso contrário, falso.

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

Operador menor ou igual <=

O operador <= retorna verdadeiro se o operando esquerdo for menor ou igual ao operando direito, caso contrário, falso.

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

Operador maior ou igual >=

O operador >= retorna verdadeiro se o operando esquerdo for maior ou igual ao operando direito, caso contrário, falso.

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. Operadores lógicos booleanos

Os seguintes operadores executam operações lógicas com operandos bool:

Unário ! (negação lógica) operador.
Binário & (E lógico), | (OU lógico) e ^ (OU exclusivo lógico). Esses operadores sempre avaliam ambos os operandos.
Binário && (E lógico condicional) e || (OU lógico condicional). Esses operadores avaliam o operando do lado direito somente se for necessário.

Operador de negação lógica !

O prefixo unário ! operador calcula a negação lógica de seu operando. Ou seja, produz verdadeiro, se o operando for avaliado como falso, e falso, se o operando for avaliado como verdadeiro.

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

Operador AND lógico &

O operador & calcula o AND lógico de seus operandos. O resultado de x & y é verdadeiro se x e y forem avaliados como verdadeiros. Caso contrário, o resultado é falso.

O operador & avalia ambos os operandos mesmo que o operando esquerdo seja avaliado como falso, de modo que o resultado da operação seja falso independentemente do valor de o operando do lado direito.

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

Operador OR exclusivo lógico ^

O operador ^ calcula o OU exclusivo lógico, também conhecido como XOR lógico, de seus operandos. O resultado de x ^ y é verdadeiro se x for avaliado como verdadeiro e y for avaliado como falso, ou x for avaliado como falso e y for avaliado como verdadeiro. Caso contrário, o resultado é falso. Ou seja, para os operandos bool, o operador ^ calcula o mesmo resultado que o operador de desigualdade !=.

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

Operador OR lógico |

O | operador calcula o OU lógico de seus operandos. O resultado de x | y é verdadeiro se x ou y for avaliado como verdadeiro, caso contrário, o resultado é falso.

O | operador avalia ambos os operandos mesmo se o operando esquerdo for avaliado como verdadeiro, de modo que o resultado da operação seja verdadeiro independentemente do valor do operando direito.

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

Operador AND lógico condicional &&

O operador AND lógico condicional &&, também conhecido como operador AND lógico de "curto-circuito", calcula o AND lógico de seus operandos. O resultado de x && y é verdadeiro se x e y forem avaliados como verdadeiros, caso contrário, o resultado será falso. Se x for avaliado como falso, y não será avaliado.

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

Operador OR lógico condicional ||

O operador OR lógico condicional ||, também conhecido como operador OR lógico de "curto-circuito", calcula o OR lógico de seus operandos. O resultado de x || y é verdadeiro se x ou y for avaliado como verdadeiro. Caso contrário, o resultado é falso. Se x for verdadeiro, y não é avaliado.

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. Operadores bit a bit e shift

Os seguintes operadores executam operações bit a bit ou shift com operandos dos tipos numéricos integrais ou do tipo char:

Unário ~ (complemento bit a bit) operador
Operadores de deslocamento << (deslocamento à esquerda) e >> (deslocamento à direita) binários
Binário & (E lógico), | (OR lógico) e ^ (OR exclusivo lógico)

Operador de complemento bit a bit ~

O operador ~ produz um complemento bit a bit de seu operando invertendo cada bit.

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

Operador de deslocamento à esquerda <<

O operador << desloca seu operando esquerdo para a esquerda pelo número de bits definido por seu operando direito. Para obter informações sobre como o operando à direita define a contagem de turno, consulte a contagem de turnos da seção de operadores de turno.

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

Operador de deslocamento à direita >>

O operador >> desloca seu operando esquerdo para a direita pelo número de bits definido por seu operando direito.

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

As posições de bits vazios de ordem superior são definidas com base no tipo do operando esquerdo da seguinte forma:

Se o operando à esquerda for do tipo int ou long, o operador de deslocamento à direita realiza um deslocamento aritmético: o valor do bit mais significativo (o bit de sinal) do operando à esquerda é propagado para as posições de bits vazios de ordem superior. Ou seja, as posições de bits vazios de ordem superior são definidas como zero se o operando esquerdo for não negativo e definidas como um se for negativo.

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

Se o operando à esquerda for do tipo uint ou ulong, o operador de deslocamento à direita executa um deslocamento lógico: as posições de bit vazias de ordem superior são sempre definidas como zero.

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

Operador AND lógico &

O operador & calcula o AND lógico bit a bit de seus operandos integrais.

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

Operador OR exclusivo lógico ^

O operador ^ calcula o OU exclusivo lógico bit a bit, também conhecido como XOR lógico bit a bit, de seus operandos integrais.

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

Operador OR lógico |

O | operador calcula o OU lógico bit a bit de seus operandos integrais.

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

5. Operadores de igualdade

Os operadores == (igualdade) e != (desigualdade) verificam se seus operandos são iguais ou não.

Operador de igualdade ==

O operador de igualdade == retorna verdadeiro se seus operandos forem iguais, falso caso contrário.

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

Operador de desigualdade !=

O operador de desigualdade != retorna verdadeiro se seus operandos não forem iguais, falso caso contrário. Para os operandos dos tipos integrados, a expressão x != y produz o mesmo resultado que a expressão !(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. Operadores diversos

Os operadores diversos comuns são ?: para verificações condicionais, :: para acessar um membro de um namespace com alias e $ para interpolação de strings.

?: operador

O operador condicional ?:, também conhecido como operador condicional ternário, avalia uma expressão booleana e retorna o resultado de uma das duas expressões, dependendo se a expressão booleana é avaliada como verdadeira ou falsa, como o exemplo a seguir mostra:

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

:: operador

Use o qualificador de alias de namespace :: para acessar um membro de um namespace com alias. Você pode usar o qualificador :: somente entre dois identificadores. O identificador à esquerda pode ser qualquer um dos seguintes aliases:

Um alias de namespace criado com uma diretiva 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);
}

Um alias externo.
O alias global, que é o alias de namespace global. O namespace global é o namespace que contém namespaces e tipos que não são declarados dentro de um namespace nomeado. Quando usado com o qualificador ::, o alias global sempre faz referência ao namespace global, mesmo se houver o alias de namespace global definido pelo usuário.

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

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

$ operador

O caractere especial $ identifica uma string literal como uma string interpolada. Uma string interpolada é uma string literal que pode conter expressões de interpolação. Quando uma string interpolada é resolvida em uma string de resultado, os itens com expressões de interpolação são substituídos pelas representações de string dos resultados da expressão.

Em Strings interpoladas, o cifrão ($) é usado para informar ao compilador C# que a string seguinte deve ser interpretada como uma String interpolada. As chaves encapsulam os valores (das variáveis) a serem incluídos no texto.

Para identificar uma string literal como uma string interpolada, anexe-a com o símbolo $. Você não pode ter nenhum espaço em branco entre o $ e o " que inicia uma string literal.

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 programação operadores microsoft windows dotnet