Javascript - Maps & Weakmaps

JAVASCRIPT (Programmation Internet)
VOL. XXII
J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
diasfb@mail2world.com
LES « Maps » && « WeakMaps » :
Les « Maps » sont des « Arrays » presque comme des « Associative Ar-
rays », leurs données sont regroupées dans des couples « key : value ».
Deux différences c’est que
1. Dans les « Maps » les couples « key : value » sont regroupés dans
des Arrays à seulement ces deux éléments, ces couples étant séparés entre
eux par une virgule ;
2. Le tout est délimité/regroupé dans une grande array le « Map » dé-
limitée par des crochets au lieu des accolades contrairement aux « Associa-
tives Arrays ».
<script type="text/javascript"> "use strict";

var map = new Map([
['a', 20], [Date.now(), 54],
[45, Date.now()], [18, 'c']
]);
console.log(map);
// Map(4) {
// a -> 20, 1544283193937 -> 54,
// 45 -> 1544283193937, 18 -> "c"
// }
for(var el of map) console.log(el);
var t=`${"Keys".padEnd(7," ")} = | `;

for(var cle of map.keys()) t += cle + ` | `;
console.log(t);
J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-XXII
var t=`${"Values".padEnd(7," ")} = * `;
for(var val of map.values()) t += val + ` * `;
console.log(t);
</script>
Maps && WeakMaps - 2/27 - mardi, 22. janvier 2019 (9:30 )

Quelques méthodes de l’objet « Map ( ) » :

var a = [Date.now()];
console.log(a); // Array [ 1544273035052 ]
var map = new Map([['a', 20], [18, 35], [91, 54]]);

console.log(map);
// Firefox : Map { a -> 20, 18 -> 35, 91 -> 54 }
// Yandex : Map(2) {"a" => 20, 18, 91 -> 54 => 35}
map.set(a, 64).set(true, 85);

console.log(map);
// Map(4) { a -> 20, 18 -> 35, 91 -> 54, (1) […] -> 64,
true -> 85 }

// Map(4) {"a" => 20, 18 => 35, 91 -> 54, Array(1) => 64,
true => 85}
console.log(map.size); // => 5
console.log(map.has(a)); // => true
console.log(map.has([1])); // => false
console.log(map.get(a)); // => 64
console.log(map.get(18)); // => 35
console.log(map.get(true)); // => 85
let k="+ ", v="* ";

map.forEach(function (val, key) {
v+=val + ` * `;
k+=key + ` + `;
});
console.log(k);
// => + a + 18 + 91 + 1544274283091 + true +
console.log(v);
// => * 20 * 35 * 54 * 64 * 85 *
map.delete(a);
console.log(map.get(a)); // => undefined
console.log(Array.from(map));
// Firefox :
// => Array(4) [ (2) […], (2) […], (2) […], (2) […] ]
// (4) […]
// 0: Array [ "a", 20 ]
// 1: Array [ 18, 35 ]
// 2: Array [ 91, 54 ]
// 3: Array [ true, 85 ]
// length: 4
// <prototype>: Array []
//
// Yandex :
// => (4) (4) [Array(2), Array(2), Array(2), Array(2)]
// 0: (2) ["a", 20]
// 1: (2) [18, 35]
// 2: (2) [91, 54]
// 3: (2) [true, 85]
// length: 4
// __proto__: Array(0)
var map = new Map([

['a', 56], [Date.now(), 40],
[78, 'c'], [41, Date.now()]
]);
console.log(map);
// Map(4) { a -> 56, 1544277041459 -> 40,
// 78 -> "c", 41 -> 1544277041459 }
let kya=[], vla=[];

for (var [cle, valeur] of map) {
kya=kya.concat(cle);
vla.push(valeur);
}
console.log(kya);
// Array(4) [ "a", 1544277173449, 78, 41 ]
console.log(vla);
// Array(4) [ 56, 40, "c", 1544277173449 ]
let vl = [];
for (let valeurs of map.values()){
vl=vl.concat(valeurs);
}
console.log(vl);
// Array(4) [ 56, 40, "c", 1544277643496 ]
let ky = [];
for (var cles of map.keys()){
ky.push(cles);
}
console.log(ky);
// => Array(4) [ "a", 1544277741029, 78, 41 ]
</script>
Lisez les commentaires dans le code ci-dessous :

