WEBVTT

00:00:01.080 --> 00:00:04.780 align:middle
Alors dans cette séquence
nous allons voir les éléments

00:00:05.000 --> 00:00:07.290 align:middle
essentiels de la
hiérarchie des collections en Pharo.

00:00:07.770 --> 00:00:09.910 align:middle
Donc vous allez voir que
Pharo est riche du point de vue

00:00:10.110 --> 00:00:14.070 align:middle
des différents types de
collections, mais il facilite la

00:00:14.270 --> 00:00:17.000 align:middle
vie du programmeur puisqu'ils
présentent tous une API commune.

00:00:17.720 --> 00:00:20.790 align:middle
Et on verra également la
différence entre les collections

00:00:21.030 --> 00:00:22.640 align:middle
littérales et les
collections dynamiques.

00:00:24.170 --> 00:00:26.360 align:middle
Donc là l'API des
collections, comme je disais, est

00:00:26.560 --> 00:00:28.550 align:middle
riche, on verra qu'il y a beaucoup
de types de collections différents.

00:00:29.000 --> 00:00:31.590 align:middle
Toutes présentent une API
commune, on le verra, qui est

00:00:31.790 --> 00:00:34.910 align:middle
assez bien organisée, qui facilite
énormément la vie du programmeur.

00:00:36.040 --> 00:00:39.000 align:middle
Petit point particulier en
Pharo les collections, les

00:00:39.200 --> 00:00:41.910 align:middle
index des collections,
commencent à 1 alors que ça

00:00:42.110 --> 00:00:43.500 align:middle
commence à 0 dans d'autres langages.

00:00:44.330 --> 00:00:46.630 align:middle
Et puis les collections
peuvent contenir n'importe quel

00:00:46.830 --> 00:00:49.180 align:middle
type d'objet en Pharo, ce
qui n'est pas forcément le cas

00:00:49.380 --> 00:00:50.140 align:middle
dans dans les autres langages.

00:00:51.700 --> 00:00:54.530 align:middle
Donc quelques-unes des
collections les plus remarquables

00:00:54.730 --> 00:00:56.810 align:middle
et les plus utilisées, donc
OrderedCollection qui est une

00:00:57.010 --> 00:01:00.580 align:middle
collection dynamique dont
la taille va grossir à chaque

00:01:00.780 --> 00:01:02.230 align:middle
fois qu'on ajoute
des éléments dedans.

00:01:02.530 --> 00:01:05.410 align:middle
Array qui est une
collection de taille fixe.

00:01:05.880 --> 00:01:07.820 align:middle
Et puis on va accéder aux
éléments en fonction d'un

00:01:08.020 --> 00:01:12.910 align:middle
indice Set, qui va contenir
des éléments mais sans doublon.

00:01:13.450 --> 00:01:16.000 align:middle
On ne pourra pas insérer 2
fois le même élément dans un Set.

00:01:16.330 --> 00:01:18.520 align:middle
Et puis les dictionnaires,
donc les dictionnaires ce sont

00:01:18.720 --> 00:01:21.040 align:middle
des tables de hachage, à une
clé donnée j'associe une valeur.

00:01:22.160 --> 00:01:24.340 align:middle
Donc vous avez ici un
extrait de la hiérarchie des

00:01:24.540 --> 00:01:25.770 align:middle
collections, c'est
seulement un extrait.

00:01:26.000 --> 00:01:28.080 align:middle
Il est plus riche que ça en Pharo.

00:01:28.280 --> 00:01:29.580 align:middle
Donc voyez qu'il y
a plein de classes.

00:01:29.780 --> 00:01:32.010 align:middle
Elles héritent toutes de
collections, ce qui nous fournit

00:01:32.210 --> 00:01:33.680 align:middle
une API commune pour
l'ensemble des collections.

00:01:34.800 --> 00:01:36.910 align:middle
Et puis on va voir celles
qui sont en gras, on voit les

00:01:37.110 --> 00:01:39.260 align:middle
expliciter un peu au fur et
à mesure de cette séquence.

00:01:40.690 --> 00:01:44.270 align:middle
Donc il existe une API commune, je
vous disais, répartie en 7 points.

00:01:44.540 --> 00:01:46.550 align:middle
On a des méthodes
spécifiques pour la création des

00:01:46.750 --> 00:01:49.270 align:middle
collections, qu'on va envoyer
plutôt aux classes des collections.

