Dart en 10 chapitres : Chap 9 Collections.

Salut encore cher Dev, maintenant vous l’êtes ouais 🤗 et vous le méritez ce qualificatif.

Bienvenue encore dans cette nouvelle leçon qui est pratiquement la dernière comme annoncer dans le chapitre précédent.

0. Vue d’ensemble

a. Qu’appelle-t-on une collection en Dart

b. List

c. Set

d. Map

e. Conclusion

1. Collections en Dart

Les collections en Dart sont des types de données qui permettent de stocker et d’organiser un ensemble d’éléments.

Et Dart nous propose plusieurs variétés des collections :

• Les listes (Lists)
• Les Ensembles (Sets)
• Les Cartes (Maps)
• Les files d’attentes (Queues)

Sous ce chapitres, nous n’allons parler que des plus importants et qu’on va utiliser et retrouver souvent.

2. List

La “list”, connue sous le nom de tableau dans certains langages, en Dart est une collection ordonnée d’éléments qu’on y accède par leur index. Sa syntaxe de déclaration reste comme dans les autres langages connus, on utilise les brackets [ ] pour y placer les éléments qui sont séparés par des virgules (,).

Dart n’oblige pas de spécifier le type des variables contenu dans une list (cf. Notion des types génériques au Chap 2), mais elles doivent être du même type. Et si il en faut, on utilise les <> au milieu desquels on ajoute le type de l’élément (int, String, double, …).

//Bien qu'il y a pas un type spécifié au début, mais les éléments restent de même type
List names = ["Georges", "Byona", "Musana", "Losingson"];
//Ajout du type si nécessaire
List<int> ages = [20, 23, 12, 15, 45, 23];

Ces types de list sont dit lists extensibles, nous verrons la différence dans les lignes qui suivent.

L’index serait des entiers allant habituellement de 0 à la taille de la list — 1, à ne pas confondre avec les éléments de la list, l’index est placé entre [ ] pour référer l’élément de la list se trouvant à cet index. Syntaxe : nom_list[index] .

names[1]; //Cet index renvoie au nom "Byona" dans notre ex précédent car l'index commence par 0 comme signaler au début
ages[5]; //Cherche si celui-ci correspondrait à quelle valeur dans la liste d'âges

Et pour accéder à la taille, on utilise la méthode length avec la syntaxe : nom_list.length .

names.length; //Renvoie comme valeur 4 car notre liste names a 4 éléments
ages.lenght; //Renvoie 6 à son tour

En Dart, nous pouvons spécifier deux grandes catégories des lists :

a. Les lists fixes : elles sont déclarées avec une taille fixe qu’on ne peut pas modifier au courant du programme.

Syntaxe de déclaration : List<type_var> nom_list = new List.filled(taillem type_var) (filled est une méthode de Dart qui permet de déclarer une list fixe).

Celles-ci ne permettent pas les manipulations qu’offre les collections Dart via ses méthodes, comme les ajouts, suppressions, …

Pour l’initialiser, on utilise la syntaxe suivante : nom_list[index] = element

//Déclaration de la list names
List names = new List.filled(4, "");
//Initialisation des éléments
  names[0] = 'Georges';
  names[1] = 'Byona';
  names[2] = 'Musana';
  names[3] = 'Losingson';
//Affichage simple de la list
  print(names); //Affiche : [Georges, Byona, Musana, Losingson]
//Affichage d'un index
  print(names[2]); //Affiche : Musana
//Affichage via une boucle for
  for (int i = 0; i < names.length; i++) {
    print(names[i]);
  }
//Affichage via une boucle for in
  for (String name in names) {
    print(name);
  }
//Affichage via une boucle forEach
  names.forEach((name) => print(name));

Pour changer la valeur d’un élément, on accède à son index puis affecte une nouvelle valeur, automatiquement l’ancienne est écrasée :

List names = new List.filled(4, "");
  names[0] = 'Georges';
  names[1] = 'Byona';
  names[2] = 'Musana';
  names[3] = 'Losingson';
//Nouvelle valeur à l'index 1, donc l'ancien nom Byona est remplacé par Birungi
  names[1] = 'Birungi';
  names.forEach((name) => print(name));

b. Les lists extensibles : ici, il s’agit des lists ayant une taille dynamique, donc n’ont pas besoin d’une initialisation avec une taille fixe, le nombre d’éléments définit la taille de la list (Donc sa taille peut être modifiée au courant du programme selon les manipulations faites à son égard).

Syntaxe de déclaration :

List<type_var> nom_list = [element_1, element_2, ..., element_n] (déclaration et initialisation).

ou

List nom_list = [] (déclaration sans initialisation).

Celles-ci permettent plusieurs manipulations des données par un groupe des méthodes que nous y accédons par la syntaxe : nom_list.nom_methode()

Exemple pour ajouter un élément : nom_list.add(element)