var a = [Date.now()];
console.log(a); // Array [ 1544273035052 ]
var map = new Map([['a', 20], [18, 35], [91, 54]]);

console.log(map);
// Firefox : Map { a -> 20, 18 -> 35, 91 -> 54 }
// Yandex : Map(2) {"a" => 20, 18, 91 -> 54 => 35}
map.set(a, 64).set(true, 85);

console.log(map);
// Map(4) { a -> 20, 18 -> 35, 91 -> 54, (1) […] -> 64,
true -> 85 }
// Map(4) {"a" => 20, 18 => 35, 91 -> 54, Array(1) => 64,
true => 85}
console.log(map.has(a)); // => true
console.log(map.has([1])); // => false
console.log(map.get(a)); // => 64
console.log(map.get(18)); // => 35
console.log(map.get(true)); // => 85
let k="+ ", v="* ";

map.forEach(function (val, key) {
v+=val + ` * `;
k+=key + ` + `;
});
console.log(k);
// => + a + 18 + 91 + 1544274283091 + true +
console.log(v);
// => * 20 * 35 * 54 * 64 * 85 *
map.delete(a);
console.log(map.get(a)); // => undefined
console.log(Array.from(map));
// Firefox :
// => Array(4) [ (2) […], (2) […], (2) […], (2) […] ]
// (4) […]
// 0: Array [ "a", 20 ]
// 1: Array [ 18, 35 ]
// 2: Array [ 91, 54 ]
// 3: Array [ true, 85 ]
// length: 4
//
// Yandex :
// => (4) (4) [Array(2), Array(2), Array(2), Array(2)]
// 0: (2) ["a", 20]
// 1: (2) [18, 35]
// 2: (2) [91, 54]

// 3: (2) [true, 85]
// length: 4
// __proto__: Array(0)
var map = new Map([

['a', 56], [Date.now(), 40],
[78, 'c'], [41, Date.now()]
]);
console.log(map);
// Map(4) { a -> 56, 1544277041459 -> 40,
// 78 -> "c", 41 -> 1544277041459 }
let kya=[], vla=[];

for (var [cle, valeur] of map) {
kya=kya.concat(cle);
vla.push(valeur);
}
console.log(kya);
// Array(4) [ "a", 1544277173449, 78, 41 ]
console.log(vla);
// Array(4) [ 56, 40, "c", 1544277173449 ]
let vl = [];
for (let valeurs of map.values()){
vl=vl.concat(valeurs);
}
console.log(vl);
// Array(4) [ 56, 40, "c", 1544277643496 ]
let ky = [];
for (var cles of map.keys()){
ky.push(cles);
}
console.log(ky);
// => Array(4) [ "a", 1544277741029, 78, 41 ]
</script>

Les « WeakMap » :
Lisez les commentaires :

var a = [96, 10] , b = [43,[67, 84]] , c = [96, 42, 64];
var wmap = new WeakMap([[a, 1], [b, 2]]);

console.log(wmap);
// WeakMap { (2) […] -> 2, (2) […] -> 1 }
// <entries>?
// 0: Array [ … ] ? 2
// <key>: Array [ … ]
// <key>: (2) […]
// 0: 96
// 1: 10
// length: 2
// <value>: 2
// 1: Array [ … ] ? 1
// <key>: Array [ … ]
// <key>: (2) […]
// 0: 43
// 1: Array [ 67, 84 ]
// 1: (2) […]
// 0: 67
// 1: 84
// length: 2
// length: 2
// <value>: 2
// <prototype>: Object { … }
wmap.set(c, 3).set(b, 4);

console.log(wmap);
// WeakMap(3) { (2) […] -> 1, (2) […] -> 4, (3) […] -> 3 }
// WeakMap(3)
// <entries>
// 0: Array [ … ] -> 1
// 0: (2) […] ? 1
// <key>: Array [ … ]

