Set

El objeto Set permite almacenar valores únicos de cualquier tipo, incluso valores primitivos u referencias a objetos.

new Set([iterable]);

iterable

Si un objeto iterable es pasado, todos sus elementos serán añadidos al nuevo Set. Si no se especifica este parámetro, o si su valor es null, el nuevo Set estará vacío.

Una nueva instancia de Set.

Los objetos Set son colecciones de valores. Se puede iterar sus elementos en el orden de su inserción. Un valor en un Set sólo puede estar una vez; éste es único en la colección Set.

Ya que cada valor en el Set tiene que ser único, la igualdad del valor será comprobada y esta igualdad no se basa en el mismo algoritmo usado en el operador ===. Específicamente, para Sets, +0 (el cual es estrictamente igual a -0) y -0 son valores distintos. Sin embargo, esto ha cambiado en la última especificación ECMAScript 6. Iniciando con Gecko 29.0 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (error 952870) y un recent nightly Chrome, +0 y -0 son tratados como el mismo valor en objetos Set. 

NaN y undefined también pueden ser almacenados en un Set. NaN es considerado igual que NaN (A pesar que NaN !== NaN).

Set.length

El valor de la propiedad length es 0.

get Set[@@species] (en-US)

La función constructora que es usada para crear objetos derivados.

Set.prototype (en-US)

Representa el prototipo para el constructor Set. Permite la adición de propiedades a todos los objetos Set.

Todas las instancias de Set heredan de Set.prototype (en-US).

{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}

{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}

const mySet = new Set();

mySet.add(1);
mySet.add(5);
mySet.add('some text');

const o = {a: 1, b: 2};
mySet.add(o);

mySet.add({a: 1, b: 2}); // La variable "o" referencia a otro objeto, por lo que agrega otro valor.

mySet.has(1); // true
mySet.has(3); // false, 3 no ha sido añadido al Set
mySet.has(5);              // true
mySet.has(Math.sqrt(25));  // true
mySet.has('Some Text'.toLowerCase()); // true
mySet.has(o); // true

mySet.size; // 5

mySet.delete(5); // Elimina 5 del Set
mySet.has(5);    // false, 5 fue eliminado

mySet.size; // 4, sólo removimos un valor
console.log(mySet);// Set {1, "some text", Object {a: 1, b: 2}, Object {a: 1, b: 2}}

// iterar todos los items de un set
// imprimir en consola los items en orden: 1, 'some text', {a: 1, b: 2}
for (let item of mySet) console.log(item);

// imprimir en consola los items en orden: 1, 'some text', {a: 1, b: 2}
for (let item of mySet.keys()) console.log(item);

// imprimir en consola los items en orden: 1, 'some text', {a: 1, b: 2}
for (let item of mySet.values()) console.log(item);

// imprimir en consola los items en orden: 1, 'some text', {a: 1, b: 2}
//(key y value poseen en mismo valor en este caso)
for (let [key, value] of mySet.entries()) console.log(key);

// crear un Array plano con los mismos valores, utilizando Array.from
const myArr = Array.from(mySet); // [1, 'some text', {a: 1, b: 2}]

// también se puede utilizar para guardar elementos del DOM
mySet.add(document.body);
mySet.has(document.querySelector('body')); // true

// crear un Array plano con los mismos valores, utilizando propagación
const mySet2 = new Set([1,2,3,4]);
mySet2.size; // 4
[...mySet2]; // [1,2,3,4]

// la intersección entre dos sets puede ser simulada con
const intersection = new Set([...set1].filter(x => set2.has(x)));

// la diferencia puede ser simulada con
const difference = new Set([...set1].filter(x => !set2.has(x)));

// Iteración utilizando forEach
mySet.forEach((value) => {
  console.log(value);
});

// 1
// 2
// 3
// 4

Set.prototype.isSuperset = function(subset) {
    for (var elem of subset) {
        if (!this.has(elem)) {
            return false;
        }
    }
    return true;
}

Set.prototype.union = function(setB) {
    var union = new Set(this);
    for (var elem of setB) {
        union.add(elem);
    }
    return union;
}

Set.prototype.intersection = function(setB) {
    var intersection = new Set();
    for (var elem of setB) {
        if (this.has(elem)) {
            intersection.add(elem);
        }
    }
    return intersection;
}

Set.prototype.difference = function(setB) {
    var difference = new Set(this);
    for (var elem of setB) {
        difference.delete(elem);
    }
    return difference;
}

//Examples
var setA = new Set([1,2,3,4]),
    setB = new Set([2,3]),
    setC = new Set([3,4,5,6]);

setA.isSuperset(setB); // => true
setA.union(setC); // => Set [1, 2, 3, 4, 5, 6]
setA.intersection(setC); // => Set [3, 4]
setA.difference(setC); // => Set [1, 2]

const myArray = ['value1', 'value2', 'value3'];

// Utiliza el constructor para para crear un set con el mismo contenido que un array
const mySet = new Set(myArray);

mySet.has('value1'); // devuelve true

// Utiliza la propagación para crear un array con los contenidos de un set
console.log([...mySet]); // Muestra lo mismo utilizando myArray

• Map
• WeakMap
• WeakSet