mozilla
Vos résultats de recherche

    Map

    Cette fonction, proposition pour ECMAScript 6 (Harmony), est expérimentale
    Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.
    Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

    L'objet Map représente un dictionnaire, autrement dit une carte de clés/valeurs. N'importe quelle valeur valable en JavaScript (que ce soit les objets ou les valeurs de types primitifs) peut être utilisée comme clé ou comme valeur.

    Syntaxe

    new Map([itérable])
    

    Paramètres

    itérable
    Un tableau Array ou tout autre objet itérable dont les éléments sont des paires clé/valeur (des objets Arrays à deux éléments). Chaque paire clé/valeur sera ajoutée au nouvel objet Map.

    Description

    Un objet Map permet de retrouver ses éléments dans leur ordre d'insertion. Par exemple, une boucle for..of renverra un tableau de [clé, valeur] pour chaque itération.

    Égalité des clés

    L'égalité des clés est testée avec l'algorithme testant l'égalité de valeurs : NaN est considéré égal à NaN (bien que, pour l'égalité stricte NaN !== NaN), les autres valeurs sont considérées égales au sens de l'égalité stricte (l'opérateur  ===). Dans les versions précédentes des brouillons ECMAScript 6 -0 et +0 étaient considérés différents (bien que -0 === +0), ceci a été changé dans les versions ultérieures et a été adapté avec Gecko 29 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (bug 952870) et une version nocturne de Chrome.

    Comparaison entre objets et maps

    Les objets sont similaires aux Maps, chacun manipulant des clés associées à des valeurs, récupérant ces valeurs, supprimant des clés... C'est pourquoi, historiquement, les objets JavaScript ont été utilisés comme des Maps. Malgré tout, il y a des différences importantes entre Objects et Maps qui permettent de distinguer une utilisation des objets Map plus efficace :

    • Un Object possède un prototype, il peut donc y avoir certaines clés par défaut. On peut contourner cela en utilisant map = Object.create(null).
    • Les clés d'un Object sont des chaînes de caractères, alors que pour une Map ça peut être n'importe quelle valeur.
    • Il est possible d'obtenir facilement la taille d'une Map. En revanche, pour un Object il faudra compter « manuellement ».

    Il est conseillé d'utiliser des Maps plutôt que des objets quand les clés sont inconnus au moment de l'exécution et lorsque toutes les clés sont du même type et que toutes les valeurs sont du même type.

    Il est conseillé d'utiliser des objets génériques quand on retrouve une certaine logique pour chacun des éléments individuels.

    Propriétés

    Map.length
    La valeur de la propriété length est 0.
    get Map[@@species]
    La fonction constructeur utilisée pour créer des objets dérivées.
    Map.prototype
    Représente le prototype du constructeur Map. Permet l'addition de propriétés à tous les objets Map.

    Instances de Map

    Toutes les instances de Map héritent de Map.prototype.

    Propriétés

    Map.prototype.constructor
    Renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera la fonction Map.
    Map.prototype.size
    Renvoie le nombre de paires de clé-valeur contenues dans l'objet Map.

    Méthodes

    Map.prototype.clear()
    Supprime toutes les paires de clé-valeur de l'objet Map.
    Map.prototype.delete(clé)
    Supprime n'importe quelle valeur associée à la clé. Map.prototype.has(clé) renverra false une fois l'opération effectuée.
    Map.prototype.entries()
    Renvoie un nouvel objet Iterator qui contient un tableau de [clé, valeur] pour chacun des éléments de l'objet Map, dans leur ordre d'insertion.
    Map.prototype.forEach(callbackFn[, thisArg])
    Appelle la fonction callbackFn pour chaque paire clé-valeur de l'objet Map dans leur ordre d'insertion. Si un paramètre thisArg est fourni, il sera utilisé comme valeur pour this pour chaque appel de la fonction de retour (callback).
    Map.prototype.get(clé)
    Renvoie la valeur associée à la clé et undefined s'il n'y en a pas.
    Map.prototype.has(clé)
    Renvoie un booléen indiquant si une valeur associée à cette clé a été trouvée dans l'objet Map.
    Map.prototype.keys()
    Renvoie un nouvel objet Iterator contenant les clés de chaque élément de l'objet Map dans leur ordre d'insertion.
    Map.prototype.set(clé, valeur)
    Définit la valeur d'un clé pour l'objet Map. Renvoie undefined.
    Map.prototype.values()
    Renvoie un nouvel objet Iterator contenant les valeurs de chaque élément de l'objet Map dans leur ordre d'insertion.
    Map.prototype[@@iterator]()
    Renvoie une nouvel objet Iterator qui contient un tableau de [clé, valeur] pour chaque élément de l'objet Map dans leur ordre d'insertion.

    Exemples

    Utiliser un objet Map

    var maMap = new Map();
    
    var objetClé = {},
        fonctionClé = function () {},
        chaineClé = "une chaîne";
    
    // définir les valeurs
    maMap.set(chaineClé, "valeur associée à 'une chaîne'");
    maMap.set(objetClé, "valeur associée à objetClé");
    maMap.set(fonctionClé, "valeur associée à fonctionClé");
    
    maMap.size; // 3
    
    // getting the values
    maMap.get(chaineClé);    // "valeur associée à 'une chaîne'"
    maMap.get(objetClé);     // "valeur associée à objetClé"
    maMap.get(fonctionClé);  // "valeur associée à fonctionClé"
    
    maMap.get("une chaîne"); // "valeur associée à 'une chaîne'"
                             // car chaineClé === 'une chaîne'
    maMap.get({});           // indéfini car objetClé !== {}
    maMap.get(function() {}) // indéfini car fonctionClé !== function () {}
    

    Utiliser NaN comme clé

    NaN peut être utilisé comme une clé. Bien que NaN ne soit pas strictement égal à lui-même (NaN !== NaN est vérifié), on peut bâtîr l'exemple suivant car on ne peut pas distinguer deux valeurs NaN :

    var maMap = new Map();
    maMap.set(NaN, "not a number");
    
    maMap.get(NaN); // "not a number"
    
    var autreNaN = Number("toto");
    maMap.get(otherNaN); // "not a number"
    

    Parcourir des objets Maps avec for..of

    Il est possible de parcourir les objets Map grâce à des boucles for..of :

    var maMap = new Map();
    maMap.set(0, "zéro");
    maMap.set(1, "un");
    for (var [clé, valeur] of maMap) {
      console.log(clé + " = " + valeur);
    }
    // On aura 2 lignes : la première avec "0 = zéro"
    // la seconde avec "1 = un"
    
    for (var clé of maMap.keys()) {
      console.log(clé);
    }
    // On aura 2 lignes : la première avec "0"
    // et la seconde avec "1"
    
    for (var valeur of maMap.values()) {
      console.log(valeur);
    }
    // On aura 2 lignes : la première avec "zéro"
    // et la seconde avec "un"
    
    for (var [clé, valeur] of maMap.entries()) {
      console.log(clé + " = " + valeur);
    }
    // On aura 2 lignes : la première avec "0 = zéro"
    // la seconde avec "1 = un"
    
    maMap.forEach(function(valeur, clé) {
      console.log(clé + " = " + valeur);
    }, maMap)
    // On aura 2 lignes : la première avec "0 = zéro"
    // la seconde avec "1 = un"
    

    Relation avec les objets Array

    var tableauCléValeur = [["clé1", "valeur1"], ["clé2", "valeur2"]];
    
    // On utilise le constructeur Map
    // pour transformer un tableau de clés/valeurs
    // en un objet map
    var maMap = new Map(tableauCléValeur);
    
    maMap.get("clé"); // renvoie "valeur1"
    
    // On utilise l'opérateur de décomposition pour transformer
    // une map en un tableau de clés/valeurs
    console.log(uneval([...maMap])); // affichera la même chose que tableauCléValeur
    
    // On peut utiliser l'opérateur de décomposition sur l'itérateur
    // des clés (ou des valeurs) pour n'obtenir que les clés
    console.log(uneval([...maMap.keys()])); // Will show ["clé1", "clé2"]

    Spécifications

    Spécification Statut Commentaires
    ECMAScript 6 (ECMA-262)
    La définition de 'Map' dans cette spécification.
    En cours de validation comme recommandation Définition initiale.

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple

    31 [1]
    38

    13 (13) 11 25 7.1
    Argument du constructeur : new Map(itérable) 38 13 (13) Pas de support 25 Pas de support
    itérable 38 17 (17) Pas de support 25 7.1
    Map.clear() 31 [1]
    38
    19 (19) 11 25 7.1
    Map.keys(), Map.values(), Map.entries() 37 [1]
    38
    20 (20) Pas de support 25 7.1
    Map.forEach() 36 [1]
    38
    25 (25) 11 25 7.1
    Égalité des clés pour -0 et 0 34 [1]
    38
    29 (29) Pas de support 25 Pas de support
    Argument du constructeur : new Map(null) (Oui) 37 (37) ? ? ?
    set() dans le constructeur (Oui) 37 (37) ? ? ?
    Map[@@species] ? 41 (41) ? ?  
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple Pas de support 31 [1]
    38
    13.0 (13) Pas de support Pas de support iOS 8
    Argument du constructeur : new Map(iterable) Pas de support 38 13.0 (13) Pas de support Pas de support Pas de support
    itérable Pas de support Pas de support 17.0 (17) Pas de support Pas de support iOS 8
    Map.clear() Pas de support 31 [1]
    38
    19.0 (19) Pas de support Pas de support iOS 8
    Map.keys(), Map.values(), Map.entries() Pas de support 37 [1]
    38
    20.0 (20) Pas de support Pas de support iOS 8
    Map.forEach() Pas de support 36 [1]
    38
    25.0 (25) Pas de support Pas de support iOS 8
    Égalité des clés entre -0 et 0 Pas de support 34 [1]
    38
    29.0 (29) Pas de support Pas de support Pas de support
    Argument du constructeur : new Map(null) ? (Oui) 37.0 (37) ? ? ?
    set() dans le constructeur ? (Oui) 37.0 (37) ? ? ?
      ? ? 41.0 (41) ? ?  

    [1] Cette fonctionnalité est disponible dans Chrome derrière un réglage utilisateur. Sous chrome://flags, activer l'élément « Activer la fonctionnalité expérimentale JavaScript ».

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: teoli, SphinxKnight
    Dernière mise à jour par : SphinxKnight,