Operadores imprescindibles de Unity C#

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

Como 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é qué hacen, de modo que la próxima vez que abra un script, pueda comprender rápidamente qué 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 de desplazamiento y de bits, 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 tipos numéricos:

  • 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, es decir, es una forma rápida de sumar un entero a un valor numérico, sin tener que escribir código adicional. Este operador se puede agregar antes 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 el opuesto de ++ (-= 1), lo que significa que resta un entero a 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 son convertibles implícitamente a decimal. Debe convertir explícitamente el operando float o double 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

Operador de resto %

El operador de resto % calcula el resto después de dividir su operando izquierdo por su operando derecho.

  • Para los operandos de tipos enteros, 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 utilizar 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 el operando de la derecha del operando de la izquierda. También puede utilizar el operador - para eliminar 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

Los operadores de comparación < (less than), > (greater than), <= (less than or equal), and >= (mayor o igual que), también conocidos como operadores relacionales, comparan sus operandos. Estos operadores son compatibles con todos los tipos numéricos enteros y de punto flotante.

Operador menor que <

El operador < devuelve verdadero si su operando de la izquierda es menor 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: 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

Operador mayor que >

El operador > devuelve verdadero si su operando de la izquierda es mayor 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: 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 que <=

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

  • Operador unario ! (negación lógica).
  • Operadores binarios & (AND lógico), | (OR lógico) y ^ (OR lógico exclusivo). Estos operadores siempre evalúan ambos operandos.
  • Operadores binarios && (AND lógico condicional) y || (OR lógico condicional). Estos operadores evalúan el operando de la derecha solo si es necesario.

Operador de negación lógica !

El operador de prefijo unario ! 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, de modo que el resultado de la operación es falso independientemente del valor del 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 lógico OR |

El operador | calcula el OR lógico de sus operandos. El resultado de x | y es verdadero si x o 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 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 lógico condicional AND &&

El operador lógico condicional AND &&, también conocido como operador lógico AND "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 lógico condicional OR ||

El operador lógico condicional OR ||, también conocido como operador lógico OR "short-circuiting", calcula el OR lógico de sus operandos. El resultado de x || y es verdadero si x o y se evalúan como verdaderos. 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 de desplazamiento y de bits

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

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

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 izquierdo hacia la izquierda según la cantidad de bits definida por su operando derecho. Para obtener información sobre cómo el operando derecho define el recuento de desplazamientos, consulte la sección Recuento de desplazamientos de los operadores de desplazamiento.

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 según la cantidad de bits definidos 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ías de orden superior se establecen en función del tipo del operando izquierdo 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 a las posiciones de bits vacíos de orden superior. 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 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 bits 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 lógico OR |

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) comprueban 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, y falso en caso contrario. Para los operandos de los tipos integrados, 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 varios comunes son ?: para verificaciones condicionales, :: para acceder a un miembro de un espacio de nombres con alias y $ para 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 utilizar 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 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);
}
  • 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 utiliza con el calificador::, el alias global siempre hace referencia al espacio de nombres global, incluso si existe el alias del 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 una cadena literal como una cadena interpolada. Una cadena interpolada es una cadena literal que puede contener expresiones de interpolación. Cuando una cadena interpolada se resuelve en una cadena de resultados, los elementos con expresiones de interpolación se reemplazan por las representaciones de cadena de los resultados de la expresión.

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

Para identificar una cadena literal como una cadena interpolada, antepóngala con el símbolo $. No puede haber ningún espacio en blanco entre el $ y el " que inicia una cadena 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.
unidadunity3dcsharpprogramaciónoperadoresmicrosoftwindowsdotnet
Artículos sugeridos
Configuración y uso de Visual Scripting en Unity
Trabajar con tablas hash en Unity
Cómo reiniciar un juego en Unity
Cómo añadir mecánicas de sigilo en Unity
Creación de un gestor de juegos sencillo en Unity
Cómo crear un controlador de armas en Unity
Implementación de mecánicas de tiro con arco en Unity
Articulos populares
Guía de MonoBehaviour en Unity
Trabajar con Arrays y Listas en Unity Code
Cómo cambiar la resolución de la pantalla en el juego Unity
Comprender la arquitectura basada en componentes de Unity
Introducción a la Máquina de Estado en Unity
Creando un sistema de combate cuerpo a cuerpo en Unity
Script para capturar objetos en Unity
Enlaces
Unity 6