Compreendendo os operadores do F#

Neste artigo, você aprenderá como usar os operadores do F# com eficiência , seja você novo no idioma ou um profissional. Discutiremos os diferentes operadores que podem ser usados ​​no F# e sua sintaxe .

A linguagem de programação F# fornece uma ampla variedade de operadores que podem ser usados ​​para operações como aritmética , comparações , lógica e muitas outras operações.

Índice-

Operadores F#

Os operadores F# são importantes porque fornecem uma maneira concisa e expressiva de executar operações comuns em vários tipos de dados . Sem operadores, você precisaria escrever funções complexas para executar essas operações, resultando em um código mais longo e menos legível.

Os operadores F# são projetados para trabalhar com o paradigma de programação funcional, que enfatiza dados imutáveis ​​e funções puras.

Eles são projetados para funcionar perfeitamente com outros recursos do F# , como correspondência de padrões, compreensões de lista e inferência de tipos. Isso permite que você escreva um código conciso, expressivo e fácil de entender.

Há vários operadores no F# que são semelhantes aos operadores em outras linguagens de programação, mas o F# tem alguns recursos específicos que o tornam especialmente adequado para trabalhar com operadores em comparação com outras linguagens.

Um compilador usa um operador para instruí-lo a executar uma tarefa específica na forma de uma operação matemática ou lógica.

Existem muitos operadores internos no F# e alguns dos tipos mais comuns de operadores estão listados abaixo:

  • Operadores aritméticos
  • Operadores de comparação
  • Operadores booleanos
  • Operadores bit a bit

F# Operadores Aritméticos

Existem vários operadores aritméticos disponíveis na linguagem F#, conforme mostrado na tabela a seguir.

Vamos supor que a variável x contém 5 e a variável y contém 15, então acontecerá o seguinte:

operadores Visão geral Exemplos
+ A adição de dois operandos é feita x + y vai dar 25
– A subtração de dois operandos é feita x – y dará -10
* A multiplicação de dois operandos é feita x * y vai dar 75
/ A divisão de dois operandos é feita y/x vai dar 3
% Imprime os restos de duas variáveis y % ​​x dará 0
** Operador de Exponenciação: Este operador pode ser usado em operandos que foram multiplicados por outro operando para obter o resultado. y**x dará 155

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
let x : int32 = 5
let y : int32 = 15
let mutable z = x + y
printfn "\nsum is: %d" z
z <- x – y;
printfn "\nSubtraction is: %d" z
z <- x * y;
printfn "\nMultiplication is: %d" z
z <- x / y;
printfn "\nDivision is: %d" z
z <- x % y;
printfn "\nModulus is: %d" z
let a = 5.0
let b = 15.0
let c = b ** a
printfn "\nExponentiation is: %A" c
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Saída:
Sum is: 20Subtraction is: -10
Multiplication is: 75
Division is: 0
Modulus is: 5
Exponentiation is: 759375.0

Operadores de Comparação

Há vários operadores de comparação com suporte na linguagem F# e eles são mostrados na tabela a seguir.

O termo comparação binária refere-se à comparação de dois tipos de dados, integrais e valores de ponto flutuante.

Um valor do tipo bool é retornado por cada um desses operadores.

Vamos supor que a variável x contém 5 e a variável y contém 15, então acontecerá o seguinte:

operadores Visão geral Exemplos
= Esta função determina se dois operandos são iguais ou não, comparando seus valores. A condição torna-se verdadeira se os operandos forem iguais. (x == y) não é verdade.
<> A função verifica se dois operandos possuem os mesmos valores ou não. Esta condição se tornará verdadeira se nenhum valor for igual, caso contrário, ela se tornará falsa. (x == y) é verdadeiro.
> Uma condição é verdadeira se o valor do operando esquerdo for maior que o valor do operando direito. Se não, então a condição é falsa. (x > y) não é verdade.
< Uma condição é verdadeira se o valor do operando direito for maior que o valor do operando esquerdo. Se não, então a condição é falsa. (x > y) é verdadeiro.
>= Uma condição é verdadeira se o valor do operando esquerdo for maior ou igual ao valor do operando direito. Se não, então a condição é falsa. (x >= y) não é verdadeiro.
<= Uma condição é verdadeira se o valor do operando direito for maior e igual ao valor do operando esquerdo. Se não, então a condição é falsa. (x <= y) é verdadeiro.

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
let mutable x : int32 = 5
let mutable y : int32 = 15
if (x = y)
then
printfn "x is equal to y\n"
else
printfn "x is not equal to y\n"
if (x <> y)
then
printfn "x is not equal to y\n"
else
printfn "x is equal to y\n"
if (x < y)
then
printfn "x is less than y\n"
else
printfn "x is not less than y\n"
if (x > y)
then
printfn "x is greater than y\n"
else
printfn "x is not greater than y\n"
if (x <= y)
then
printfn "x is less or equal to y\n"
else
printfn "x is a is greater than y\n"
if (x >= y)
then
printfn "x is greater or equal to y\n"
else
printfn "x is a is less than y\n"
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Saída:
x is not equal to y
x is not equal to y
x is less than y
x is not greater than y
x is less or equal to y
x is a is less than y

