F # - Données mutables

Les variables en F # sont immutable,ce qui signifie qu'une fois qu'une variable est liée à une valeur, elle ne peut pas être modifiée. Ils sont en fait compilés en tant que propriétés statiques en lecture seule.

L'exemple suivant illustre cela.

Exemple

let x = 10
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

let x = 15
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

Lorsque vous compilez et exécutez le programme, il affiche le message d'erreur suivant -

Duplicate definition of value 'x'
Duplicate definition of value 'Y'
Duplicate definition of value 'Z'

Variables mutables

Parfois, vous devez modifier les valeurs stockées dans une variable. Pour spécifier qu'il pourrait y avoir un changement dans la valeur d'une variable déclarée et assignée dans une partie ultérieure d'un programme, F # fournit lemutablemot-clé. Vous pouvez déclarer et affecter des variables mutables à l'aide de ce mot clé, dont vous allez modifier les valeurs.

le mutable Le mot clé vous permet de déclarer et d'affecter des valeurs dans une variable mutable.

Vous pouvez attribuer une valeur initiale à une variable mutable en utilisant le letmot-clé. Cependant, pour lui attribuer une nouvelle valeur ultérieure, vous devez utiliser le<- opérateur.

Par exemple,

let mutable x = 10
x <- 15

L'exemple suivant clarifiera le concept -

Exemple

let mutable x = 10
let y = 20
let mutable z = x + y

printfn "Original Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

printfn "Let us change the value of x"
printfn "Value of z will change too."

x <- 15
z <- x + y

printfn "New Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Original Values:
x: 10
y: 20
z: 30
Let us change the value of x
Value of z will change too.
New Values:
x: 15
y: 20
z: 35

Utilisations des données mutables

Les données mutables sont souvent requises et utilisées dans le traitement des données, en particulier avec la structure des données d'enregistrement. L'exemple suivant illustre ceci -

open System

type studentData =
   { ID : int;
      mutable IsRegistered : bool;
      mutable RegisteredText : string; }

let getStudent id =
   { ID = id;
      IsRegistered = false;
      RegisteredText = null; }

let registerStudents (students : studentData list) =
   students |> List.iter(fun st ->
      st.IsRegistered <- true
      st.RegisteredText <- sprintf "Registered %s" (DateTime.Now.ToString("hh:mm:ss"))

      Threading.Thread.Sleep(1000) (* Putting thread to sleep for 1 second to simulate processing overhead. *))

let printData (students : studentData list) =
   students |> List.iter (fun x -> printfn "%A" x)

let main() =
   let students = List.init 3 getStudent

   printfn "Before Process:"
   printData students

   printfn "After process:"
   registerStudents students
   printData students

   Console.ReadKey(true) |> ignore

main()

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Before Process:
{ID = 0;
IsRegistered = false;
RegisteredText = null;}
{ID = 1;
IsRegistered = false;
RegisteredText = null;}
{ID = 2;
IsRegistered = false;
RegisteredText = null;}
After process:
{ID = 0;
IsRegistered = true;
RegisteredText = "Registered 05:39:15";}
{ID = 1;
IsRegistered = true;
RegisteredText = "Registered 05:39:16";}
{ID = 2;
IsRegistered = true;
RegisteredText = "Registered 05:39:17";}