// <key>: (2) […]
// 0: 96
// 1: 10
// length: 2
// <value>: 1
// 1: Array [ … ] -> 4
// 1: (2) […] -> 4
// <key>: Array [ … ]
// <key>: (2) […]
// 0: 43
// 1: Array [ 67, 84 ]
// length: 2
// <value>: 4
// 2: Array(3) [ … ] -> 3
// 2: (3) […] -> 3
// <key>: Array(3) [ … ]
// <key>: (3) […]
// 0: 96
// 1: 42
// 2: 64
// length: 3
// <value>: 3
// <prototype>: Object { … }
console.log("wmap.has([96, 42, 64]) = ",

wmap.has([96, 42, 64])); // => false
console.log(wmap.has(c)); // => true
console.log(wmap.get(a)); // => 1
console.log(wmap.get(b)); // => 4
console.log(wmap.get(c)); // => 3
wmap.delete(b);
console.log(wmap.get(b)); // => undefined
</script>
Le « get » et le « set » avec les « weakMap » :

var Oeil = (function () {
console.log("Dans « Oeil »");
var organes = new WeakMap;
console.log("this = ",this);
// this = undefined
function Oeil(lequel) {
organes.set(this, lequel);
console.log("this = ",this);
// this = Object { }
// this = Oeil {}
}
Oeil.prototype.dispOrgan = function () {
return organes.get(this);
};
Oeil.prototype.dispOrganPlus = function () {
return [organes.get(this)," Surchargé"];
};
return Oeil;
})();
console.log("Départ ...");
// Départ ...
var bruch = new Oeil('Membane de Bruch');

// Dans « Oeil »
console.log("Après « Oeil »");

// Après « Oeil »
console.log(bruch);
// Object { }
// Oeil {}
console.log(bruch.dispOrgan());
// Membane de Bruch
console.log(bruch.dispOrganPlus()[0]
, bruch.dispOrganPlus()[1]);
// Membane de Bruch Surchargé
for (var idx in bruch)

console.log("* for (var idx in bruch) => ",idx);
// * for (var idx in bruch) => dispOrgan

// * for (var idx in bruch) => dispOrganPlus
</script>


Ne confondez pas la méthode « Array . map » (qui permet

d’appliquer un même traitement à chaque membre d’une array) et
l’objet Map (capitalisé) qui permet de créer un objet HashTable ou
Dictionary. Ce HashTable est comme un objet ordinaire avec des
clés et des valeurs associées, sauf qu’un Map peut utiliser comme
clé n’importe quoi sauf les mots clés (numérique, string ou objet),
alors que les autres objets n’admettent que des strings comme clés.
Pour accéder aux clés Map utilise les méthodes « get » et « set ».,
alors que les objets utilisent le point séparateur (« objet . clé »).
La clé d’un Map doit être soit un nombre (entre guillemets ou pas :
les deux sont distincts), soit une chaîne représenté un objet déjà défi-
ni, ou alors une chaîne littérale (entre guillemets).

let y = new Map(); // objet Map
y.set(2018, 'val de 2018');
y.set("25", 'val de 25');
y.set("z", 'val de "z"');
let x = new Map(); // objet Map

let objectKey = { key: 'keyvalue' }; // litt d'objet.
console.log(objectKey); // Object { key: "key-value" }

console.log(objectKey.key); // keyvalue
console.log(x.get(objectKey)); // undefined
x.set(1, 'clé numérique');

console.log(x.get(1)); // clé numérique
x.set('1', 'clé string');

console.log(x.get('1')); // clé string
x.set('objk', objectKey);
console.log(x.get('objk'));
// Object { key: "keyvalue" }
x.set(objectKey, ['une', 'Array', 'comme', 'val-eur']);

console.log(x.get(objectKey));
// (4) ["une", "Array", "comme", "valeur"]
console.log(objectKey.key); // keyvalue
let fv=function(){this.pr="Property"};
x.set(fv, 'objet expression de fonction');
console.log(x.get(fv));
// objet expression de fonction
console.log(y);
// Map(3) {
// 2018 => "val de 2018",
// "25" => "val de 25",
// "z" => "val de "z""
// }
x.set(y, 'Et même un autre objet Map');

console.log(x.get(y));
// Et même un autre objet Map
// L'objet Map clé ici n'altère pas
// l'objet Map de départ.
console.log(y);
// Map(3) {
// 2018 => "val de 2018",
// "25" => "val de 25",
// "z" => "val de "z""
// }
// L'objet Map de départ n'a pas été altéré.
console.log(x);
// Map(6) {
// 1 => "clé numérique",
// "1" => "clé string",
// "objk" => {…},