00:01:49.530 --> 00:01:51.530 align:middle
Des méthodes spécifiques
pour accéder aux propriétés des

00:01:51.730 --> 00:01:53.900 align:middle
collections, que ce soit
accéder par exemple à la taille

00:01:54.330 --> 00:01:57.540 align:middle
d'une collection ou accéder même aux
éléments que la collection contient.

00:01:58.150 --> 00:02:01.000 align:middle
Des méthodes de tests, savoir
est-ce que la collection est vide ou pas.

00:02:01.240 --> 00:02:03.020 align:middle
Des méthodes d'ajout et
de retrait d'éléments, des

00:02:03.220 --> 00:02:05.130 align:middle
méthodes d'énumération des
éléments dans une collection.

00:02:05.420 --> 00:02:07.190 align:middle
Donc je parcours
l'ensemble des éléments, je voudrais

00:02:08.190 --> 00:02:11.080 align:middle
savoir si un élément existe, est
présent dans une collection ou pas.

00:02:11.580 --> 00:02:14.410 align:middle
Et puis on a des méthodes
de conversion d'un type de

00:02:14.610 --> 00:02:15.500 align:middle
collection en un autre type.

00:02:17.130 --> 00:02:18.200 align:middle
Commençons par un exemple.

00:02:18.630 --> 00:02:21.600 align:middle
Donc je veux créer une
collection en Pharo tout bêtement.

00:02:21.800 --> 00:02:24.450 align:middle
Je vais sélectionner la
bonne classe qui m'intéresse et

00:02:24.650 --> 00:02:26.510 align:middle
lui envoyer un message new
pour instancier, pour créer un

00:02:26.710 --> 00:02:27.900 align:middle
nouvel instance sur cette classe.

00:02:28.350 --> 00:02:30.240 align:middle
Donc premier cas de
figure, j'utilise new.

00:02:30.630 --> 00:02:31.600 align:middle
Deuxième cas de figure.

00:02:32.070 --> 00:02:34.260 align:middle
En fait je ne peux pas
faire un new directement où j'ai

00:02:34.460 --> 00:02:36.020 align:middle
envie de spécifier la
taille de la collection.

00:02:36.430 --> 00:02:39.380 align:middle
Donc typiquement Array je
peux lui envoyer new:4, donc je

00:02:39.580 --> 00:02:41.490 align:middle
fais un tableau de taille 4
ou un tableau de taille 2,

00:02:41.770 --> 00:02:43.280 align:middle
donc ça marche également
sur les OrderedCollection je

00:02:43.480 --> 00:02:48.000 align:middle
pourrais faire un
OrderedCollection. Donc on a d'autres

00:02:48.200 --> 00:02:50.440 align:middle
types de méthodes pour
créer des collections

00:02:50.930 --> 00:02:53.850 align:middle
pré-initialisées, donc
avec withAll par exemple où je

00:02:54.050 --> 00:02:55.160 align:middle
vais passer une collection littérale.

00:02:55.500 --> 00:02:58.280 align:middle
Une collection littérale ça
commence par un #( je vous rappelle.

00:02:59.050 --> 00:03:01.300 align:middle
Et puis ça va me créer donc
une nouvelle instance de la

00:03:01.500 --> 00:03:03.080 align:middle
 classe
OrderedCollection, donc un nouvel

00:03:03.280 --> 00:03:05.000 align:middle
OrderedCollection qui
contiendra bien tous les éléments

00:03:05.200 --> 00:03:06.870 align:middle
qui ont été placés au
moment de sa création.

00:03:07.630 --> 00:03:10.000 align:middle
Je peux faire la même chose
avec un Set, par contre je

00:03:10.200 --> 00:03:12.810 align:middle
vous rappelle hein dans un Set on
ne peut pas avoir d'objets doublons.

00:03:13.030 --> 00:03:15.750 align:middle
Donc le chiffre 7 qu'on
avait mis 2 fois dans la

00:03:15.950 --> 00:03:18.700 align:middle
collection littérale il ne peut
pas se retrouver 2 fois dans le Set.

00:03:21.300 --> 00:03:25.070 align:middle
Donc il y a d'autres types,
d'autres sortes de messages

00:03:25.270 --> 00:03:27.860 align:middle
qu'on peut envoyer aux classes
collection pour les initialiser.

