Dart en 10 chapitres : Chap 2 Variables & Types de données.

Salut, merci de rester avec nous dans la course vers l’apprentissage de Dart🤗 !

Si vous aviez loupé le cours précédent, n’hésitez pas d’y jeter un coup d’oeil, en cliquant ici.

0. Vue d’ensemble

a. Quels sont les types de donnée en Dart ;

b. Qu’est-ce qu’un variable et comment les déclarer ;

c. La notion du “String interpolation” en Dart ;

d. Qu’est-ce qu’un constant et comment le déclarer en Dart ;

e. Conclusion du chapitre ;

1. Types de donnée en Dart

D’abord, il faut noter que Dart est un langage de type sécurisé ou statique, c-à-d qu’il utilise une combinaison de vérifications de type statique et de vérification d’exécution ce qui veut dire que le type de chaque variable doit être déclaré avant de l’utiliser. Cela rassure qu’il n’y aura pas de surprises à trouver qu’une variable à eu à être compiler avec un type qui n’est pas le tien initialement déclaré ou affecté, ce qui permet d’améliorer la fiabilité du code.

Mais, bien que les types soient obligatoires, les annotations de type restent facultatives comme nous le verrons dans les lignes qui suivent.

Dart nous offre plusieurs types de donnée, et je dirai même qu’il en donne un peu plus que certains langages. Et nous pouvons les catégoriser en 2 grands groupes :

a. Les types primitifs : pour dire qu’ils ont une nature prise des langages que nous connaissons déjà ou parlons (Je dirai humain).

Ici, nous classons :

• les nombres avec leur keyword (mot-clé) en Dart qui est int pour les entiers (1, 6, 10, 25376) et double pour les décimaux (2.3, 2345.89, 14.3)

Un “keyword” ou mot-clé est un mot dit “réservé” que Dart utilise pour communiquer avec l’ordinateur via l’IDE.

• les booléens : types ayant comme valeurs true ou false avec leur mot-clé bool
• les chaînes de caractère (par exemple, “Bonjour”, “Dart”), avec le mot-clé String

b. Les types non primitifs : ceux-ci sont un peu plus vague à la première vue, c’est plus dans la programmation qu’on retrouve ces types de donnée. Ici, nous pouvons citer :

• les listes : collections ordonnées d’éléments de type T, avec comme mot-clé List<T>
• les ensembles : collections non ordonnées d’éléments uniques de type T, mot-clé Set<T>
• les mapes : collections de paires clé-valeur, où les clés sont de type K et les valeurs de type T, keyword Map<K, T>
• les classes : modèles définissant des structures et des comportements pour les objets, mot-clé : Class
• les fonctions : blocs de code pouvant être appelés et réutilisés, mot-clé : Function.
• les symboles : valeurs uniques utilisées comme identificateurs, mot-clé : Symbol.

On parlerait aussi du type générique dans certains endroits, ce qui veut dire que c’est un type qui lui peut prendre plusieurs types de variable selon son affectation.

A l’exemple de List qui lui peut prendre et les entiers, et les lettres, …

Notons que nous les étudierons un peu à large dans l’un des chapitres qui suivent.

2. Variables en Dart

Disons d’abord un mot sur ce que c’est une variable.

Une variable est un espace mémoire nommé qu’on réserve pour pouvoir prendre une valeur (nombre, bool, …) au courant du programme (algorithme) et cela permet la manipulation de celui-ci sous plusieurs formes sans faire buguer l’exécution du programme.

Exemple d’un champs de texte où on voudrait entrer une adresse mail puis la valider. On utilisera une variable pour stocker différentes adresses mails qui y seront tapées et à chaque validation libérer la variable afin de contenir une suivante et ainsi de suite.

Avec ça, je crois bien que cette notion de variable nous est palliée. Mais déjà son nom l’indique, elle peut varier autant que possible mais cela tout en gardant le type qu’il lui a été attribué au début de l’algorithme soit par déclaration soit par affectation.

Alors, avant de voir comment déclarer une variable en Dart, disons un mot sur comment nommer celle-ci.

a. Nomenclature d’une variable en Dart

