Valeurs (F#)
En F#, les valeurs sont des quantités qui ont un type spécifique ; les valeurs peuvent être des nombres intégraux ou à virgule flottante, des caractères ou du texte, des listes, des séquences, des tableaux, des tuples, des unions discriminées, des enregistrements, des types de classe ou des valeurs de fonction.
Liaison d'une valeur
Le terme liaison signifie l'association d'un nom à une définition. Le mot clé let lie une valeur, comme dans les exemples suivants :
let a = 1
let b = 100u
let str = "text"
// A function value binding.
let f x = x + 1
Le type d'une valeur est déduit de la définition. Pour un type primitif, tel qu'un nombre intégral ou à virgule flottante, le type est déterminé à partir du type du littéral. Par conséquent, dans l'exemple précédent, le compilateur déduit que le type de b est unsigned int, alors que le compilateur déduit que le type de a est int. Le type d'une valeur de fonction est déterminé à partir de la valeur de retour dans le corps de la fonction. Pour plus d'informations sur les types de valeurs de fonction, consultez Fonctions (F#). Pour plus d'informations sur les types de littéraux, consultez Littéraux (F#).
Pourquoi immuables ?
Des valeurs immuables sont des valeurs qui ne peuvent pas être modifiées durant toute l'exécution d'un programme. Si vous travaillez d'habitude avec des langages tels que C++, Visual Basic ou C#, vous pourrez être surpris de constater que F# donne la primauté aux valeurs immuables, et non aux variables auxquelles de nouvelles valeurs peuvent être assignées pendant l'exécution d'un programme. Les données immuables sont un élément important de la programmation fonctionnelle. Dans un environnement multithread, des variables mutables partagées qui peuvent être modifiées par différents threads sont difficiles à gérer. Par ailleurs, avec des variables mutables, il peut parfois être difficile de savoir si une variable peut être modifiée lorsqu'elle est passée à une autre fonction.
Dans les langages fonctionnels purs, il n'y a pas de variables, et les fonctions se comportent strictement comme des fonctions mathématiques. Là où le code dans un langage procédural utilise une assignation de variable pour modifier une valeur, le code équivalent dans un langage fonctionnel comprend une valeur immuable comme entrée, une fonction immuable et différentes valeurs immuables comme sortie. Cette rigueur mathématique donne lieu à un raisonnement plus étroit concernant le comportement du programme, ce qui permet aux compilateurs de vérifier le code plus rigoureusement et de l'optimiser plus efficacement. Pour les développeurs, cela se traduit par une meilleure compréhension du code et la possibilité d'écrire plus facilement du code correct. Le code fonctionnel est donc probablement plus facile à déboguer que le code procédural ordinaire.
F# n'est pas un langage fonctionnel pur ; toutefois, il prend entièrement en charge la programmation fonctionnelle. L'utilisation de valeurs immuables est conseillée, car votre code bénéficie ainsi d'un aspect important de la programmation fonctionnelle.
Variables mutables
Vous pouvez utiliser le mot clé mutable pour spécifier une variable qui peut être modifiée. En F#, les variables mutables doivent généralement avoir une portée limitée, soit en tant que champ d'un type, soit en tant que valeur locale. Des variables mutables avec une portée limitée sont plus faciles à contrôler et moins susceptibles d'être modifiées de manière incorrecte.
Vous pouvez assigner une valeur initiale à une variable mutable à l'aide du mot clé let, de la même façon que vous définissez une valeur. Toutefois, la différence est que vous pouvez assigner par la suite de nouvelles valeurs à des variables mutables à l'aide de l'opérateur <-, comme dans l'exemple suivant.
let mutable x = 1
x <- x + 1
Rubriques connexes
Titre |
Description |
|---|---|
Fournit des informations sur l'utilisation du mot clé let pour lier des noms à des valeurs et à des fonctions. |
|
Fournit une vue d'ensemble des fonctions en F#. |