Dans cet article, nous nous pencherons sur les liaisons en F #, en particulier sur Let / Use / Do. Maintenant, vous vous demandez peut-être ce que sont les liaisons, et puisque nous ne les avons pas encore examinées, il est maintenant temps d'en parler.
En termes simples, une liaison associe un identifiant à une valeur ou une fonction.
Soit
Vous utilisez le mot clé let pour associer un nom à une valeur ou une fonction. En fait, il y a une utilisation subtile et différente de Let, où l'un est déclaré au niveau supérieur dans le module, puis l'autre où nous définissons un contexte local. Voici un exemple des deux:
module DemoModule = let someFunction = let a = 1 let b = 2 a * b
Nous pourrions accéder à someFunction en utilisant un nom complet, tel que DemoModule.someFunction, mais les liaisons Let (a, b) imbriquées ne sont disponibles que pour Let top level. Habituellement, vous voyez plus de cas lorsque nous utilisons la liaison Let pour déclarer certaines valeurs du module interne, concentrons-nous là-dessus (bien qu'il soit important de savoir que vous pouvez utiliser Let au niveau du module).
Voyons donc quelques exemples supplémentaires.
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"
Vous pouvez voir que nous pouvons utiliser la liaison Let pour se lier à plusieurs valeurs, qui peuvent être de différents types, telles que:
- Entier
- Décimal
- Fonction sans paramètres d'entrée
- Fonction avec paramètres d'entrée (où le système d'inférence logique de type F # choisira le type correctement)
- Une fonction qui a des types de paramètres entièrement définis
- Tuple (dans ce cas, String * String tuple)
Ailleurs, vous pouvez voir la liaison Let dans la classe, mais nous en discuterons plus en détail dans le prochain article de cette série.
Vous pouvez en savoir plus sur Let binding sur MSDN.Utiliser
La liaison Use est très similaire à la liaison Let, car elle lie la valeur au résultat de l'expression. La principale différence est que la liaison Use est conçue pour fonctionner avec les types IDisposable et supprime automatiquement une valeur lorsqu'elle n'est plus dans la portée. Ceci est très similaire au mot clé .NET using, bien que je ne pense pas que la liaison F # Use sera exactement la même que celle utilisée dans .NET, car le mot clé using dans .NET est en fait un essai / enfin avec un appel à Dispose ( ) enfin.
Nous avons déjà vu un exemple de la liaison Use dans le dernier article sur la mise en forme du texte, mais juste pour nous rappeler, regardons cela de nouveau.
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()
Dans cet exemple, la liaison Use garantit que la méthode StreamWriter appellera sa méthode Dispose () après avoir appelé sw.Close (), comme illustré ci-dessus.
Utiliser ne fonctionne qu'avec IDisposables, et vous obtiendrez une erreur de compilation si vous essayez de l'utiliser avec autre chose, comme indiqué ci-dessous:
Étant donné que la méthode Dispose () est appelée à la fin de la liaison Use, il convient de veiller à ne pas renvoyer la valeur associée à Let.
let Write = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") sw
Si vous devez absolument renvoyer IDisposable, qui fait partie de la liaison Use, vous pouvez utiliser le rappel à la place. Quelque chose comme ça fonctionnera, mais je m'arrêterais et me demanderais si vous avez correctement conçu votre conception si vous faites de telles choses:
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
Faire
La liaison do est utilisée pour exécuter du code sans définir de fonction ou de valeur. Une liaison DOIT toujours retourner une unité (aucune valeur / annulation). Dans de nombreux cas, vous pouvez omettre la liaison Do et tout fonctionnera comme prévu.
Voici quelques exemples d'utilisation des liaisons Do.
do printf "doing the do" //oh oh not a unit do printf "print a sum %i" 1 + 1 do 1 + 1
Si je vous montre à la place une capture d'écran avec le code ci-dessus, vous verrez que le compilateur se plaindra si vous essayez d'utiliser Do avec un résultat non-Unit.
Vous avez deux options:
- Utilisez un opérateur en pipeline pour ignorer le résultat
- Créer une reliure let
J'ai montré un exemple de chacun d'eux ci-dessous:
let x = 1 + 1 do printf "print a sum %i" x do (1+1 |> ignore)
Laissez! Utilisez! Faites!
Bien que je ne veuille pas encore en parler, vous pouvez parfois voir accidentellement Let! Utilisez! Faites!, Et lorsque vous faites cela, cela fait partie de ce qu'on appelle une expression de calcul. Vous le verrez très probablement dans les workflows asynchrones F #, que nous couvrirons dans l'un des derniers articles. Si je comprends suffisamment, je peux même essayer d'expliquer comment vous pouvez créer votre propre «expression informatique», bien qu'il s'agisse d'un concept plutôt abstrait et d'un sujet plutôt compliqué, ce n'est donc pas le moment pour eux.