// {…} => Array(4),
// ƒ => "objet expression de fonction",
// …
// }
</script>

Création d’objet Map avec des itérables (array d’arrays ou un géné-

rateur) : new Map ( iterable : Object ).

var obj_key = { prop: 'property' };
var fromArray = new Map(

[[0, 'array0'], [obj_key, 'array1']]
);
// Initialisation de fromArray
// (nouvel objet Map)
// avec une itération d'arrays.
console.log(fromArray.get(0)); // array0
console.log(fromArray.get(obj_key)); // array1
console.log();
// Gnération d'entrées de Map

// avec une fonction génératrice.
var generator_fct = function*() {
yield [15, 'g15'];
yield [obj_key, 'gObK'];
};
// Initialisation de fromGenerator
// (nouvel objet Map)
// avec les entrées générées par un générateur.
var fromGenerator = new Map(generator_fct());
// Affichage des entrées de fromGenerator.

console.log(fromGenerator.get(15)); // g15
console.log(fromGenerator.get(obj_key)); // gObK
console.log(fromGenerator.size); // 2
fromGenerator.set('add', 'value of add');
console.log(fromGenerator.size); // 3
fromGenerator.delete(15); // Retire
console.log(fromGenerator);
// Map(2) {{…} => "gObK", "add" => "value of add"}
fromGenerator.clear(); // Efface tout

console.log(fromGenerator); // Map { }
</script>


Parcourons quelques propriétés de Map :
fromGenerator.hasOwnProperty() : false
fromGenerator.valueOf() : Map {
15 -> "g15",
{…} -> "gObK"
}
fromGenerator.toString() : [object Map]"
fromGenerator.toSource() : "({})"
fromGenerator.size : 2
fromArray.has(0) : true
fromGenerator.has(15) : true
fromGenerator.has(150) : false
Le prototype de Map :

Map()
length: 0
name: "Map"
prototype: {…}
clear: function clear()
constructor: function Map()
delete: function delete()
entries: function entries()
forEach: function forEach()
get: function get()
has: function has()
keys: function keys()
set: function set()
size: Getter
values: function values()
Symbol(Symbol.iterator): undefined
Symbol(Symbol.toStringTag): undefined
__proto__: Object { … }
Symbol(Symbol.species): undefined
__proto__: function ()
Map . entries ( ) :

var iMap = new Map(
[ [1, 'valueof 1'], ['s', 'valueof s'],
['9', 'valueof 9'] ]);
// BOUCLE FOR(...OF...) : Les entrées sont

// returnées par iMap[Symbol.iterator]
for (var value of iMap) { console.log(value); }
// Array [ 1, "valueof 1" ]
// Array [ "s", "valueof s" ]
// Array [ "9", "valueof 9" ]
// ITÉRATION EXPLICITE à travers les entrées

for (var value of iMap.values()) {
console.log(value); }
// valueof 1
// valueof s
// valueof 9
for (var entry of iMap.entries()) {

console.log(entry); }
// Array [ 1, "valueof 1" ]
// Array [ "s", "valueof s" ]
// Array [ "9", "valueof 9" ]
// PARCOURS MANUEL DE L'ITÉRATEUR

var entries = iMap.entries();
console.dir(entries.next());
/*
Object
done: false
value: (2) [1, "valueof 1"]
Object
done: false
value: (2) ["s", "valueof s"
Object
done: false
value: (2) ["9", "valueof 9"]
Object
done: true
value: undefined */
// ITÉRATION AVEC FOREACH
iMap.forEach(function(val, cle, obj) {

console.log(
'clé: "' + cle + '", val: "' + val + '" '+obj);
});
// clé: "1", val: "valueof 1" [object Map]
// clé: "s", val: "valueof s" [object Map]
// clé: "9", val: "valueof 9" [object Map]

// FOR (...OF...) pour parcourir l'itérateur
for(var cle of iMap.keys()) { console.log(cle); }
// 1
// s
// 9
for(var val of iMap.values()) { console.log(val); }

// valueof 1
// valueof s
// valueof 9
// UN AUTRE ACCÈS MANUEL À L'ITÉRATEUR