• Le nom d’une variable, autrement dit “identifiant”, ne peut contenir que des lettres et des chiffres, notons que c’est d’abord une ou plusieurs lettres qui précèdent puis peuvent venir un ou plusieurs chiffres (Pas de chiffre au début).

Non pas des chiffres seuls, ni une lettre majuscule au début.

v3 👍
        3v👎
g23 👍
        g 23 👎
sam 👍
        s@m 👎

• Le nom d’une variable ou son identifiant ne peut pas être un mot clé -keyword- (cf. types de données).
• Le nom d’une variable ou son identifiant ne peut pas contenir des espaces ou des caractères spéciaux, sauf les underscores (_) et le signe de dollar ($) (ce qui n’est pas rassurant car il arrive de fois que ce signe soit confondu, car c’est un symbole réservé).

b. Déclaration & Affectation d’une variable en Dart

Tout d’abord, notons qu’une variable en Dart est obligatoirement déclaré avant d’être utilisé dans le programme. On utilise les keywords pour la déclaration.

La syntaxe pour la déclaration est :

type_var nom_var

Voyons comment la déclaration se présente avec un type clé et l’affectation, qui est fait avec un signe d’égalité (=) :

String name = "Georges";
int age = 20;
bool etudiant = true;
double moyenne = 13.57;
List cours = ["Dart",'Flutter',"FireBase",'ML'];

De gauche à droite : ‘keyword’ pour le type de donnée, nom ou identifiant de la variable, signe d’affectation (=), valeur de variable et la fin de l’instruction (;) comme dit dans le chapitre précédent.

Nous constatons que la valeur d’une variable est notée selon son type.

• Le String avec “ … ” ou ‘ … ’ selon le cas, on en discutera d’ici-là
• Le int et double directement la valeur
• La List avec [ ] (celle-ci avait des valeurs String d’où la présence de soit “ ” soit ‘ ’).

Comme dit là-haut, la déclaration en Dart est dit du type statique, mais l’annotation n’est pas aussi obligatoire que cette considération statique. Et pour ce faire, un mot-clé, noté dynamic , permet de déclarer une variable de n’importe quel type et là vraiment n’importe lequel (int, String, List, Map, …) mais seulement qu’après affectation, elle gardera le type de la valeur entrée.

dynamic name = "Georges";
dynamic age = 20;
dynamic etudiant = true;
dynamic moyenne = 13.57;
dynamic cours = ["Dart",'Flutter',"FireBase",'ML'];

Nous reprenons le même exemple pour montrer que ces variables peuvent aussi être déclarées de la sorte mais en sortie seront des types différents vu les valeurs d’affectation.

Voici un exemple d’un code pour l’explication des notions que nous venons de voir :

void main() {
  //Exemple d'une chaîne de caractère
  String name = "Georges";
  //Affichage de la variable name
  print(name);
  //Exemple d'un entier
  int age = 20;
  print(age);
  //Exemple d'un booléen
  bool etudiant = true;
  print(etudiant);
  //Exemple d'un décimaux
  double moyenne = 13.57;
  print(moyenne);
  //Exemple d'une liste des cours du type chaîne de caractère
  List cours = ["Dart",'Flutter',"FireBase",'ML'];
  /*Il tient à noter que l'affichage ici est basique
   pour l'instant quand nous serons sur les collections en Dart
   nous en diront plus*/
  print(cours);
}

— Pour en être sûr, vous pouvez aussi essayer avec l’annotation dynamic

3. Littérals en Dart

Ici, nous verrons les différentes manières de déclarer une variable du type String et savoir quand employer laquelle et pourquoi.

Donc allons y :

a. En utilisant le single-quote (‘ ’)

String ex1 = 'Je suis un String en single-quote';

b. En utilisant le double-quotes (“ ”)

String ex2 = "Je suis un String en double-quotes";

Notons que ces deux manières n’ont pas une grande différence car l’exécution reste la même.

Mais alors si nous voulons ajouter un apostrophe dans la phrase 😏:

String ex1 = 'J'suis un string en single-quote';

String ex2 = "J'suis un string en double-quotes";

