Operadores de ferrugem

Como na vida real, os operadores da programação nos ajudam a definir e executar funções específicas usando uma linguagem de programação. Qualquer linguagem de programação auto-respectiva fornece um conjunto de operadores que podemos usar para executar operações. Os operadores comuns incluem operadores matemáticos, operadores lógicos, etc.

Este guia discutirá como trabalhar com vários operadores fornecidos pela linguagem de programação de ferrugem.

Vamos começar ..

Operadores R8UST

Rust fornece o seguinte conjunto de operadores:

1. Operadores aritméticos
2. Operadores lógicos
3. Operadores de comparação
4. Operadores bitwise
5. Operadores de atribuição de compostos

Operadores aritméticos de ferrugem

Como o nome sugere, os operadores aritméticos nos permitem executar operações aritméticas em um conjunto de operandos. As operações matemáticas comuns incluem adição, subtração, divisão, etc.

A seguir, são apresentados o conjunto popular de operadores aritméticos:

Símbolo do operador	Nome do operador	Descrição
+	Adição aritmética	Retorna a soma de dois ou mais operandos
-	Subtração aritmética	Retorne a diferença entre dois ou mais operandos.
*	Multiplicação aritmética	Retorna o produto de dois ou mais operando
/	Divisão Aitmética	Retorna o quociente do dividendo do operando esquerdo pelo operando direito
%	Restante aritmético.	Retorna o restante da divisão do operando esquerdo pelo operando direito.

Podemos ilustrar como usar os operadores aritméticos na ferrugem, como mostrado abaixo:

fn main ()
// operadores aritméticos
Seja x = 10;
Seja y = 2;
println!("Sum: ", x + y);
println!("Diffince: ", x - y);
println!("Produto: ", x * y);
println!("Quociente: ", x / y);
println!("Modulo: ", x % y);

O código acima deve retornar:

Operadores lógicos de ferrugem

A segunda categoria de operadores suportados pelo Rust Lang são operadores lógicos. Esses tipos de operadores são usados ​​para combinar duas ou mais condições booleanas. Os operadores lógicos sempre retornarão um valor booleano.

Eles incluem:

Símbolo do operador	Nome do operador	Descrição
&&	Curto-circuito lógico e	Retorna true se todas as condições especificadas avaliarem para serem verdadeiras.
||	Curto-circuito lógico ou	Retorna verdadeiro se pelo menos uma das condições especificadas for verdadeira.
!	Lógico não	Nega o resultado de uma expressão booleana. Se a condição for verdadeira, o operador não retornar.

Exemplo de implementação de código é como mostrado:

fn main ()
// operadores aritméticos
Seja x = true;
Seja y = false;
println!("Lógico e: ", (x && y));
println!("Lógico ou: ", (x || y));
println!("Lógico não: ", (!x));
println!("Lógico não: ", (!y));

O código acima deve retornar como:

Operadores de comparação de ferrugem

Os operadores de comparação comparam dois operandos e retornam um valor booleano com base na condição.

Esses operadores incluem:

Símbolo do operador	Nome do operador	Descrição
>	Maior que	Retorna true se o operando à esquerda for maior que o operando direito.
<	Menor que	Retorna true se o operando esquerdo for menor que o operando direito.
> =	Melhor que ou igual a	Retorna true se o operando esquerdo for maior ou igual ao operando direito.
<=	Menos que ou igual a	Retorna true se o operando esquerdo for menor ou igual ao operando certo.
==	Igual a	Retorne true se o operando esquerdo for igual ao operando direito.
!=	Não igual a	Retorna true se o operando esquerdo não for igual ao operando direito.

Podemos ilustrar o uso dos operadores de comparação, conforme mostrado no código abaixo:

fn main ()
Seja x = 10;
Seja y = 2;
println!("é x maior que y: ", (x> y));
println!("é x menor que y: ", (x < y));
println!("é x igual a y: ", (x == y));
println!("é x maior ou igual a: ", (x> = y));
println!("é x menor ou igual a: ", (x <= y));
println!("X não é igual y: ", (x != y));

O código acima deve retornar:

Operadores de ferrugem bitwee

Os operadores bitwise são usados ​​para executar operações bitwise. Eles incluem:

Símbolo do operador	Nome do operador	Descrição
&	Bit nejudado e	Executa booleano e em cada bit.
|	Bit nejudado ou	Execute booleano ou em cada bit
^	Bitwise xor	Executa booleano exclusivo ou em cada bit.
!	Bitwise não	Executa não unário.
<<	Esquerda de bitshift	muda o operando de bit esquerdo para a esquerda pela quantidade especificada pelo operando direito.
>>	Rishift certo	Muda o operando esquerdo pelo valor especificado pelo operando direito.

Um exemplo de código -fonte é mostrado abaixo:

fn main ()
Seja x = 10;
Seja y = 2;
println!("Bitwise e: ", (x & y));
println!("Bitwise ou: ", (x | y));
println!("Bitwise exclusivo ou: ", (x ^ y));
println!("Esquerda Bitshift ", (x << y));
println!("Desshift de bits direito: ", (x >> y));
println!("Bitwise não: ", (!x));

O código acima deve retornar a saída como mostrado:

Bitwise e: 2
Bitwise ou: 10
Bitwise exclusivo ou: 8
Esquerda Bitshift 40
Desshift de bits certo: 2
Bitwise não: -11

Operadores de atribuição de composto de ferrugem

Os operadores de atribuição de compostos são usados ​​para atribuir o valor à direita ao valor à esquerda. Esses incluem:

Símbolo do operador	Nome do operador
+=	Adição e atribuição aritmética
-=	Subtração e atribuição aritmética
*=	Multiplicação e atribuição aritmética
/=	Divisão aritmética e atribuição
>> =	Deslocamento direito e atribuição
<<=	Deslocamento e atribuição de esquerda
%=	Restante aritmético e atribuição
& =	Bitwise e e atribuição
| =	Bitmente ou e atribuição
^=	Exclusiva bitwise ou e atribuição

Conclusão

Este artigo discutiu os operadores de ferrugem e como podemos usá -los em nossos programas. Verifique a documentação da ferrugem para explorar.

Obrigado pela leitura!!