Operadores booleanos

Uma tabela é fornecida abaixo que lista todos os operadores booleanos com suporte no F#. Assumindo que a variável x é verdadeira e a variável y é falsa, então:

operadores Visão geral Exemplos
&& Também é chamado de operador booleano AND. Esta condição é verdadeira se ambos os operandos forem diferentes de zero. (x && y) é falso.
|| Também é chamado de operador OR booleano. Esta condição é verdadeira se algum dos dois operandos for diferente de zero. (x || y) é verdadeiro.
não Também é chamado de Operador Booleano NOT. Reverter o estado lógico de seus operandos. Ao usar o operador Logical NOT, uma condição verdadeira torna-se falsa e uma condição falsa torna-se verdadeira. not (x && y) é verdadeiro.

Example: 

1
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Saída:
X && Y Condition is true
X || Y Condition is true
not (x && y) Condition is not true
X && Y Condition is not true
X || Y Condition is true
not (x && y) Condition is true

Operadores bit a bit

Usando operadores bit a bit, você pode executar operações bit a bit.

Esta instrução mostra as tabelas de verdade para os operadores bit a bit ( AND ), bit a bit ( OR ) e OR exclusivo bit a bit:

p q p &&& q p ||| q p ^^^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

Suponha que x = 45 , e y = 15 , e então no formato binário eles serão os seguintes:

A = 0010 1101
B = 0000 1111
A&&&B = 0000 1101
A|||B = 0010 1111
A^^^B = 0010 0010
~~~A = 1101 0001

Abaixo está uma tabela que lista todos os operadores Bitwise com suporte na linguagem F#.

Se assumirmos que a variável x representa 45 e a variável y representa 15, podemos concluir:

operadores Visão geral Exemplos
&&& Usando um operador AND binário, se o bit estiver presente em ambos os operandos, ele é copiado para o resultado. (x &&& y) dará 13, que é 0000 1101
||| A função verifica se dois operandos possuem os mesmos valores ou não. Esta condição se tornará verdadeira se nenhum valor for igual, caso contrário, ela se tornará falsa. (x ||| y) dará 47, que é 0010 1111
^^^ Uma condição é verdadeira se o valor do operando esquerdo for maior que o valor do operando direito. Se não, então a condição é falsa. (x ^^^ y) dará 34, que é 0010 0010
~~~ Uma condição é verdadeira se o valor do operando direito for maior que o valor do operando esquerdo. Se não, então a condição é falsa. (~~~x) dará -46, que é 1101 0001 na forma de complemento de 2s.
<<< Uma condição é verdadeira se o valor do operando esquerdo for maior ou igual ao valor do operando direito. Se não, então a condição é falsa. x <<< 2 dará 180 que é 1011 0100
>>> Uma condição é verdadeira se o valor do operando direito for maior e igual ao valor do operando esquerdo. Se não, então a condição é falsa. x >>> 2 dará 11 que é 0000 1011

Example: 

1
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Saída:
x &&& y - Value of z is 13
x ||| y - Value of z is 47
x ^^^ y - Value of z is 34
~~~x - Value of z is -46
x <<< 2 - Value of z is 180
x >>> 2 - Value of z is 11

Precedência dos Operadores

Como você pode ver na tabela abaixo, os operadores e outras palavras-chave de expressão são classificados em ordem de precedência na linguagem F#, onde o operador de precedência mais baixa é exibido primeiro, seguido pelo operador de precedência mais alta.

operadores Associatividade
como Certo
quando Certo
| (cano) Esquerda
; Certo
deixar Não associativo
função, diversão, combinar, tentar Não associativo
se Não associativo
→ Certo
:= Certo
, Certo
ou, || Esquerda
&, && Esquerda
<op, >op, =, |op, &op Esquerda
&&& , |||, ^^^, ~~~, <<<, >>> Esquerda
^ op Certo
:: Certo
:?> Não associativo
– op, +op, (binário) Esquerda
* op, /op, %op Esquerda
** op Certo
fx (aplicativo de função) Esquerda
| (correspondência de padrão) Certo
Operadores de prefixo (+op, -op, %, %%, &, &&, !op, ~op) Esquerda
. Esquerda
f(x) Esquerda
f<tipos> Esquerda
Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.