00:03:28.140 --> 00:03:29.390 align:middle
Ici j'en ai un autre exemple.

00:03:29.590 --> 00:03:33.020 align:middle
new withAll, donc qui est
un message, je veux faire une

00:03:33.220 --> 00:03:35.390 align:middle
collection de taille 5
mais je veux que toutes les

00:03:35.590 --> 00:03:37.100 align:middle
 classes soient
initialisées avec un certain objet.

00:03:37.370 --> 00:03:39.450 align:middle
Donc en l'occurrence ici
une Stream qui contient.

00:03:42.470 --> 00:03:46.230 align:middle
Donc subtilité en Pharo toutes les
collections commencent à l'indice 1.

00:03:46.680 --> 00:03:49.780 align:middle
Donc si je demande à cette
collection de 3 éléments de me

00:03:50.000 --> 00:03:52.470 align:middle
rendre l'élément à
l'indice 2, c'est bien'hates'.

00:03:52.670 --> 00:03:53.430 align:middle
Donc c'est bien celui-là.

00:03:53.780 --> 00:03:55.920 align:middle
Ça c'est 1, ça c'est 2, ça c'est 3.

00:03:57.260 --> 00:03:58.650 align:middle
Donc c'est la même chose
pour les OrderedCollection, si

00:03:58.850 --> 00:04:01.400 align:middle
je convertis cette
collection en OrderedCollection et je

00:04:01.600 --> 00:04:04.210 align:middle
lui demande son élément indice 2,
ça me revient'hates'la même chose.

00:04:05.950 --> 00:04:08.890 align:middle
Donc les collections peuvent
contenir toutes sortes d'objets,

00:04:09.090 --> 00:04:12.380 align:middle
comme je l'ai dit, et ici
je vous en montre un exemple

00:04:12.580 --> 00:04:15.190 align:middle
cette collection littérale
va contenir, dans son premier

00:04:15.390 --> 00:04:17.770 align:middle
élément, la chaîne des
caractères'calvin', et dans son

00:04:18.000 --> 00:04:21.460 align:middle
second élément une collection
qui contiendra les nombres 1, 2, 3.

00:04:22.150 --> 00:04:25.360 align:middle
Je peux créer par exemple un
tableau, donc ici ce tableau

00:04:25.560 --> 00:04:30.000 align:middle
il est composé des éléments 1, 2 ici

00:04:31.060 --> 00:04:32.490 align:middle
et d'un Set à la fin.

00:04:33.280 --> 00:04:36.960 align:middle
Donc l'élément 1 a été ajouté
ici, l'élément 2 ici et le Set ici.

00:04:38.240 --> 00:04:40.180 align:middle
Donc on peut maintenant
parcourir les éléments d'une

00:04:40.380 --> 00:04:43.810 align:middle
collection, en utilisant
le message "do" par exemple.

00:04:44.730 --> 00:04:49.000 align:middle
Donc ici j'ai une collection et je
vais lui envoyer le message "do".

00:04:49.690 --> 00:04:52.910 align:middle
Je vais lui passer un
block, donc je vous rappelle le

00:04:53.110 --> 00:04:55.380 align:middle
block ici il commence avec
le crochet ouvrant, il se

00:04:55.580 --> 00:04:59.040 align:middle
ferme avec le crochet fermant.
Le paramètre du block il s'appelle

00:04:59.240 --> 00:05:00.550 align:middle
"each", donc qui commence par un :.

00:05:00.920 --> 00:05:03.850 align:middle
Il est séparé du corps de
block par la barre verticale et

00:05:04.050 --> 00:05:06.410 align:middle
on va à chaque tour de
boucles, "each" vaudra le premier

00:05:06.610 --> 00:05:08.550 align:middle
élément de la collection, le
deuxième et caetera jusqu'à la fin.

00:05:08.920 --> 00:05:12.180 align:middle
Donc on va bien afficher sur le
Transcript Calvin hates Suzie.

00:05:14.640 --> 00:05:15.400 align:middle
Donc on a les tableaux.

00:05:16.110 --> 00:05:18.190 align:middle
Donc les tableaux c'est des
collections de taille fixe.

00:05:18.410 --> 00:05:21.820 align:middle
Donc on peut demander à un tableau sa
taille, j'y envoie le message "size".