var cles = iMap.keys();
console.log(cles.next());
// Object { value: 1, done: false }
// Object { value: "s", done: false }
// Object { value: "9", done: false }
// Object { value: undefined, done: true }
var vals = iMap.values();
console.log(vals.next());
// Object { value: "valueof 1", done: false }
// Object { value: "valueof s", done: false }
// Object { value: "valueof 9", done: false }
// Object { value: undefined, done: true }
</script>
I. Remplacer des membres d’Array par d’autres :
<script type = "text/javascript"> "use strict";

// Remplacez tous les "Louis" par "Rose" et "Blue".
function suppress(parr, val) {
var i;

while ((i = parr.indexOf(val)) != -1) {
parr.splice(i, 1,"*ROSE*","*MAGENTA*");
}
return parr;
}
let arr=["Louis", "Delon", "Keriy", "Louis"]

let narr=suppress(arr, "Louis")
console.log(narr);
</script>
Maxthon v5.2.6.1000 et Opera Version 57.0.3098.106 :
Firefox 64.0b13 :

Yandex Version 18.11.1.385 beta :
Kinshasa, le mardi, 22. janvier 2019 (9:30 ).

Mots-clés :
Maps, Arrays typées, ArrayBuffer, WeakMap, Typed Array, Array, key,

value, JavaScript, EcmaScript, Associatives Arrays, Get, Set
DIASOLUKA Nz. Luyalu

Docteur en Médecine, Chirurgie & Accouchements (1977),
CNOM : 0866 - Spécialiste en ophtalmologie (1980)
Études humanités : Scientifique - Mathématiques & Physique.
Informaticien-amateur, Programmeur et WebMaster.
Chercheur indépendant, autonome et autofinancé, bénévole,

sans aucun conflit d’intérêt ou liens d'intérêts ou contrainte
promotionnelle avec qui qu’il soit ou quelqu’organisme ou
institution / organisation que ce soit, étatique, paraétatique ou
privé, industriel ou commercial en relation avec le sujet
présenté.
+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818
diasfb@mail2world.com
Autre Lecture :
https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-de-La-
Creation
D’autres publications pouvant aussi intéresser :

• https://www.scribd.com/document/377036251/Le-Dosage-
Des-Medicaments-en-Cac-Cas
• https://www.scribd.com/document/377035454/Le-Hasard-
Des-Thermometres-Non-contact-a-Infrarouge
• https://www.scribd.com/document/376222482/Petite-
Introduction-Aux-Fonctions-JavaScript
• https://www.scribd.com/document/376221919/La-Foi-en-
Jesus-Christ-Pour-Quoi-Faire
• https://www.scribd.com/document/375689778/Lacuite-
visuelle-angulaire
• https://www.scribd.com/document/375349851/La-variable-
This
• https://www.scribd.com/document/375024162/Fonctions-
Imbriquees-en-JS
• https://www.scribd.com/document/374789297/Format-
Interne-Des-Objets-JavaScript
• https://www.scribd.com/document/374788758/Iterations-en-
JavaScript
• https://www.scribd.com/document/374738470/Le-Plus-
Grand-Secret-de-La-Creation
• https://www.scribd.com/document/374597969/Nouvelle-
Formule-d-IMC-indice-de-doduite-Selon-Dr-Diasoluka
• https://www.scribd.com/document/373847209/Property-
Descriptors
• https://www.scribd.com/document/373833282/l-Objet-
Global-Window
• https://www.scribd.com/document/372665249/Javascript-
Tome-II
• https://www.scribd.com/document/355291488/motilite-
oculaire-2
• https://www.scribd.com/document/355291239/motilite-
oculaire-I
• https://www.scribd.com/document/355290248/Script-d-
Analyses-Des-Reflexes-Pupillomoteurs
•
https://www.scribd.com/document/321168468/Renseignement
s-Id-et-Anthropometriques
• https://www.scribd.com/document/320856721/Emission-31-
Jul-2016
•
https://www.scribd.com/document/318182982/Complication-
Visuelle-du-Traitement-de-La-Malaria
• https://www.scribd.com/document/318180637/Rapport-
Entre-Oxymetrie-Et-Type-Respiration
•
https://www.scribd.com/document/315746265/Classification-
Des-Medicaments
•
https://www.scribd.com/document/315745909/Incongruences-
Heresies-et-Heterodoxies-de-la-Notion-de-Laboratoire
• https://www.scribd.com/document/315745725/Rapport-
Entre-Oxymetrie-Et-Type-Respiration

