Eu pretendia escrever um post decente sobre as declarações F #, mas pensei que, honestamente, não podia ver muitas vantagens em simplesmente repetir o que já está disponível gratuitamente no MSDN, que lista TODAS as declarações F #.
Você pode encontrar uma lista completa de todos os operadores e caracteres de F # nesta página do MSDN.Se você seguir este link, a primeira coisa que entenderá é que o F # possui muitos operadores e símbolos, muitos para eu incluir em uma postagem do blog. Com isso em mente, assumi a intenção de criar meio post decente sobre os operadores e decidi reduzir um pouco o escopo para incluir apenas uma discussão dos operadores mais comuns, então acho que você poderia dizer que isso será apenas 1/4 ou 1/8 de um post decente, pelo qual peço desculpas humildemente.
Agora, antes de começarmos, eu só queria dizer que passarei apenas pelos operadores mais comuns; Você provavelmente terá que estudar o link do MSDN que eu incluí no começo deste post quando realmente começar a usar o F #, mas agora espero que aqueles em que paramos sejam suficientes para começarmos.
Operadores aritméticos
+ Somatório
Incontrolável. Uma possível condição de estouro é quando os números são somados e a soma excede o valor absoluto máximo suportado pelo tipo.
- Subtração
Incontrolável. Possível condição de preenchimento insuficiente quando tipos não assinados são subtraídos ou quando valores de ponto flutuante são muito pequenos para serem representados pelo tipo.
* Multiplicação
Incontrolável. Uma possível condição de estouro se os números forem multiplicados e o produto exceder o valor absoluto máximo suportado pelo tipo.
/ Divisão
A divisão por zero gera uma DivideByZeroException para tipos inteiros. Para tipos de ponto flutuante, dividir por zero fornece valores especiais de ponto flutuante + Infinito ou-Infinito. Uma condição de preenchimento insuficiente também é possível quando o número do ponto flutuante é muito pequeno para ser representado por um tipo.
Módulo%
Retorna o restante de uma operação de divisão. O sinal do resultado é o mesmo que o sinal do primeiro operando.
** Exposição
Possível condição de estouro quando o resultado exceder o valor absoluto máximo para o tipo. O operador de exponenciação funciona apenas com tipos de ponto flutuante.
Demo
//Arithmetic operators printfn "25 + 25 = %i" (25 + 25) printfn "75 - 25 = %i" (75 - 25) printfn "12 * 12 = %i" (12 * 12) printfn "100 / 4 = %i" (100 / 4) printfn "101 %% 10 = %i" (101
E aqui está o resultado do lançamento:
Operadores binários
A tabela a seguir mostra os operadores de comparação binária disponíveis para tipos inteiros e tipos de ponto flutuante. Esses operadores retornam valores do tipo bool.
= Igual
Este não é um operador de atribuição. É usado apenas para comparação. Este é um operador universal.
> mais de
Este é um operador universal.
<menos que
Este é um operador universal.
> = maior ou igual
Este é um operador universal.
<= maior ou igual
Este é um operador universal.
<> Diferente
Este é um operador universal.
//Binary operators printfn "25 = 25 = %b" (25 = 25) printfn "26 > 25 = %b" (26 > 25) printfn "26 < 25 = %b" (26 < 25) printfn "26 >= 25 = %b" (26 >= 25) printfn "26 <= 25 = %b" (26 <= 25) printfn "'a' <= 'b' = %b" ('a' <> 'b') //how about a more complex example, a tuple printfn "(1,'a') = (2,'a') = %b" ((1,'a') = (2,'a')) printfn "(1,'a') = (1,'a') = %b" ((1,'a') = (1,'a')) printfn "Some(1) = Some(2) = %b" (Some(1) = Some(2)) printfn "Some(2) = Some(2) = %b" (Some(2) = Some(2))
Operadores booleanos
A tabela a seguir lista os operadores lógicos disponíveis no F #. O único tipo suportado por esses operadores é o tipo bool.
não
Negação booleana
||
OR lógico
&&
Lógico e
Aqui está uma pequena demonstração dos operadores booleanos listados acima
//Boolean operators printfn "not true = %b" (not true) printfn "true || false = %b" (true || false) printfn "true && true = %b" (true && true) printfn "true && false = %b" (true && false)
Operadores de bit
A tabela a seguir descreve os operadores de bits que são suportados para tipos inteiros descompactados em F #.
&&&
O operador AND bit a bit. Como resultado, os bits têm um valor de 1 se e somente se os bits correspondentes nos dois operandos de origem forem 1.
|||
O operador OR bit a bit. Os bits, como resultado, terão um valor 1 se qualquer um dos bits correspondentes nos operandos de origem for 1.
^^^
O operador exclusivo bit a bit "OR". Os bits, como resultado, têm um valor de 1 se e somente se os bits nos operandos originais tiverem valores desiguais.
~~~
Operador de negação bit a bit. Este é um operador unário que produz um resultado no qual todos os 0 bits no operando original são convertidos em 1 bit e todos os 1 bits são convertidos em 0 bits.
<<<
Operador de deslocamento à esquerda bit a bit. O resultado é o primeiro operando com os bits deslocados para a esquerda pelo número de bits no segundo operando. Os bits deslocados da posição mais significativa não se transformam na posição menos significativa. Os bits menos significativos são preenchidos com zeros. O tipo do segundo argumento é int32.
>>>
Operador de mudança à direita bit a bit. O resultado é um primeiro operando com os bits deslocados para a direita pelo número de bits no segundo operando. Os bits deslocados da posição menos significativa não se transformam na posição mais significativa. Para tipos não assinados, os bits mais significativos são preenchidos com zeros. Para tipos assinados, os bits mais significativos são preenchidos com outros. O tipo do segundo argumento é int32.
//Bit shift operators //&&& and printfn "2 &&& 4 (which is 0010 &&& 0100, should be 0) = %X" (2 &&& 4) printfn "2 &&& 3 (which is 0010 &&& 0011, should be 2) = %X" (2 &&& 3) //||| or printfn "2 ||| 4 (which is 0010 ||| 0100, should be 6) = %X" (2 ||| 4) printfn "2 ||| 3 (which is 0010 ||| 0011, should be 3) = %X" (2 ||| 3) //^^^ xor printfn "2 ^^^ 4 (which is 0010 ^^^ 0100, should be 6) = %X" (2 ^^^ 4) printfn "2 ^^^ 3 (which is 0010 ^^^ 0011, should be 1) = %X" (2 ^^^ 3) //^^^ negate printfn "~~~4 (which is not 0100, should be 1011 (B hex), or 11 decimal) = %X" (~~~4) //<<< bit shift left printfn "4 <<< 1 (which is 0100 <<< by 1 place left , should be 1000 (8 hex), or 8 decimal) = %X" (4 <<< 1) //>>> bit shift right printfn "4 >>> 1 (which is 0100 >>> by 1 place right , should be 0010 (2 hex), or 2 decimal) = %X" (4 >>> 1)
Sobrecarga do operador
Como mencionei, haverá momentos em que você precisará implementar sua própria lógica de operador. Em outras linguagens .NET, isso pode ser conseguido fornecendo sobrecargas ao seu próprio operador. Não é de surpreender que você precise fazer o mesmo em F #. Eu não queria entrar em aulas e OO ainda, mas parece ser consistente com a discussão atual, então vamos ver como você pode implementar seus próprios operadores em F #.
Eu roubei novamente do MSDN. O código a seguir ilustra uma classe de vetor que possui apenas dois operadores: um para menos unário e outro para multiplicar por um escalar. Neste exemplo, são necessárias duas sobrecargas para multiplicação escalar, pois o operador deve trabalhar independentemente da ordem em que o vetor e o escalar aparecem.
type Vector(x: float, y : float) = member this.x = x member this.y = y static member (~-) (v : Vector) = Vector(-1.0 * vx, -1.0 * vy) static member (*) (v : Vector, a) = Vector(a * vx, a * vy) static member (*) (a, v: Vector) = Vector(a * vx, a * vy) override this.ToString() = this.x.ToString() + " " + this.y.ToString()