00:05:22.580 --> 00:05:25.160 align:middle
On peut accéder directement
à un élément d'un tableau en

00:05:25.360 --> 00:05:28.050 align:middle
lui envoyant le message "at:", je
veux l'élément 2 de la collection.

00:05:28.250 --> 00:05:31.080 align:middle
On peut modifier
l'élément à l'indice 2 dans la

00:05:31.280 --> 00:05:35.030 align:middle
collection en
envoyant at:1 put'Calvin'.

00:05:35.730 --> 00:05:38.240 align:middle
Donc je vais insérer la
chaîne Calvin dans la case 1.

00:05:39.360 --> 00:05:40.630 align:middle
Et puis je peux demander la taille.

00:05:40.830 --> 00:05:45.040 align:middle
L'élément intéressant ici
dans cet exemple c'est qu'on

00:05:45.240 --> 00:05:47.430 align:middle
voit qu'on a construit le
même tableau de 2 manières

00:05:47.630 --> 00:05:50.580 align:middle
différentes: une première
version littérale et une

00:05:50.780 --> 00:05:52.860 align:middle
deuxième version
dynamique ici, où j'ai vraiment

00:05:53.060 --> 00:05:57.730 align:middle
instancié la classe Array à la
main et rempli chacune des cases.

00:05:59.590 --> 00:06:02.250 align:middle
Donc on peut envoyer le
message "size" à une collection

00:06:02.450 --> 00:06:05.240 align:middle
pour récupérer sa taille. On
peut accéder à un élément d'une

00:06:05.440 --> 00:06:07.400 align:middle
collection en lui
fournissant la méthode "at:".

00:06:07.800 --> 00:06:08.830 align:middle
Donc ça j'en ai déjà parlé.

00:06:10.590 --> 00:06:12.610 align:middle
Donc il faut faire
attention il y a une subtilité.

00:06:12.810 --> 00:06:14.760 align:middle
Quand j'accède à un
élément d'une collection en

00:06:14.960 --> 00:06:17.190 align:middle
fournissant un indice, il
faut faire attention que cet

00:06:17.390 --> 00:06:21.660 align:middle
indice soit bien dans
les bornes acceptées par la

00:06:21.860 --> 00:06:23.700 align:middle
collection, qu'il soit
inférieur à la taille de la collection.

00:06:24.030 --> 00:06:26.950 align:middle
Si je demande à cette
collection l'élément à l'indice 55

00:06:27.150 --> 00:06:28.790 align:middle
forcément il n'existe pas
puisque cette collection a une

00:06:29.000 --> 00:06:30.330 align:middle
taille 3, donc ça va
bien me rendre une erreur.

00:06:33.500 --> 00:06:36.020 align:middle
Donc pour modifier les
éléments, j'en ai parlé, à l'indice

00:06:36.220 --> 00:06:39.820 align:middle
2 je veux modifier,
insérer un nouvel élément dans la

00:06:40.020 --> 00:06:41.310 align:middle
collection, la chaine
des caractères'loves'.

00:06:41.620 --> 00:06:44.890 align:middle
Donc ça bien
remplacer'hates'par'loves', on le voit bien

00:06:45.530 --> 00:06:49.730 align:middle
ici dans le résultat.

00:06:49.950 --> 00:06:54.590 align:middle
Donc les tableaux littéraux,
donc on a ici un exemple de

00:06:54.790 --> 00:06:57.770 align:middle
tableau littéral, ça commence
par #( comme je vous l'avais

00:06:58.000 --> 00:07:00.330 align:middle
dit, on peut mettre
n'importe quoi dedans donc un nom ou

00:07:00.530 --> 00:07:01.540 align:middle
une chaine de caractères et cetera.

00:07:02.280 --> 00:07:05.680 align:middle
Et puis tous les
tableaux littéraux en Pharo sont

00:07:05.880 --> 00:07:07.350 align:middle
instance de la
 classe Array par défaut.

00:07:08.100 --> 00:07:10.470 align:middle
Donc je peux envoyer le
message "class" à un tableau

00:07:10.670 --> 00:07:12.290 align:middle
littéral et ça me rend bien Array.

00:07:12.490 --> 00:07:14.590 align:middle
Donc c'est bien une
instance de la classe Array.

00:07:18.850 --> 00:07:21.000 align:middle
Alors les versions
dynamiques et les versions littérales

