Operadores de óxido

Como en la vida real, los operadores en la programación nos ayudan a definir y realizar funciones específicas utilizando un lenguaje de programación. Cualquier lenguaje de programación autónomo proporciona un conjunto de operadores que podemos usar para realizar operaciones. Los operadores comunes incluyen operadores matemáticos, operadores lógicos, etc.

Esta guía discutirá cómo trabajar con varios operadores proporcionados por el lenguaje de programación de Rust.

Comencemos ..

Operadores R8ust

Rust proporciona el siguiente conjunto de operadores:

1. Operadores aritméticos
2. Operadores logicos
3. Operadores de comparación
4. Operadores de bit a bit
5. Operadores de asignación compuesta

Operadores aritméticos de óxido

Como su nombre indica, los operadores aritméticos nos permiten realizar operaciones aritméticas en un conjunto de operandos. Las operaciones matemáticas comunes incluyen suma, resta, división, etc.

Los siguientes son el popular conjunto de operadores aritméticos:

Símbolo del operador	Nombre del operador	Descripción
+	Adición aritmética	Devuelve la suma de dos o más operandos
-	Resta aritmética	Devolver la diferencia entre dos o más operandos.
*	Multiplicación aritmética	Devuelve el producto de dos o más operandos
/	División aritmética	Devuelve el cociente del dividendo de operando izquierdo por el operando derecho
De %	Resto aritmético.	Devuelve el resto de la división del operando izquierdo por el operando derecho.

Podemos ilustrar cómo usar los operadores aritméticos en óxido como se muestra a continuación:

fn main ()
// operadores aritméticos
Sea x = 10;
Sea y = 2;
println!("Suma: ", x + y);
println!("Difernce: ", x - y);
println!("Producto: ", x * y);
println!("Cociente: ", x / y);
println!("Modulo: ", x % y);

El código anterior debería devolver:

Operadores lógicos de óxido

La segunda categoría de operadores compatibles con Rust Lang son los operadores lógicos. Estos tipos de operadores se utilizan para combinar dos o más condiciones booleanas. Los operadores lógicos siempre devolverán un valor booleano.

Incluyen:

Símbolo del operador	Nombre del operador	Descripción
&&	Cortocircuito lógico y	Devuelve verdadero si todas las condiciones especificadas se evalúan como verdaderas.
||	Cortocircuito lógico o	Devuelve verdadero si al menos una de las condiciones especificadas es verdadera.
!	Lógico no	Niega el resultado de una expresión booleana. Si la condición es verdadera, el no operador devuelve falso.

La implementación del código de ejemplo es como se muestra:

fn main ()
// operadores aritméticos
Sea x = verdadero;
Sea y = falso;
println!("Lógico y: ", (x && y));
println!("Lógico o: ", (x || y));
println!("Lógico no: ", (!X));
println!("Lógico no: ", (!y));

El código anterior debe devolver como:

Operadores de comparación de óxido

Los operadores de comparación comparan dos operandos y devuelven un valor booleano basado en la condición.

Estos operadores incluyen:

Símbolo del operador	Nombre del operador	Descripción
>	Mas grande que	Devuelve verdadero si el operando a la izquierda es mayor que el operando derecho.
<	Menos que	Devuelve verdadero si el operando izquierdo es menor que el operando correcto.
> =	Mayor qué o igual a	Devuelve verdadero si el operando izquierdo es mayor o igual al operando derecho.
<=	Menos que o igual a	Devuelve verdadero si el operando izquierdo es menor o igual al operando derecho.
==	Igual a	Devolver verdadero si el operando izquierdo es igual a la derecha operando.
!=	No igual a	Devuelve verdadero si el operando izquierdo no es igual a la derecha operando.

Podemos ilustrar el uso de los operadores de comparación, como se muestra en el código a continuación:

fn main ()
Sea x = 10;
Sea y = 2;
println!("es x mayor que y: ", (x> y));
println!("es x menos que y: ", (x < y));
println!("es x igual a y: ", (x == y));
println!("es x mayor o igual a: ", (x> = y));
println!("es x menor o igual a: ", (x <= y));
println!("x no es igual y: ", (x != y));

El código anterior debería devolver:

Oxx Operadores de bit a bit

Los operadores de bit a bit están acostumbrados a realizar operaciones bit a bit a. Incluyen:

Símbolo del operador	Nombre del operador	Descripción
Y	Bit a bit y	Realiza booleano y en cada bit.
|	Bit a bit o	Realizar boolean o en cada bit
^	Xor bit a bit	Realiza un booleano exclusivo o en cada bit.
!	Bit a no	Realiza unary no.
<<	Desplazamiento de bits izquierdo	cambia el operando del bit izquierdo hacia la izquierda por la cantidad especificada por el operando derecho.
>>	Desplazamiento de bits correcto	Cambia el operando izquierdo por el valor especificado por el operando derecho.

A continuación se muestra un código fuente de ejemplo:

fn main ()
Sea x = 10;
Sea y = 2;
println!("Bitwise y: ", (x & y));
println!("Bitwise o: ", (x | y));
println!("Exclusivo bit a bit o: ", (x ^ y));
println!("Left bitshift ", (x << y));
println!("Bitshift correcto: ", (x >> y));
println!("Bitwise no: ", (!X));

El código anterior debe devolver la salida como se muestra:

Bit a bit y: 2
Bit a bit o: 10
Bitwise exclusivo o: 8
Left Bitshift 40
Bitshift correcto: 2
Bit a bit no: -11

Operadores de asignación compuesta de óxido

Los operadores de asignación compuesta se utilizan para asignar el valor a la derecha al valor a la izquierda. Éstas incluyen:

Símbolo del operador	Nombre del operador
+=	Adición y asignación aritmética
-=	Sustracción aritmética y asignación
*=	Multiplicación aritmética y asignación
/=	División aritmética y asignación
>> =	Desplazamiento a la derecha y asignación
<<=	Desplazamiento a la izquierda y asignación
%=	Resto aritmético y asignación
& =	Bit a bit y y asignación
| =	Bitwise o y asignación
^=	Bit a bitwise o asignación

Conclusión

Este artículo discutió los operadores de óxido y cómo podemos usarlos en nuestros programas. Consulte la documentación de Rust para explorar.

Gracias por leer!!