Operadores imprescindibles de Unity C#

Unity es un motor de juegos que hace mucho "heavy-lifting" para los desarrolladores en términos de funcionalidad y les permite concentrarse por completo en el proceso de desarrollo. Utiliza C# como lenguaje de programación principal.

Como ocurre con cualquier lenguaje de programación, C# consta de una serie de funciones especiales, tipos, clases, bibliotecas, etc., pero también tiene una lista de símbolos especiales (operadores), cada uno de los cuales tiene su propia función. En esta publicación, enumeraré esos símbolos y explicaré lo que hacen, de modo que la próxima vez que abra un script, pueda comprender rápidamente lo que significa cada parte.

Los operadores en C# son algunos símbolos especiales que realizan alguna acción en los operandos.

En C#, hay 6 tipos de operadores integrados: operadores aritméticos, operadores de comparación, operadores lógicos booleanos, operadores bit a bit y de desplazamiento, operadores de igualdad y operadores varios. Conocerlos todos te convertirá instantáneamente en un mejor programador.

1. Operadores aritméticos

Los siguientes operadores realizan operaciones aritméticas con operandos de tipo numérico:

  • Operadores unarios ++ (incremento), -- (decremento), + (más) y - (menos)
  • Operadores binarios * (multiplicación), / (división), % (resto), + (suma) y - (resta)

Operador de incremento++

El operador "add one" (o ++) significa += 1, en otras palabras, es una forma rápida de agregar un número entero a un valor numérico, sin tener que escribir código adicional. Este operador se puede agregar antes del valor o después del valor, lo que daría como resultado un comportamiento 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 --

El operador "subtract one" es lo opuesto a ++ (-= 1), lo que significa que resta un número entero de un valor numérico. También se puede agregar antes o después de un 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

Operadores unarios + y -

El operador unario + devuelve el valor de su operando y el operador unario - calcula la negación numérica de su 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 multiplicación *

El operador de multiplicación * calcula el producto multiplicado de sus 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 división /

El operador de división / divide su operando de la izquierda por su operando de la derecha.

Si uno de los operandos es decimal, otro operando no puede ser ni float ni double, porque ni float ni double se pueden convertir implícitamente a decimal. Debe convertir explícitamente el operando flotante o doble al 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

Resto operador %

El operador de resto % calcula el resto después de dividir su operando de la izquierda por su operando de la derecha.

  • Para los operandos de tipo entero, el resultado de a %b es el valor producido 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 los operandos decimales, el operador de resto % es equivalente al operador de resto del 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 suma +

El operador de suma + calcula la suma de sus operandos. También puede usar el operador + para la concatenación de cadenas y la combinación de delegados.

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

El operador de resta - resta su operando de la derecha de su operando de la izquierda. También puede utilizar el operador - para la eliminación de delegados.

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 comparación

La comparación < (less than), > (greater than), <= (less than or equal), and >= (mayor o igual), también conocida como relacional, los operadores comparan sus operandos. Esos operadores son compatibles con todos los tipos numéricos integrales y de coma flotante.

Operador menor que <

El operador < devuelve verdadero si su operando de la izquierda es menor que su operando de la derecha, de lo contrario, es 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

Mayor que operador >

El operador > devuelve verdadero si su operando de la izquierda es mayor que su operando de la derecha, de lo contrario, devuelve 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 o igual <=

El operador <= devuelve verdadero si su operando de la izquierda es menor o igual que su operando de la derecha, falso en caso contrario.

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 mayor o igual >=

El operador >= devuelve verdadero si su operando de la izquierda es mayor o igual que su operando de la derecha, falso en caso contrario.

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

Los siguientes operadores realizan operaciones lógicas con operandos booleanos:

  • Unario! (negación lógica) operador.
  • Binario & (Y lógico), | (OR lógico) y ^ (OR exclusivo lógico). Esos operadores siempre evalúan ambos operandos.
  • && binario (AND lógico condicional) y || (OR lógico condicional) operadores. Esos operadores evalúan el operando de la derecha solo si es necesario.

¡Operador de negación lógica!

El prefijo unario ! operador calcula la negación lógica de su operando. Es decir, produce verdadero, si el operando se evalúa como falso, y falso, si el operando se evalúa como verdadero.

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

Operador lógico AND &

El operador & calcula el AND lógico de sus operandos. El resultado de x & y es verdadero si tanto x como y se evalúan como verdaderos. De lo contrario, el resultado es falso.

El operador & evalúa ambos operandos incluso si el operando de la izquierda se evalúa como falso, por lo que el resultado de la operación es falso independientemente del valor de el operando de la derecha.

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 ^

El operador ^ calcula el OR exclusivo lógico, también conocido como XOR lógico, de sus operandos. El resultado de x ^ y es verdadero si x se evalúa como verdadero e y se evalúa como falso, o x se evalúa como falso e y se evalúa como verdadero. De lo contrario, el resultado es falso. Es decir, para los operandos booleanos, el operador ^ calcula el mismo resultado que el operador de desigualdad !=.

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 |

el | operador calcula el OR lógico de sus operandos. El resultado de x | y es verdadero si x o y se evalúa como verdadero; de lo contrario, el resultado es falso.

The | El operador evalúa ambos operandos incluso si el operando de la izquierda se evalúa como verdadero, de modo que el resultado de la operación es verdadero independientemente del valor del operando de la derecha.

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

El operador AND lógico condicional &&, también conocido como operador AND lógico "short-circuiting", calcula el AND lógico de sus operandos. El resultado de x && y es verdadero si tanto x como y se evalúan como verdaderos; de lo contrario, el resultado es falso. Si x se evalúa como falso, y no se evalúa.

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