00:07:21.200 --> 00:07:22.760 align:middle
sont exactement
équivalentes en Pharo.

00:07:22.960 --> 00:07:26.000 align:middle
C'est juste une version plus concise,
donc ça permet d'écrire ça plus vite.

00:07:26.630 --> 00:07:30.020 align:middle
Donc ici vous avez la
version littérale d'une collection

00:07:30.220 --> 00:07:32.510 align:middle
et vous avez sa version
dynamique où j'instancie vraiment

00:07:32.710 --> 00:07:33.470 align:middle
la classe Array à la main.

00:07:33.830 --> 00:07:35.440 align:middle
Mais c'est complètement
équivalent puisque vous voyez

00:07:35.640 --> 00:07:36.830 align:middle
bien que les 2
résultats sont les mêmes.

00:07:40.080 --> 00:07:43.100 align:middle
Donc la classe
OrderedCollection définit une collection

00:07:43.300 --> 00:07:46.570 align:middle
particulière, qui est
extensible, donc à chaque fois qu'on

00:07:46.770 --> 00:07:48.550 align:middle
va ajouter des
éléments elle va s'agrandir.

00:07:49.290 --> 00:07:53.460 align:middle
Donc ici j'instancie la classe
OrderedCollection en envoyant un message new.

00:07:53.660 --> 00:07:55.670 align:middle
J'utilise la méthode
"add" pour ajouter différents

00:07:55.870 --> 00:07:58.510 align:middle
éléments dans cette
collection. J'ai même des variations

00:07:58.710 --> 00:08:00.870 align:middle
je peux faire "addFirst"
pour ajouter un élément au début

00:08:01.070 --> 00:08:02.610 align:middle
de la collection, par
défaut il s'ajoute à la fin.

00:08:04.510 --> 00:08:07.890 align:middle
Donc vous voyez à chaque fois
ce que nous rend la collection.

00:08:08.090 --> 00:08:11.450 align:middle
Donc là on a bien 3 éléments dans
la collection: Pharo, Reef et Pharo.

00:08:11.720 --> 00:08:14.660 align:middle
Si je fais "add: Seaside",
"Seaside" est bien ajouté à la

00:08:14.860 --> 00:08:15.620 align:middle
fin de la collection.

00:08:18.180 --> 00:08:21.300 align:middle
J'ai des méthodes de conversion
entre un type de collection et un autre.

00:08:21.650 --> 00:08:24.840 align:middle
Donc par exemple ici
j'utilise une collection littérale,

00:08:25.040 --> 00:08:27.070 align:middle
donc qui va être un
Array et le message

00:08:27.270 --> 00:08:31.250 align:middle
asOrderedCollection qui va
transformer ce tableau en

00:08:31.710 --> 00:08:32.470 align:middle
collection ordonnée.

00:08:33.750 --> 00:08:37.020 align:middle
Enfin les Set. Donc les Set sont
un type de collection sans doublon.

00:08:37.450 --> 00:08:39.670 align:middle
Donc pareil de taille
extensible, donc à chaque fois que

00:08:39.870 --> 00:08:41.490 align:middle
va ajouter un élément ça va grandir.

00:08:41.840 --> 00:08:44.800 align:middle
Je peux utiliser une
collection littérale que je

00:08:45.000 --> 00:08:48.000 align:middle
transforme en Set et ça me
donne bien un Set dans lequel

00:08:48.200 --> 00:08:49.000 align:middle
les doublons ont été retirés.

00:08:50.440 --> 00:08:52.140 align:middle
Ou alors je peux accéder à la
version dynamique plutôt qu'une

00:08:52.340 --> 00:08:56.220 align:middle
collection littérale. Set
with with qui permet de créer

00:08:56.420 --> 00:08:59.090 align:middle
un Set et de le remplir avec 2
éléments, deux Set à chaque fois.

00:09:02.210 --> 00:09:03.800 align:middle
Donc les méthodes de
conversion sont extrêmement

00:09:04.000 --> 00:09:06.760 align:middle
pratiques pour jongler, pour
transformer une collection en un autre type.

00:09:07.000 --> 00:09:09.880 align:middle
Elles ont toujours la même
forme c'est "as" + le nom de

00:09:10.080 --> 00:09:11.250 align:middle
la collection qu'on voudra avoir.

