Programmation D - Immuable

Nous utilisons souvent des variables modifiables, mais dans de nombreuses occasions, la mutabilité n'est pas requise. Des variables immuables peuvent être utilisées dans de tels cas. Quelques exemples sont donnés ci-dessous où des variables immuables peuvent être utilisées.

  • Dans le cas de constantes mathématiques telles que pi qui ne changent jamais.

  • Dans le cas de tableaux où l'on veut conserver des valeurs et ce n'est pas des exigences de mutation.

L'immuabilité permet de comprendre si les variables sont immuables ou mutables garantissant que certaines opérations ne modifient pas certaines variables. Cela réduit également le risque de certains types d'erreurs de programme. Le concept d'immuabilité de D est représenté par les mots-clés const et immuables. Bien que les deux mots eux-mêmes aient un sens proche, leurs responsabilités dans les programmes sont différentes et parfois incompatibles.

Le concept d'immuabilité de D est représenté par les mots-clés const et immuables. Bien que les deux mots eux-mêmes aient un sens proche, leurs responsabilités dans les programmes sont différentes et parfois incompatibles.

Types de variables immuables en D

Il existe trois types de variables de définition qui ne peuvent jamais être mutées.

  • enum constantes
  • variables immuables
  • variables const

enum Constantes en D

Les constantes enum permettent de relier des valeurs constantes à des noms significatifs. Un exemple simple est présenté ci-dessous.

Exemple

import std.stdio;

enum Day{ 
   Sunday = 1, 
   Monday,
   Tuesday, 
   Wednesday, 
   Thursday, 
   Friday, 
   Saturday 
} 
 
void main() { 
   Day day; 
   day = Day.Sunday;
   
   if (day == Day.Sunday) { 
      writeln("The day is Sunday"); 
   } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

The day is Sunday

Variables immuables en D

Des variables immuables peuvent être déterminées pendant l'exécution du programme. Il indique simplement au compilateur qu'après l'initialisation, il devient immuable. Un exemple simple est présenté ci-dessous.

Exemple

import std.stdio; 
import std.random; 
 
void main() { 
   int min = 1; 
   int max = 10; 
   
   immutable number = uniform(min, max + 1); 
   // cannot modify immutable expression number 
   // number = 34; 
   typeof(number) value = 100;  
   
   writeln(typeof(number).stringof, number); 
   writeln(typeof(value).stringof, value); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

immutable(int)4 
immutable(int)100

Vous pouvez voir dans l'exemple ci-dessus comment il est possible de transférer le type de données vers une autre variable et d'utiliser stringof lors de l'impression.

Variables const en D

Les variables Const ne peuvent pas être modifiées comme immuables. les variables immuables peuvent être passées aux fonctions en tant que paramètres immuables et il est donc recommandé d'utiliser immutable sur const. Le même exemple utilisé précédemment est modifié pour const comme indiqué ci-dessous.

Exemple

import std.stdio; 
import std.random; 
 
void main() { 
   int min = 1; 
   int max = 10; 
   
   const number = uniform(min, max + 1); 
   // cannot modify const expression number| 
   // number = 34; 
   typeof(number) value = 100; 
   
   writeln(typeof(number).stringof, number); 
   writeln(typeof(value).stringof, value); 
}

Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant -

const(int)7 
const(int)100

Paramètres immuables en D

const efface les informations indiquant si la variable d'origine est mutable ou immuable et, par conséquent, l'utilisation d'immuable lui fait passer d'autres fonctions avec le type d'origine conservé. Un exemple simple est présenté ci-dessous.

Exemple

import std.stdio; 
 
void print(immutable int[] array) { 
   foreach (i, element; array) { 
      writefln("%s: %s", i, element); 
   } 
}
  
void main() { 
   immutable int[] array = [ 1, 2 ]; 
   print(array); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

0: 1 
1: 2