El operador OR lógico condicional ||, también conocido como operador OR lógico "short-circuiting", calcula el OR lógico de sus operandos. El resultado de x || y es verdadero si x o y se evalúa como verdadero. De lo contrario, el resultado es falso. Si x se evalúa como verdadero, y no se evalúa.

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 y de desplazamiento

Los siguientes operadores realizan operaciones bit a bit o de desplazamiento con operandos de tipo numérico integral o tipo char:

  • Operador unario ~ (complemento bit a bit)
  • Operadores de desplazamiento binarios << (left shift) and >> (desplazamiento a la derecha)
  • Binario & (Y lógico), | (OR lógico) y ^ (OR exclusivo lógico) operadores

Operador de complemento bit a bit ~

El operador ~ produce un complemento bit a bit de su operando invirtiendo 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 desplazamiento a la izquierda <<

El operador << desplaza su operando de la izquierda a la izquierda el número de bits definido por su operando de la derecha. Para obtener información sobre cómo el operando de la derecha define el número de turnos, consulte la sección Número de turnos de los operadores de turnos.

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 desplazamiento a la derecha >>

El operador >> desplaza su operando de la izquierda hacia la derecha el número de bits definido por su operando de la derecha.

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

Las posiciones de bits vacíos de orden superior se establecen según el tipo del operando de la izquierda de la siguiente manera:

  • Si el operando de la izquierda es de tipo int o long, el operador de desplazamiento a la derecha realiza un desplazamiento aritmético: el valor del bit más significativo (el bit de signo) del operando de la izquierda se propaga al bit vacío de orden superior. posiciones. Es decir, las posiciones de bits vacíos de orden superior se establecen en cero si el operando de la izquierda no es negativo y se establecen en uno si es 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
  • Si el operando de la izquierda es de tipo uint o ulong, el operador de desplazamiento a la derecha realiza un desplazamiento lógico: las posiciones de bit vacías de orden superior siempre se establecen en cero.
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 lógico AND &

El operador & calcula el AND lógico bit a bit de sus operandos integrales.

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 ^

El operador ^ calcula el OR exclusivo lógico bit a bit, también conocido como XOR lógico bit a bit, de sus operandos integrales.

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 |

el | El operador calcula el OR lógico bit a bit de sus operandos integrales.

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 igualdad

Los operadores == (igualdad) y != (desigualdad) verifican si sus operandos son iguales o no.

Operador de igualdad ==

El operador de igualdad == devuelve verdadero si sus operandos son iguales, falso en caso contrario.

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 desigualdad !=

El operador de desigualdad != devuelve verdadero si sus operandos no son iguales, falso en caso contrario. Para los operandos de los tipos incorporados, la expresión x != y produce el mismo resultado que la expresión !(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 varios

Los operadores misceláneos comunes son ?: para comprobaciones condicionales, :: para acceder a un miembro de un espacio de nombres con alias y $ para la interpolación de cadenas.

?: operador

El operador condicional ?:, también conocido como operador condicional ternario, evalúa una expresión booleana y devuelve el resultado de una de las dos expresiones, dependiendo de si la expresión booleana se evalúa como verdadera o falsa, como muestra el siguiente ejemplo:

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

:: operador

Utilice el calificador de alias de espacio de nombres :: para acceder a un miembro de un espacio de nombres con alias. Puede usar el calificador :: solo entre dos identificadores. El identificador de la izquierda puede ser cualquiera de los siguientes alias:

  • Un alias de espacio de nombres creado con una directiva de alias de uso:
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);
}
  • Un alias externo.
  • El alias global, que es el alias del espacio de nombres global. El espacio de nombres global es el espacio de nombres que contiene espacios de nombres y tipos que no están declarados dentro de un espacio de nombres con nombre. Cuando se usa con el calificador ::, el alias global siempre hace referencia al espacio de nombres global, incluso si hay un alias de espacio de nombres global definido por el usuario.
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

El carácter especial $ identifica un literal de cadena como una cadena interpolada. Una cadena interpolada es un literal de cadena que puede contener expresiones de interpolación. Cuando una cadena interpolada se resuelve en una cadena de resultado, los elementos con expresiones de interpolación se reemplazan por las representaciones de cadena de los resultados de la expresión.

En cadenas interpoladas, el signo de dólar ($) se usa para indicarle al compilador de C# que la cadena que le sigue debe interpretarse como una cadena interpolada. Las llaves encapsulan los valores (de las variables) a incluir en el texto.

Para identificar un literal de cadena como una cadena interpolada, antepóngalo con el símbolo $. No puede tener ningún espacio en blanco entre el $ y el " que inicia un literal de cadena.

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.
unidad unity3d csharp programación operadores microsoft windows dotnet
Artículos sugeridos
Comprensión de funciones y llamadas a métodos
Introducción al lenguaje de secuencias de comandos Unity C#
Implementación de operaciones aritméticas básicas en el código de Unity
Cómo convertirse en un mejor programador en Unity
Creando objetos interactivos en Unity
Implementación de interacciones cinéticas en Unity
Abrir cajones y armarios con llaves específicas en Unity
Más publicaciones »
Articulos populares
Creación de un sistema de elaboración de artículos e inventario en Unity
Cómo reproducir archivos de vídeo en Unity
Codificación de un sistema de inventario simple con arrastrar y soltar la interfaz de usuario en Unity
Mostrar texto al tocar un objeto en Unity
Mover objetos con entrada de desplazamiento en Unity
Crear juegos por turnos en Unity
Creando un juego inspirado en Pac-Man en Unity