Si vous programmez dans un environnement compatible ES6 (tel que node.js, un navigateur spécifique avec les capacités ES6 dont vous avez besoin ou transpilant du code ES6 pour votre environnement), vous pouvez utiliser l' Setobjet intégré à ES6 . Il a de très belles capacités et peut être utilisé tel quel dans votre environnement.
Pour de nombreuses choses simples dans un environnement ES5, l'utilisation d'un objet fonctionne très bien. Si objest votre objet et Aest une variable qui a la valeur sur laquelle vous souhaitez opérer dans l'ensemble, vous pouvez le faire:
Code d'initialisation:
// create empty object
var obj = {};
// or create an object with some items already in it
var obj = {"1":true, "2":true, "3":true, "9":true};
Question 1: Est Adans la liste:
if (A in obj) {
// put code here
}
Question 2: supprimez «A» de la liste s'il y en a un:
delete obj[A];
Question 3: ajoutez 'A' à la liste si ce n'est déjà fait
obj[A] = true;
Pour être complet, le test de A est dans la liste est un peu plus sûr avec ceci:
if (Object.prototype.hasOwnProperty.call(obj, A))
// put code here
}
en raison d'un conflit potentiel entre les méthodes et / ou les propriétés intégrées sur l'objet de base comme le constructor propriété.
Barre latérale sur ES6: La version de travail actuelle d' ECMAScript 6 ou quelque chose appelé ES 2015 a un objet Set intégré . Il est désormais implémenté dans certains navigateurs. Étant donné que la disponibilité du navigateur change au fil du temps, vous pouvez consulter la ligneSet dans ce tableau de compatibilité ES6 pour voir l'état actuel de la disponibilité du navigateur.
L'un des avantages de l'objet Set intégré est qu'il ne contraint pas toutes les clés à une chaîne comme le fait l'objet, vous pouvez donc avoir à la fois 5 et "5" comme clés distinctes. Et, vous pouvez même utiliser des objets directement dans l'ensemble sans conversion de chaîne. Voici un article qui décrit certaines des capacités et la documentation de MDN sur l'objet Set.
J'ai maintenant écrit un polyfill pour l'objet set ES6 afin que vous puissiez commencer à l'utiliser maintenant et il se reportera automatiquement à l'objet set intégré si le navigateur le prend en charge. Cela a l'avantage d'écrire du code compatible ES6 qui fonctionnera jusqu'à IE7. Mais, il y a quelques inconvénients. L'interface de l'ensemble ES6 profite des itérateurs ES6 pour que vous puissiez faire des choses comme for (item of mySet)et il itérera automatiquement l'ensemble pour vous. Mais, ce type de fonctionnalité de langage ne peut pas être implémenté via polyfill. Vous pouvez toujours itérer un ensemble ES6 sans utiliser les nouvelles fonctionnalités linguistiques ES6, mais franchement sans les nouvelles fonctionnalités linguistiques, ce n'est pas aussi pratique que l'autre interface d'ensemble que j'inclus ci-dessous.
Vous pouvez décider lequel vous convient le mieux après avoir examiné les deux. Le polyfill ES6 set est ici: https://github.com/jfriend00/ES6-Set .
Pour info, lors de mes propres tests, j'ai remarqué que l'implémentation de Firefox v29 Set n'est pas entièrement à jour par rapport à la version actuelle de la spécification. Par exemple, vous ne pouvez pas enchaîner les .add()appels de méthode comme le décrit la spécification et mon support polyfill. Il s'agit probablement d'une spécification en mouvement car elle n'est pas encore finalisée.
Objets Set prédéfinis: Si vous voulez un objet déjà construit qui possède des méthodes pour fonctionner sur un ensemble que vous pouvez utiliser dans n'importe quel navigateur, vous pouvez utiliser une série d'objets différents prédéfinis qui implémentent différents types d'ensembles. Il existe un miniSet qui est un petit code qui implémente les bases d'un objet set. Il a également un objet d'ensemble plus riche en fonctionnalités et plusieurs dérivations, y compris un dictionnaire (vous permet de stocker / récupérer une valeur pour chaque clé) et un ObjectSet (vous permet de conserver un ensemble d'objets - soit des objets JS ou des objets DOM où vous fournissez le fonction qui génère une clé unique pour chacun ou l'ObjectSet générera la clé pour vous).
Voici une copie du code du miniSet (le code le plus récent est ici sur github ).
"use strict";
//-------------------------------------------
// Simple implementation of a Set in javascript
//
// Supports any element type that can uniquely be identified
// with its string conversion (e.g. toString() operator).
// This includes strings, numbers, dates, etc...
// It does not include objects or arrays though
// one could implement a toString() operator
// on an object that would uniquely identify
// the object.
//
// Uses a javascript object to hold the Set
//
// This is a subset of the Set object designed to be smaller and faster, but
// not as extensible. This implementation should not be mixed with the Set object
// as in don't pass a miniSet to a Set constructor or vice versa. Both can exist and be
// used separately in the same project, though if you want the features of the other
// sets, then you should probably just include them and not include miniSet as it's
// really designed for someone who just wants the smallest amount of code to get
// a Set interface.
//
// s.add(key) // adds a key to the Set (if it doesn't already exist)
// s.add(key1, key2, key3) // adds multiple keys
// s.add([key1, key2, key3]) // adds multiple keys
// s.add(otherSet) // adds another Set to this Set
// s.add(arrayLikeObject) // adds anything that a subclass returns true on _isPseudoArray()
// s.remove(key) // removes a key from the Set
// s.remove(["a", "b"]); // removes all keys in the passed in array
// s.remove("a", "b", ["first", "second"]); // removes all keys specified
// s.has(key) // returns true/false if key exists in the Set
// s.isEmpty() // returns true/false for whether Set is empty
// s.keys() // returns an array of keys in the Set
// s.clear() // clears all data from the Set
// s.each(fn) // iterate over all items in the Set (return this for method chaining)
//
// All methods return the object for use in chaining except when the point
// of the method is to return a specific value (such as .keys() or .isEmpty())
//-------------------------------------------
// polyfill for Array.isArray
if(!Array.isArray) {
Array.isArray = function (vArg) {
return Object.prototype.toString.call(vArg) === "[object Array]";
};
}
function MiniSet(initialData) {
// Usage:
// new MiniSet()
// new MiniSet(1,2,3,4,5)
// new MiniSet(["1", "2", "3", "4", "5"])
// new MiniSet(otherSet)
// new MiniSet(otherSet1, otherSet2, ...)
this.data = {};
this.add.apply(this, arguments);
}
MiniSet.prototype = {
// usage:
// add(key)
// add([key1, key2, key3])
// add(otherSet)
// add(key1, [key2, key3, key4], otherSet)
// add supports the EXACT same arguments as the constructor
add: function() {
var key;
for (var i = 0; i < arguments.length; i++) {
key = arguments[i];
if (Array.isArray(key)) {
for (var j = 0; j < key.length; j++) {
this.data[key[j]] = key[j];
}
} else if (key instanceof MiniSet) {
var self = this;
key.each(function(val, key) {
self.data[key] = val;
});
} else {
// just a key, so add it
this.data[key] = key;
}
}
return this;
},
// private: to remove a single item
// does not have all the argument flexibility that remove does
_removeItem: function(key) {
delete this.data[key];
},
// usage:
// remove(key)
// remove(key1, key2, key3)
// remove([key1, key2, key3])
remove: function(key) {
// can be one or more args
// each arg can be a string key or an array of string keys
var item;
for (var j = 0; j < arguments.length; j++) {
item = arguments[j];
if (Array.isArray(item)) {
// must be an array of keys
for (var i = 0; i < item.length; i++) {
this._removeItem(item[i]);
}
} else {
this._removeItem(item);
}
}
return this;
},
// returns true/false on whether the key exists
has: function(key) {
return Object.prototype.hasOwnProperty.call(this.data, key);
},
// tells you if the Set is empty or not
isEmpty: function() {
for (var key in this.data) {
if (this.has(key)) {
return false;
}
}
return true;
},
// returns an array of all keys in the Set
// returns the original key (not the string converted form)
keys: function() {
var results = [];
this.each(function(data) {
results.push(data);
});
return results;
},
// clears the Set
clear: function() {
this.data = {};
return this;
},
// iterate over all elements in the Set until callback returns false
// myCallback(key) is the callback form
// If the callback returns false, then the iteration is stopped
// returns the Set to allow method chaining
each: function(fn) {
this.eachReturn(fn);
return this;
},
// iterate all elements until callback returns false
// myCallback(key) is the callback form
// returns false if iteration was stopped
// returns true if iteration completed
eachReturn: function(fn) {
for (var key in this.data) {
if (this.has(key)) {
if (fn.call(this, this.data[key], key) === false) {
return false;
}
}
}
return true;
}
};
MiniSet.prototype.constructor = MiniSet;