00:09:14.080 --> 00:09:16.610 align:middle
Les dictionnaires. Donc c'est un
type de collection clés, valeurs.

00:09:16.810 --> 00:09:19.020 align:middle
À une clé donnée
j'associe une valeur.

00:09:19.390 --> 00:09:21.180 align:middle
Elles sont aussi
extensibles à chaque fois qu'on va

00:09:21.380 --> 00:09:23.640 align:middle
ajouter des éléments elles
vont grandir, et puis on a une

00:09:23.840 --> 00:09:28.400 align:middle
API un peu
particulière sur cette collection,

00:09:28.690 --> 00:09:31.820 align:middle
donc le message "at" qui lui
est classique, at:ifAbsent:

00:09:32.320 --> 00:09:34.440 align:middle
c'est-à-dire si je veux
accéder à un élément, à une clé

00:09:34.640 --> 00:09:37.890 align:middle
particulière mais qu'elle n'existe
pas, qu'est-ce que je dois rendre?

00:09:38.090 --> 00:09:40.840 align:middle
"at: put: donc à une clé
particulière je veux insérer une

00:09:41.040 --> 00:09:42.930 align:middle
nouvelle valeur et
caetera. Et puis je vais pouvoir

00:09:43.130 --> 00:09:46.890 align:middle
itérer avec des messages
tout à fait classiques "do", on

00:09:47.090 --> 00:09:49.080 align:middle
a déjà vu, mais on va
avoir des nouveaux messages

00:09:49.280 --> 00:09:52.650 align:middle
"KeysDo" donc je parcours
toutes les clés du dictionnaire

00:09:53.000 --> 00:09:54.060 align:middle
ou les clés et les valeurs.

00:09:54.520 --> 00:09:55.520 align:middle
Donc je vous donne un exemple.

00:09:55.720 --> 00:09:59.060 align:middle
Ici j'ai créé l'instance de
la classe dictionnaire, et

00:09:59.260 --> 00:10:02.110 align:middle
puis dans ce
dictionnaire, donc il faut voir un

00:10:02.310 --> 00:10:05.590 align:middle
dictionnaire un peu comme un
tableau, à la clé janvier j'associe

00:10:05.790 --> 00:10:09.820 align:middle
le nombre 31, à la clé février le
nombre 28 et à la clé mars le nombre 31.

00:10:13.020 --> 00:10:16.320 align:middle
Donc c'est complètement
équivalent à une collection dynamique.

00:10:16.520 --> 00:10:21.060 align:middle
Donc une collection dynamique cette
fois c'est créé avec une accolade.

00:10:21.260 --> 00:10:22.860 align:middle
Accolade ouvrante, accolade fermante.

00:10:23.840 --> 00:10:26.390 align:middle
Ici je vous rappelle la flèche
c'est pour créer des associations.

00:10:27.060 --> 00:10:28.900 align:middle
Donc ici j'ai un symbole.

00:10:29.290 --> 00:10:33.000 align:middle
Donc au symbole janvier
j'associe le nombre 31, donc ici

00:10:33.700 --> 00:10:36.610 align:middle
j'ai bien une collection
d'associations que je transforme

00:10:36.810 --> 00:10:38.150 align:middle
en dictionnaire avec
à le "Ad dictionary".

00:10:38.620 --> 00:10:42.760 align:middle
Donc ces 2 formes pour créer le
dictionnaire sont complètement équivalentes.

00:10:45.680 --> 00:10:47.830 align:middle
Donc si je demande à une
association, si je lui demande

00:10:48.030 --> 00:10:50.640 align:middle
sa clé ça va bien nous
renvoyer la clé, donc le début.

00:10:50.840 --> 00:10:52.380 align:middle
On voit qu'ici c'est l'équivalent.

00:10:52.700 --> 00:10:54.640 align:middle
Et puis si je demande à une
association de me retourner

00:10:54.840 --> 00:10:56.160 align:middle
sa valeur ça ne me
retourne que la valeur.

00:10:56.510 --> 00:10:58.410 align:middle
Donc ça c'est une
paire ou une association.

00:11:00.670 --> 00:11:01.620 align:middle
Donc les dictionnaires.

00:11:02.000 --> 00:11:05.630 align:middle
Si je veux dans un
dictionnaire accéder à une valeur

00:11:05.830 --> 00:11:09.420 align:middle
particulière, il suffit que
j'utilise "at" et la clé, je