Le constat fait est que le single-quote n’admet pas directement l’apostrophe, il le considère comme la fermeture du single-quote, alors que le double-quotes l’accueille simplement.

Ceci montre déjà quand utiliser le double-quotes et pourquoi ce choix.

Mais nous pouvons pallier à ce souci dans le single-quote en intégrant un \ avant l’apostrophe.

String ex1 = 'J\'suis un string en single-quote';

Bing et voilà 🤗!

Nous pouvons faire la même chose mais 😏 a-t-on assez de temps pour chaque fois chercher ce symbole au clavier ?🤷‍♀️

Il arrive de fois vous avez un long texte à noter et l’écran cache une suite alors vous voulez faire un retour à la ligne tout en gardant la même structure à la sortie du message.

Cela se fait en ramenant à la ligne le bout de texte qui sort de l’écran soit en les liant avec un signe (+), soit simplement en faisant un retour à la ligne, cela tout en gardant les deux quotes. Voyons comment le faire :

//Exemple d'un String écrit sur une ligne
String ex1 = 'Je suis un string en single-quote. Je suis un string en single-quote. Je suis un string en single-quote. Je suis un string en single-quote. Je suis un string en single-quote.';

/*Exemple d'un String qui fait un retour à la ligne dans le code,
écrit sur plusieurs ligne avec une liaison (+)*/
String ex1 = 'Je suis un string en single-quote.'+
"Je suis un string en double-quotes."+
'Je suis un string en single-quote.'+
"Je suis un string en double-quotes."+
'Je suis un string en single-quote.';

/*Exemple d'un String qui fait un retour à la ligne dans le code,
écrit sur plusieurs ligne sans liaison*/
String ex2 = 'Je suis un string en single-quote.'
"Je suis un string en double-quotes."
'Je suis un string en single-quote.'
"Je suis un string en double-quotes."
'Je suis un string en single-quote.';

Ce code ne fait pas de retour à la ligne à la sortie, juste pour que le code soit lisible.

Et qu’en est-il d’un retour à la ligne à la sortie ?

Pour de retour à la ligne dans le message d’output (sortie), dans le cas des single-quote et double-quotes, on utilise \n à l’endroit où nous voulons faire ce retour à la ligne. On le fait de la même manière et dans un single-quote et dans un double-quotes.

/*Exemple d'un String qui fait un retour à la ligne à la sortie,
écrit sur une ligne*/
String ex = 'Je suis un string en single-quote.\nJe suis un string en single-quote.\nJe suis un string en single-quote.\nJe suis un string en single-quote.\nJe suis un string en single-quote.';

/*Exemple d'un String qui fait un retour à la ligne
et dans le code et à la sortie,
écrit sur plusieurs ligne avec une liaison (+)*/
String ex1 = 'Je suis un string en single-quote.\n'+
"Je suis un string en double-quotes.\n"+
'Je suis un string en single-quote.\n'+
"Je suis un string en double-quotes.\n"+
'Je suis un string en single-quote.\n';

/*Exemple d'un String qui fait un retour à la ligne
et dans le code et à la sortie,
écrit sur plusieurs ligne sans liaison*/
String ex2 = 'Je suis un string en single-quote.\n'
"Je suis un string en double-quotes.\n"
'Je suis un string en single-quote.\n'
"Je suis un string en double-quotes.\n"
'Je suis un string en single-quote.\n';

Cette notion nous pousse à parler d’une troisième manière de déclarer un String en Dart, en utilisant le triple-quotes (‘‘‘ ’’’). Cette manière permet de faire de retour à la ligne et dans le code et à la sortie au même moment, sans des symboles entrant en jeu.

//Exemple d'un String déclaré avec un triple-quotes
String tripleQuotes = '''Je suis un string en triple-quotes.
  Je suis un string en triple-quotes.
  Je suis un string en triple-quotes.
  Je suis un string en triple-quotes.
  J\'suis un string en triple-quotes.
  J\'suis un string en triple-quotes.
  J\'suis un string en triple-quotes.
  ''';

4. La notion du “String interpolation” en Dart