Javascript - Maps &amp; Weakmaps

Transféré par

Informations du document

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Javascript - Maps &amp; Weakmaps

Transféré par

Droits d'auteur :

JAVASCRIPT (Programmation Internet)

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

LES « Maps » && « WeakMaps » :

<script type="text/javascript"> "use strict";

for(var el of map) console.log(el);

var t=`${"Keys".padEnd(7," ")} = | `;

Maps && WeakMaps - 2/27 - mardi, 22. janvier 2019 (9:30 )

Quelques méthodes de l’objet « Map ( ) » :

<script type="text/javascript"> "use strict";

var map = new Map([['a', 20], [18, 35], [91, 54]]);

map.set(a, 64).set(true, 85);

Maps && WeakMaps - 3/27 - mardi, 22. janvier 2019 (9:30 )

let k="+ ", v="* ";

var map = new Map([

Maps && WeakMaps - 4/27 - mardi, 22. janvier 2019 (9:30 )

let kya=[], vla=[];

Lisez les commentaires dans le code ci-dessous :

<script type="text/javascript"> "use strict";

var map = new Map([['a', 20], [18, 35], [91, 54]]);

map.set(a, 64).set(true, 85);

let k="+ ", v="* ";

Maps && WeakMaps - 6/27 - mardi, 22. janvier 2019 (9:30 )

var map = new Map([

let kya=[], vla=[];

Maps && WeakMaps - 7/27 - mardi, 22. janvier 2019 (9:30 )

Lisez les commentaires :

<script type="text/javascript"> "use strict";

var wmap = new WeakMap([[a, 1], [b, 2]]);

wmap.set(c, 3).set(b, 4);

Maps && WeakMaps - 8/27 - mardi, 22. janvier 2019 (9:30 )

console.log("wmap.has([96, 42, 64]) = ",

Le « get » et le « set » avec les « weakMap » :

<script type="text/javascript"> "use strict";

var bruch = new Oeil('Membane de Bruch');

console.log("Après « Oeil »");

for (var idx in bruch)

Maps && WeakMaps - 10/27 - mardi, 22. janvier 2019 (9:30 )

Maps && WeakMaps - 11/27 - mardi, 22. janvier 2019 (9:30 )

Maps && WeakMaps - 12/27 - mardi, 22. janvier 2019 (9:30 )

Ne confondez pas la méthode « Array . map » (qui permet

<script type="text/javascript"> "use strict";

let x = new Map(); // objet Map

console.log(objectKey); // Object { key: "key-value" }

x.set(1, 'clé numérique');

x.set('1', 'clé string');

x.set(objectKey, ['une', 'Array', 'comme', 'val-eur']);

x.set(y, 'Et même un autre objet Map');

Maps && WeakMaps - 14/27 - mardi, 22. janvier 2019 (9:30 )

Maps && WeakMaps - 15/27 - mardi, 22. janvier 2019 (9:30 )

Création d’objet Map avec des itérables (array d’arrays ou un géné-

Maps && WeakMaps - 16/27 - mardi, 22. janvier 2019 (9:30 )

<script type="text/javascript"> "use strict";

var fromArray = new Map(

// Gnération d'entrées de Map

// Affichage des entrées de fromGenerator.

fromGenerator.clear(); // Efface tout

Maps && WeakMaps - 17/27 - mardi, 22. janvier 2019 (9:30 )

Maps && WeakMaps - 18/27 - mardi, 22. janvier 2019 (9:30 )

Parcourons quelques propriétés de Map :

Maps && WeakMaps - 19/27 - mardi, 22. janvier 2019 (9:30 )

<script type="text/javascript"> "use strict";

// BOUCLE FOR(...OF...) : Les entrées sont

// ITÉRATION EXPLICITE à travers les entrées

for (var entry of iMap.entries()) {

// PARCOURS MANUEL DE L'ITÉRATEUR

// ITÉRATION AVEC FOREACH

iMap.forEach(function(val, cle, obj) {

Javascript - Maps & Weakmaps

Javascript - Maps & Weakmaps