Neste post, veremos as ligações em F #, em particular, vamos ver Let / Use / Do. Agora você pode estar se perguntando o que são ligações e, como ainda não as examinamos, agora é a hora de falar sobre isso.
Simplificando, uma ligação associa um identificador a um valor ou função.
Vamos
Você usa a palavra-chave let para associar um nome a um valor ou função. Na verdade, há um uso sutil e diferente de Let, onde um é declarado no nível superior do módulo e, em seguida, o outro, onde definimos algum contexto local. Aqui está um exemplo de ambos:
module DemoModule = let someFunction = let a = 1 let b = 2 a * b
Poderíamos acessar someFunction usando um nome completo, como DemoModule.someFunction, mas as ligações aninhadas Let (a, b) estão disponíveis apenas para o nível superior de Let. Normalmente, você vê mais casos quando usamos a ligação Let para declarar alguns valores do módulo interno, então vamos concentrar nossos esforços lá (embora seja importante saber que você pode usar Let no nível do módulo).
Então, vejamos mais alguns exemplos.
let aString ="this is a string" let aInt = 12 let aDecimal = 12.444 let aPiFunction () = Math.PI let aSquareRootFunction (x) = Math.Sqrt(x) let aFullyTypedSquareRootFunction (x :float) = Math.Sqrt(x) let a,b = "a","tuple"
Você pode ver que podemos usar a ligação Let para vincular a vários valores, que podem ser de vários tipos, como:
- Inteiro
- Decimal
- Função sem parâmetros de entrada
- Função com parâmetros de entrada (onde o sistema de inferência lógica do tipo F # escolherá o tipo corretamente)
- Uma função que possui tipos de parâmetros totalmente definidos
- Tupla (neste caso, String * String tupla)
Em outros lugares, você pode ver a ligação Let na classe, mas discutiremos isso com mais detalhes no próximo artigo desta série.
Você pode ler mais sobre Permitir ligação no MSDN.Use
A ligação Use é muito semelhante à ligação Let, pois vincula o valor ao resultado da expressão. A principal diferença é que a ligação Usar foi projetada para trabalhar com tipos IDisposable e exclui automaticamente um valor quando ele não está mais no escopo. Isso é muito parecido com a palavra-chave .NET using, embora eu não acredite que a ligação F # Use seja exatamente a mesma que a usada no .NET, pois a palavra-chave using no .NET é na verdade uma tentativa / finalmente com uma chamada para Dispose ( ) finalmente.
Já vimos um exemplo da ligação Usar na última postagem sobre formatação de texto, mas apenas para lembrar, vamos dar uma outra olhada nisso.
use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "This is a string line %s\r\n" "cat" fprintf sw "This is a int line %i" 10 sw.Close()
Neste exemplo, a ligação Use garante que o método StreamWriter chame seu método Dispose () após chamar sw.Close (), mostrado acima.
Use apenas funciona com IDisposables e você receberá um erro de compilação se tentar usá-lo com outra coisa, conforme mostrado abaixo:
Como o método Dispose () é chamado no final da ligação Use, deve-se tomar cuidado para não retornar o valor associado a Let.
let Write = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") sw
Se você absolutamente precisar devolver IDisposable, que fazem parte da ligação Usar, você pode usar o retorno de chamada. Algo assim funcionará, mas eu pararia e me perguntaria se você projetou seu design corretamente, se você fizer essas coisas:
let Write callback = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "Write is writing to the StreamWriter" callback sw sw let callback sw = fprintf sw "sw is the StreamWriter" let disp = Write callback
Fazer
A ligação do é usada para executar código sem definir uma função ou valor. Uma ligação deve sempre retornar a unidade (sem valor / vazio). Em muitos casos, você pode omitir a ligação Do e tudo funcionará conforme o esperado.
Aqui estão alguns exemplos do uso de ligações Do.
do printf "doing the do" //oh oh not a unit do printf "print a sum %i" 1 + 1 do 1 + 1
Se, em vez disso, mostrar uma captura de tela com o código acima, você verá que o compilador reclamará se tentar usar Do com um resultado que não seja da Unidade.
Você tem duas opções:
- Use um operador em pipeline para ignorar o resultado
- Criar ligação let
Eu mostrei um exemplo de cada um deles abaixo:
let x = 1 + 1 do printf "print a sum %i" x do (1+1 |> ignore)
Vamos! Use! Faça!
Embora eu não queira discuti-los ainda, às vezes você pode acidentalmente ver Let! Use! Faça!, E quando você faz isso, isso faz parte do que é chamado de expressão computacional. Você provavelmente verá isso nos fluxos de trabalho assíncronos em F #, que abordaremos em um dos artigos finais. Se eu entendo o suficiente, posso até tentar explicar como você pode criar sua própria “Expressão Computacional”, embora sejam um conceito bastante abstrato e um tópico bastante complicado, então agora não é o momento para eles.