Le “String interpolation” ou l’interpolation de chaînes en Dart est une fonctionnalité qui permet d’insérer des expressions et/ou des variables directement dans une chaîne de caractères.

Ceci permet de créer des chaînes de caractères dynamiques et dont le contenu peut varier en fonction de l’exécution du programme.

Une première manière est d’utiliser la notion de concaténation comme dans certains langages. Ici on utilise le signe (+) entre le String et la variable ou l’expression, celle-ci se met hors des quotes.

String name = "Georges";
print("Mon nom est "+name);
print("Mon nom est " + "Georges Byona");

Une deuxième manière est d’utiliser le signe ($) entre le String et la variable ou l’expression, cette fois elle est entre quotes.

String name = "Georges";
print("Mon nom est $name");
String expression = "Georges Byona, un développeur flutter.";
print("J'suis $expression");

Avant de passer cette notion, disons un mot sur la méthode length (taille), qui permet d’extraire ou de lire la taille d’un String, d’une collection, … en Dart.

String name = "Georges";
//Lecture de la taille avec la concaténation
print("Mon nom est " +name+ "et il a une taille de " +name.length.toString());
//Lecture de la taille avec le signe $
print("Mon nom est $name et il a une taille de ${name.length}");

Déjà notons que la méthode length renvoie un entier (int).

Par rapport à cet exemple, nous pourrons voir la manière qui serait la mieux disposée pour le “String interpolation”.

Pour joindre notre taille qui est un entier à la chaîne de caractère, la première manière qui est celle de la concaténation nous a obligé d’appeler la méthode toString() pour que cet entier soit lu comme un String.

Pour la deuxième manière qui est celle d’utilisation du signe ($), nous n’avons pas eu à appeler cette méthode, mais à revanche on a eu à utiliser les { } parce que notre expression name.length est composée et non simple comme dans name .

Ainsi, je vous conseillerais d’utiliser la deuxième manière que la première pour une lecture simple et claire de la variable ou l’expression dynamique dans une chaîne de caractère.

Voyons jusqu’à où peut-on jouer avec cette notion d’interpolation :

int a = 23;
int b = 10;
print("La somme de $a et $b est ${a + b}");

int a = 23;
int b = 10;
int sum = a + b;
print("La somme de $a et $b est $sum");

5. Constante en Dart et comment la déclarer

A la question de qu’est-ce qu’une constante en Dart, nous répondons simplement en disant qu’une constante est une valeur qui ne peut pas être modifiée après son initialisation.

On l’utilise pour définir des valeurs qui ne changent pas pendant l’exécution du programme.

On a deux manière de la déclarer en Dart :

a. En utilisant le mot-clé const:

• Le mot-clé const est utilisé pour déclarer des constantes dont la valeur est connue au moment de la compilation.
• Les constantes déclarées avec const peuvent être des valeurs primitives (nombres, chaînes de caractères, booléens) ou des références à des objets immuables (objets dont l’état ne peut pas être modifié après leur création).

const pi = 3.14;
const max = 100;

b. En utilisant le mot-clé final:

• Le mot-clé final est utilisé pour déclarer des variables dont la valeur ne peut pas être modifiée après leur initialisation.
• La valeur d’une variable final peut être connue ou non au moment de la compilation.
• Les variables final peuvent être des valeurs primitives ou des références à des objets.

final name = "Georges";
final age = 20;

Donnons quelques points de différence entre const et final:

• Les constantes const doivent avoir une valeur connue au moment de la compilation, tandis que les variables final peuvent avoir une valeur non connue.
• Les constantes const sont généralement utilisées pour définir des valeurs qui ne changent jamais, tandis que les variables final peuvent être utilisées pour définir des valeurs qui peuvent changer occasionnellement.

Cette notion entre en jeu plus avec l’utilisation des classes.

6. Conclusion

Ouf ! Ce chapitre a été un peu plus longue là 🥱

Mais nous avons eu à entrer un peu plus en fond dans cette notion importante de Dart, la bonne compréhension de données et de variable nous rendra la tâche plus facile dans la suite de notre apprentissage.

Merci et au prochain !

Portez-vous bien et n’oubliez pas : “Ne limitez pas vos rêves !”.

😉