Carte vs Objet en JavaScript

La principale différence est que les Objets de soutien de la chaîne de clés où des Cartes de soutien plus ou moins tout type de clé.

Si je ne obj[123] = true, puis de l'Objet.les touches(obj) alors j'aurai ["123"] plutôt que [123]. Une Carte permettrait de conserver le type de la clé et de retour [123] qui est grand. Des cartes vous permettent aussi d'utiliser des Objets comme des clés. Traditionnellement, pour ce faire, vous avez à donner aux objets une sorte d'identifiant unique de hachage (je ne pense pas que je n'ai jamais rien vu de tel getObjectId en JS dans le cadre de la norme). Des cartes de garantie de maintien de l'ordre sont donc tout rond mieux pour la préservation et peut parfois vous sauver de devoir faire quelques sortes.

Entre les cartes et les objets, dans la pratique, de très de plusieurs avantages et les inconvénients. Objets d'acquérir à la fois des avantages et des inconvénients d'être très bien intégré dans la base de JS qui les distingue de manière significative la Carte au-delà de la différence dans la clé de support.

Un avantage immédiat est que vous avez syntaxique de soutien pour les Objets facilitant l'accès à des éléments. Vous avez également un soutien direct pour avec JSON. Lorsqu'il est utilisé comme une table de hachage, c'est ennuyeux pour obtenir un objet sans propriétés à tous. Par défaut si vous souhaitez utiliser des Objets comme une table de hachage ils seront polluées et vous aurez souvent à l'appel hasOwnProperty sur eux lors de l'accès aux propriétés. Vous pouvez voir ici comment, par défaut, les Objets sont pollués et comment créer espérons-le, non polluées, les objets pour les utiliser comme des hachages:

({}).toString
    toString() { [native code] }
JSON.parse('{}').toString
    toString() { [native code] }
(Object.create(null)).toString
    undefined
JSON.parse('{}', (k,v) => (typeof v === 'object' && Object.setPrototypeOf(v, null) ,v)).toString
    undefined

De la Pollution sur des objets n'est pas seulement quelque chose qui rend le code plus ennuyeux, lent, etc, mais peut également avoir des conséquences potentielles pour la sécurité.

Les objets ne sont pas du pur tables de hachage, mais essayez de faire plus. Vous avez des maux de tête comme hasOwnProperty, de ne pas être en mesure d'obtenir la longueur facilement (Objet.les touches(obj).la longueur) et ainsi de suite. Les objets ne sont pas destinés uniquement être utilisé comme hachage des cartes, mais comme une dynamique évolutive d'Objets et donc quand vous les utilisez comme pure tables de hachage des problèmes surviennent.

Comparaison/Liste des différentes opérations communes:

    Object:
       var o = {};
       var o = Object.create(null);
       o.key = 1;
       o.key += 10;
       for(let k in o) o[k]++;
       var sum = 0;
       for(let v of Object.values(m)) sum += v;
       if('key' in o);
       if(o.hasOwnProperty('key'));
       delete(o.key);
       Object.keys(o).length
    Map:
       var m = new Map();
       m.set('key', 1);
       m.set('key', m.get('key') + 10);
       m.foreach((k, v) => m.set(k, m.get(k) + 1));
       for(let k of m.keys()) m.set(k, m.get(k) + 1);
       var sum = 0;
       for(let v of m.values()) sum += v;
       if(m.has('key'));
       m.delete('key');
       m.size();

Il ya quelques autres options, s'approcha, méthodologies, etc, avec des variations de hauts et de bas (la performance, laconique, portable, extensible, etc). Les objets sont un peu étrange au cœur de la langue de sorte que vous avez beaucoup de méthodes statiques pour travailler avec eux.

Outre l'avantage de Cartes en préservant types de clés ainsi que d'être en mesure de soutenir des choses comme des objets comme des clés, ils sont isolés d'effets secondaires que les objets de beaucoup ont. Une Carte est une pure hachage, il n'y a pas de confusion au sujet d'essayer d'être un objet en même temps. Les cartes peuvent également être facilement étendu avec les fonctions de proxy. L'objet actuellement d'une classe Proxy toutefois, le rendement et l'utilisation de la mémoire est sombre, en fait, la création de votre propre proxy qui ressemble à la Carte pour les Objets actuellement plus performante que la Procuration.

Un important désavantage pour les Cartes, c'est qu'ils ne sont pas pris en charge avec JSON directement. L'analyse est possible, mais a plusieurs décrochements:

JSON.parse(str, (k,v) => {
    if(typeof v !== 'object') return v;
    let m = new Map();
    for(k in v) m.set(k, v[k]);
    return m;
});

Ci-dessus va introduire un sérieux gain de performance et sera également pas en charge les clés de chaîne. Encodage JSON est encore plus difficile et problématique (c'est l'une des nombreuses approches):

//An alternative to this it to use a replacer in JSON.stringify.
Map.prototype.toJSON = function() {
    return JSON.stringify({
        keys: Array.from(this.keys()),
        values: Array.from(this.values())
    });
};

Ce n'est pas si mal si vous êtes purement à l'aide de Cartes mais ont des problèmes lorsqu'on mélange les types ou de l'utilisation non-valeurs scalaires comme les clés (pas que JSON est parfait avec ce genre de problème tel qu'il est, c'est à dire la circulaire de référence de l'objet). Je n'ai pas testé mais les chances sont qu'il va sérieusement affecter les performances par rapport à stringify.

D'autres langages de script, souvent, n'ont pas ces problèmes car ils sont explicites non scalaire types de Carte, l'Objet et le Tableau. Le développement Web est souvent une douleur avec les types scalaires où vous avez à traiter avec des choses comme PHP fusionne Tableau/Map avec un Objet à l'aide d'Un/M pour les propriétés et les JS fusionne la Carte/Objet avec la Matrice de l'extension M/O. Fusion complexe de types, c'est le diable fléau de haut niveau dans les langages de script.

Jusqu'à présent, ils sont en grande partie les questions autour de la mise en œuvre, mais les performances pour les opérations de base est important. La Performance est également complexe car il dépend du moteur et de l'utilisation. Prendre mes tests avec un grain de sel, car je ne peux pas exclure toute erreur (j'ai plus vite que ce que). Vous devez également exécuter vos propres tests afin de confirmer que la mienne examiner très spécifiques scénarios simples pour donner une indication approximative seulement. Selon des tests en Chrome pour les objets de très grande taille/les cartes de la performance pour les objets est de pire en raison de supprimer ce qui est apparemment d'une certaine manière proportionnelle au nombre de clés au lieu de O(1):

Object Set Took: 146
Object Update Took: 7
Object Get Took: 4
Object Delete Took: 8239
Map Set Took: 80
Map Update Took: 51
Map Get Took: 40
Map Delete Took: 2

Chrome a clairement un fort avantage avec l'obtention et la mise à jour, mais la suppression de la performance est horrible. Cartes utiliser une petite quantité de mémoire en plus dans ce cas (frais généraux), mais avec un seul Objet/Carte testé avec des millions de clés de l'impact de la surcharge des cartes n'est pas bien exprimé. Avec la gestion de la mémoire les objets également semblent libre plus tôt si je lis le profil correctement ce qui pourrait être un avantage en faveur des objets.

Dans FireFox pour ce test, c'est une autre histoire:

Object Set Took: 435
Object Update Took: 126
Object Get Took: 50
Object Delete Took: 2
Map Set Took: 63
Map Update Took: 59
Map Get Took: 33
Map Delete Took: 1

Je doit immédiatement signaler que, dans cette référence de la suppression à partir d'objets dans FireFox n'est pas causer de problèmes, mais dans d'autres repères, il a causé des problèmes surtout quand il y a beaucoup de touches tout comme dans google Chrome. Les cartes sont nettement supérieure dans FireFox pour de grandes collections.

Cependant, ce n'est pas la fin de l'histoire, qu'en de nombreux petits objets ou des cartes? J'ai fait un rapide test de ce mais pas exhaustive (réglage/mise) qui donne les meilleurs résultats avec un petit nombre de clés dans les opérations ci-dessus. Ce test est plus sur la mémoire et l'initialisation.

Map Create: 69    //new Map
Object Create: 34 //{}

Encore ces chiffres varient, mais, fondamentalement, l'Objet a une bonne longueur d'avance. Dans certains cas, le plomb pour les Objets de plus de cartes est extrême (~10 fois mieux) mais en moyenne, il était d'environ 2 à 3 fois mieux. Il semble extrême pointes de performance peut fonctionner dans les deux sens. J'ai uniquement testé sur Chrome et création de le profil de l'utilisation de la mémoire et de surcharge. J'ai été assez surpris de voir que dans google Chrome, il semble que les Cartes avec une touche d'environ 30 fois plus de mémoire que les Objets avec une seule clé.

Pour tester un grand nombre de petits objets avec toutes les opérations décrites ci-dessus (4 touches):

Chrome Object Took: 61
Chrome Map Took: 67
FireFox Object Took: 54
FireFox Map Took: 139

En termes d'allocation de mémoire ces se comportaient de la même en termes de libération/GC, mais la Carte utilisée 5 fois plus de mémoire. Ce test utilisé 4 touches où, comme dans le dernier test que j'ai seulement mis une clé, de sorte que cela permettrait d'expliquer la réduction de la surcharge de la mémoire. J'ai couru ce test plusieurs fois et de la Carte/Objet sont plus ou moins du cou et de la nuque pour l'ensemble de Chrome en termes de vitesse. Dans FireFox pour de petits Objets, il y a un réel avantage en termes de performances sur les cartes dans l'ensemble.

Bien sûr, cela n'inclut pas les options individuelles qui peuvent varier énormément. Je ne voudrais pas les conseils de micro-optimisation avec ces chiffres. Ce que vous pouvez sortir de cela est que, en règle générale, considérez les Cartes plus fortement que la très grande valeur de la clé de magasins et d'objets de petite valeur de la clé de magasins.

Au-delà, que la meilleure stratégie avec ces deux à la mise en place et il suffit de faire un travail d'abord. Lors de l'analyse, il est important de garder à l'esprit que, parfois, les choses que vous ne voudriez pas que serait lente lorsque l'on regarde peut être incroyablement lent, à cause de moteur de bizarreries comme on le voit avec la clé de l'objet de la suppression cas.

En plus des autres réponses, j'ai trouvé que les Cartes sont plus lourd et verbeux pour fonctionner avec des objets.

obj[key] += x
//vs.
map.set(map.get(key) + x)

C'est important, parce que plus court code est plus rapide à lire, plus directement expressif, et mieux conservés dans le programmeur de la tête.

Un autre aspect: parce que set() retourne la carte, et non la valeur, il est impossible de la chaîne d'affectations.

foo = obj[key] = x;  //Does what you expect
foo = map.set(key, x)  //foo !== x; foo === map

Le débogage des cartes est également de plus en plus douloureux. Ci-dessous, vous ne pouvez pas voir ce que les clés sont dans la carte. Vous devez écrire du code pour le faire.

Les objets peuvent être évaluées par une IDE:

Les objets peuvent se comporter comme des dictionnaires, car le Javascript est dynamiquement typé, mais ils ne sont vraiment pas destiné à être.

La nouvelle Map() fonctionnalité est beaucoup plus agréable, car il est normal de get/set/has/delete méthodes, accepte tout type de la remise des clés au lieu de simplement les chaînes, plus facile à utiliser lors de l'itération, et il n'a pas de bord de cas à l'aide de prototypes et d'autres propriétés qui se montre. Il est aussi très rapide et ne cesse de devenir plus rapide que les moteurs de mieux. 99% du temps, vous devriez utiliser un Map().

Toutefois, si vous êtes seulement en utilisant la chaîne de clés et besoin d'un maximum de performances de lecture, puis les objets peuvent être un meilleur choix. Le détail est que (presque tous) les moteurs javascript compiler les objets vers le bas pour les classes C++ en arrière-plan. Ces types sont mis en cache et réutilisé par leur "plan", de sorte que lorsque vous créer un nouvel objet avec les mêmes propriétés exactes le moteur de réutiliser une classe d'arrière-plan. Le chemin d'accès pour les propriétés de ces classes est très optimisé et beaucoup plus rapide que la recherche d'un Map().

L'ajout ou la suppression d'une propriété entraîne la mise en cache de la sauvegarde de la classe à la re-compilation, qui est pourquoi l'aide d'un objet comme un dictionnaire avec beaucoup de principaux ajouts et des suppressions est très lent, mais les lectures et l'attribution des clés existantes, sans modification de l'objet sont très rapides.

Donc si vous avez une écriture, une fois lu-lourde charge de travail avec des clés de chaîne d'utiliser ensuite une object en tant qu'institution spécialisée de haute performance dictionnaire, mais pour tout le reste d'utiliser une Map().

Ces deux conseils peuvent vous aider à décider de l'utilisation d'une Carte ou d'un Objet:

• Utiliser des cartes au-dessus des objets lorsque les clés sont inconnues jusqu'à ce moment de l'exécution, et quand
  toutes les touches sont du même type et de toutes les valeurs sont du même type.

• Utiliser des cartes dans le cas où si il y a un besoin de stocker des valeurs primitives comme des clés
  parce que l'objet traite chaque touche comme une chaîne de caractères, soit de ses un certain nombre de valeur,
  valeur booléenne ou toute autre valeur primitive.

• Utiliser des objets quand il y a une logique qui opère sur les différents éléments.

Source:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Keyed_Collections#Object_and_Map_compared