00:11:09.620 --> 00:11:11.240 align:middle
spécifie la clé pour
laquelle je veux la valeur.

00:11:11.880 --> 00:11:15.250 align:middle
Si c'est une clé qui est
inexistante forcément je vais

00:11:15.560 --> 00:11:16.660 align:middle
récupérer une erreur en retour.

00:11:18.720 --> 00:11:21.310 align:middle
Et si je veux éviter ça
ce que je peux faire c'est

00:11:21.510 --> 00:11:25.640 align:middle
utiliser "at: ifAbsent", donc
je fais "at" une clé qui n'existe

00:11:25.840 --> 00:11:28.010 align:middle
pas dans le dictionnaire, et
si c'est absent donc je vais

00:11:28.210 --> 00:11:30.590 align:middle
récupérer la valeur qui est ici le 0.

00:11:31.760 --> 00:11:33.020 align:middle
Donc on voit bien cette
clé n'existe pas dans le

00:11:33.220 --> 00:11:34.000 align:middle
dictionnaire donc je
récupère la valeur 0.

00:11:35.320 --> 00:11:37.730 align:middle
Je peux itérer sur un
dictionnaire, donc si je fais un

00:11:37.930 --> 00:11:41.400 align:middle
"do" sur les éléments d'un
dictionnaire je récupère en

00:11:41.600 --> 00:11:44.040 align:middle
fait ici que les
valeurs du dictionnaire.

00:11:44.280 --> 00:11:45.040 align:middle
On ne voit pas les clés.

00:11:45.460 --> 00:11:46.950 align:middle
Alors pourquoi on
peut se demander ça?

00:11:47.150 --> 00:11:48.950 align:middle
C'est un peu bizarre de ne
récupérer que les valeurs.

00:11:49.150 --> 00:11:51.740 align:middle
En fait c'est complètement
logique puisque si on regarde

00:11:51.940 --> 00:11:53.460 align:middle
dans la classe
"dictionnaire" l'implémentation de la

00:11:53.660 --> 00:11:57.170 align:middle
méthode "do", qui prend un
block, en fait elle fait à l'intérieur

00:11:57.370 --> 00:12:00.930 align:middle
selfvaluesDo. Donc par
défaut quand en fait un "do" sur

00:12:01.130 --> 00:12:03.570 align:middle
un dictionnaire, on ne parcourt
que ses valeurs et pas les clés.

00:12:05.520 --> 00:12:08.060 align:middle
Si je veux parcourir les
2 en fait j'ai une méthode

00:12:08.260 --> 00:12:11.260 align:middle
particulière qui s'appelle
"KeysAndValuesDo", qui prend

00:12:11.460 --> 00:12:14.720 align:middle
en paramètre un block
avec 2 arguments: k et v.

00:12:15.340 --> 00:12:18.510 align:middle
Et donc k ça correspondra
bien à une clé et v à la valeur.

00:12:19.350 --> 00:12:22.000 align:middle
Donc cette fois j'ai bien
mon dictionnaire complet.

00:12:24.000 --> 00:12:27.090 align:middle
Donc en résumé dans cette
séquence on a vu que Pharo

00:12:27.370 --> 00:12:30.170 align:middle
propose énormément de types
de collections différents.

00:12:31.290 --> 00:12:33.300 align:middle
Que toutes les
collections proposent un vocabulaire

00:12:33.500 --> 00:12:36.000 align:middle
commun, que ce soit pour
créer des collections, pour

00:12:36.200 --> 00:12:38.610 align:middle
accéder aux éléments, pour accéder à
la taille d'une collection et caetera.

00:12:39.000 --> 00:12:40.350 align:middle
Donc ça, ça facilite
la vie du programmeur.

00:12:41.290 --> 00:12:44.370 align:middle
Et c'est simple aussi de convertir un
type de collection en un autre type.

00:12:44.950 --> 00:12:46.840 align:middle
Et vous on a même vu quelque
chose de supplémentaire, on

00:12:47.040 --> 00:12:49.080 align:middle
a vu que quand on se pose des
questions il est facile d'aller

00:12:49.280 --> 00:12:51.760 align:middle
découvrir dans le système,
dans Pharo, en allant lire le

00:12:52.000 --> 00:12:54.280 align:middle
code des classes, en allant découvrir
de nouvelles classes de collections.