Voyons cela en exemple pour une bonne compréhension :

 //Déclaration et affectation
  List names = ["Georges", "Byona", "Musana", "Losingson"];
  //Déclaration seulement
  List ages = [];
  //Ajout des éléments à la list ages via la méthode add()
  ages.add(23);
  ages.add(20);
  ages.add(12);
  ages.add(45);
  //Affichage de la taille des listes
  print(names.length);
  print('\n');
  print(ages.length);
  print('\n');
  //Affichage des deux listes
  names.forEach((name) => print(name));
  print('\n');
  ages.forEach((age) => print(age));
  print('\n');
  //Suppression des éléments via les méthodes remove(), removeWhere(), removeAt(), removeLast(), ...
  names.remove("Georges");
  //Supression de l'élément de l'index 2 = 'Losingson' car on avait déjà supprimer Georges, donc la taille de la liste avait diminuer à 3
  names.removeAt(2);
  //Ici c'est 45 qui est supprimé vu qu'il est dernier de la liste
  ages.removeLast();
  //Affichage de la taille des listes après suppression
  print(names.length);
  print('\n');
  print(ages.length);
  print('\n');
  //Affichage des deux listes après manipulation
  names.forEach((name) => print(name));
  print('\n');
  ages.forEach((age) => print(age));
  print('\n');

Plusieurs manipulations sont possibles avec les collections Dart en général et les lists en particulier, veuillez vous exercer sur les autres méthodes pour plus d’approfondissement.

3. Set

Les Sets quant à eux sont des collections Dart qui ont des éléments non ordonnés mais toujours de même type.

Ils ont les mêmes fonctionnalités que les Lists mais une choses à noter est que les sets ne supportent pas les doublons d’éléments. Ils ne peuvent contenir que des valeurs uniques.

Ils jouent un rôle important dans le stockage des éléments du même type mais qui ne doivent pas être repris (avoir un doublon) dans une variable (collection).

Syntaxe de déclaration :

Set<type_var> nom_set = Set.from([element_1, element_2, ..., element_n]) (déclaration et initialisation).

ou

Set<type_var> nom_set = Set()(déclaration sans initialisation).

Voyons cela dans notre exemple précédent :

//Déclaration et affectation
  Set names = Set.from(["Georges", "Byona", "Musana", "Losingson"]);
  //Affichage de la taille du Set
  print("Taille initiale : ${names.length}");
  print('\n');
  //Ajout d'un élément de même valeur que un autre déjà existant, la taille ne change pas, donc l'élément n'est pas ajouté
  names.add('Georges');
  names.add('Georges');
  names.add('Georges');
  names.add('Georges');
  print("Taille après ajout d'un élément existant : ${names.length}");
  print('\n');
  //Ajout d'un élément iexistant, la taille change, donc l'élément a été ajouté
  names.add('Birungi');
  print("Taille après ajout d'un élément inexistant : ${names.length}");
  print('\n');
  //Affichage des éléments de Set
  names.forEach((name) => print(name));
  print('\n');
  //Suppression des éléments via la méthode remove(), removeWhere(), removeLast(), ...
  names.remove("Georges");
  //Supression de l'élément via la méthode removeAt() n'est pas supporté par le type Set
  //names.removeAt(2);
  print(names.length);
  print('\n');
  //Affichage des éléments après manipulation
  names.forEach((name) => print(name));
  print('\n');

4. Map

Les Maps à leur tour sont des collections du type clé-valeur, c-à-d que chaque élément a une sorte de clé ou d’identifiant qui peut être soit de même type soit de type différent.

Il tient à noter que les clés sont uniques. Donc les Maps ne supportent pas le doublon d’une clé existante.

Elles sont de taille dynamique, donc leur taille peut être modifiée au courant du programme.

Syntaxe de déclaration :

Map<clé_type, val_type> nom_map = {clé_1 : valeur_1, clé_2 : valeur_2, ..., clé_n : valeur_n} (déclaration et initialisation)

ou

Map<clé_type, val_type> nom_map = Map()(déclaration sans initialisation).

Et si vous faites une déclaration sans initialisation, pour passer une valeur à la Map, on utilise la syntaxe : nom_map[clé] = valeur

Plusieurs manipulations peuvent être effectuées sur les Maps, notamment la mise en jour d’une valeur via la méthode update(key, (valeur) => valeur) , la vérification de l’existence d’une clé avec la méthode containsKey(key) qui renvoie true si la clé existe et false dans le cas contraire, …

Comprenons par un exemple :

//Déclaration et initialisation
  Map students = {'Georges': 20, 'Bénédict': 21, 'Kévin': 25, 'Losingson': 12};
  //Déclaration seulement
  Map<String, String> cours = Map();
  //Initialisation
  cours['Python'] = 'Salama';
  cours['Algo'] = 'Boribo';
  cours['MAI'] = 'Christian';
  cours['Réseau'] = 'Youen';
  //Affichage d'un élément avec sa clé
  print(students['Georges']);
  print(cours['Python']);
  //Affichage de tous les éléments via leur clé
  for (String key in students.keys) {
    print(key);
  }
  //Affichage de tous les éléments directement en ciblant la valeur
  for (String value in cours.values) {
    print(value);
  }
  //Affichage des clés et valeurs
  students.forEach((key, value) => print("La clé est $key et la valeur $value"));
  //Mise en jour d'un élément
  students.update('Losingson', (value) => 45);
  print(students['Losingson']);
  //Vérification de la clé 'Python' dans la Map cours et affichage du résultat
  print(cours.containsKey('Python'));

Plusieurs manipulations sont au rendez-vous, prenez un temps de vous exercer en utilisant les différentes méthodes qu’offre Dart.

5. Conclusion

Sous ce chapitre, il a été question de parler des collections en Dart, une notion qui donne plus de possibilité à Dart de gérer la logique dans des applications Flutter.

Merci encore et au prochain arrêt qui serait le dernier, avec les Quiz !!!

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

😉