Utiliser des variables pour stocker des valeurs

Tous les programmes se composent généralement de nombreuses étapes dans lesquelles le programme fonctionne sur des données. Dans le cadre de l’exécution de toutes ces étapes, il est courant de stocker le résultat intermittent, les données, dans une référence nommée. Vous pouvez ensuite lire ou manipuler les données ultérieurement. Les références nommées sont couramment appelées variables.

Variables, lier une valeur

Les variables sont des références nommées liées à une valeur que vous souhaitez conserver dans votre code. En F#, on parle de liaison d’une valeur. Par conséquent, ce que vous faites est d’affecter, ou de lier, une valeur à une référence nommée, une variable. Pour lier une valeur, vous utilisez le let mot clé, un nom pour votre référence et lui attribuer une valeur, comme dans le code ci-dessous :

let name = "Chris"

name est la référence nommée et « Chris » sa valeur liée.

Une fois qu’une valeur est affectée à une variable, elle ne peut pas être modifiée, elle est immuable. Le code suivant ne serait pas compilé et génère une erreur indiquant quelque chose comme « error FS0027 : Cette valeur n’est pas mutable ».

let name = "Chris"
name <- "Luis" // not allowed

Rendre mutable

Vous pouvez modifier des variables, mais vous devez signaler que vous souhaitez les rendre mutables. En utilisant le mot clé mutable dans votre définition de variable, vous pouvez modifier une valeur sans erreur de compilation, comme dans le code suivant :

let mutable name = "Chris"
name <- "Luis" // this statement is now allowed

Types de variable

Il existe une gamme de différents types en F#. De nombreux types doivent être liés au stockage de nombres de tailles différentes et avec ou sans décimales. D’autres types sont associés à la chaîne de texte ou aux variables booléennes. Voici une liste de types que vous êtes susceptible de rencontrer lorsque vous commencez à apprendre F#.

Le type est déduit

Lorsque vous déclarez une variable, vous pouvez le faire avec ou sans type. Si vous ne fournissez pas de type lorsque vous déclarez une variable, le compilateur F# fait une estimation de ce que le type doit être par la valeur que vous affectez à la variable. Tenez compte des affirmations suivantes :

let age = 65 // int
let PI = 3.14 // float
let name = "my name" // string

Le compilateur déduit ce que les types doivent être, et c’est correct. Vous pouvez également être plus explicite sur le type souhaité. Pour affecter des données, vous utilisez la syntaxe variableName:<type>, comme dans ce code :

let sum:float = 0.0

Imprimer sur l’écran

Vous souhaitez souvent être en mesure d’imprimer à l’écran. Il peut s’agir de diverses raisons, telles que :

• Sortie de l’application : l’application effectue un certain nombre de calculs et vous souhaitez voir la sortie.
• Débogage : dans le cadre du débogage de votre code, vous devrez peut-être générer le résultat à un moment donné pour comprendre ce qui va mal.

Il existe d’autres raisons de vouloir sortir à l’écran, mais les deux scénarios précédents sont les plus courants.

Alors, comment afficher des données à l'écran ? En F#, il existe trois fonctions différentes que vous pouvez utiliser. Ils sont printf, printfnet même Console.WriteLine. Quelle est la différence ?

• printf : affiche les données dans stdout en les incorporant (sans caractère de nouvelle ligne).
• printfn : affiche les données dans stdout en ajoutant un caractère de nouvelle ligne.
• Console.WriteLine: cette fonction provient de l’espace System de noms et fonctionne dans tous les langages .NET.

Maintenant, vous connaissez la différence, mais laquelle devez-vous utiliser ? Eh bien, printf et printfn sont considérés comme plus idiomatiques et préférés en F#.

Mise en forme

Dans le cadre de l’impression à l’écran, vous pouvez combiner du texte et des nombres. Vous pouvez également souhaiter que la sortie soit mise en forme d’une certaine manière, par exemple à l’aide de :

• Arguments positionnels : pour mettre en forme, vous pouvez utiliser une fonction .NET comme String.Format, qui utilise des arguments positionnels comme String.Format("My name is {0} and I live in {1}", "Chris", "UK").

• Interpolation de chaîne : une autre façon de combiner des variables et du texte consiste à utiliser quelque chose appelé interpolation. Pour l’utiliser, vous devez précéder la chaîne par un signe $ et indiquer les espaces réservés avec des crochets {}. Voici un exemple d’utilisation de l’interpolation :

  let name = "Luis"
  let company = "Microsoft"
  printfn $"Name: {name}, Company: {company}"
  

  Vous pouvez également ajouter des expressions entre les crochets, comme suit :

  let firstNumber = 2000
  let secondNumber = 21
  printfn $"The year is: {firstNumber + secondNumber}"
  

  Remarque

  Il n’existe aucune vérification de type à l’aide de l’interpolation. Il peut donc sembler simple d’utiliser. Veillez à combiner les choses correctement.

• Spécificateurs : vous pouvez également utiliser des spécificateurs de format dans le cadre de ce que vous essayez d’imprimer. L’utilisation de spécificateurs est la méthode la plus couramment utilisée pour mettre en forme en F#. Voici un exemple :

  let name = "Chris"
  printf "Hi %s" name
  // prints: Hi Chris
  

  Ici, vous pouvez voir comment le formateur %s est utilisé pour mélanger la première chaîne avec la variable name.

  Remarque

  Lorsque vous utilisez des formateurs comme %s ou %i, le compilateur vérifie les types. Si votre argument positionnel n’est pas du type que vous avez spécifié, il génère une erreur.

Spécificateurs de format

Il existe de nombreux spécificateurs de format. Voici quelques-uns que vous êtes susceptible de rencontrer.

Vous trouverez plus d’informations sur la mise en forme. Si vous souhaitez connaître toutes les fonctionnalités, consultez la mise en forme dans la documentation F#.