El objeto Set
permite almacenar valores únicos de cualquier tipo, incluso valores primitivos u referencias a objetos.
Sintaxis
new Set([iterable]);
Parámetros
- 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 nuevoSet
estará vacío.
Valor retornado
Una nueva instancia de Set
.
Descripción
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
.
Igualdad de valores
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
).
Propiedades
Set.length
- El valor de la propiedad
length
es 0. get Set[@@species]
- La función constructora que es usada para crear objetos derivados.
Set.prototype
- Representa el prototipo para el constructor Set. Permite la adición de propiedades a todos los objetos Set.
Instancias Set
Todas las instancias de Set
heredan de Set.prototype
.
Propiedades
{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}
Métodos
{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}
Ejemplos
Usando el objeto Set
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}}
Iterando los Sets
// 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
Implementando operaciones básicas
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]
Relación con los objetos Array
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
Especificaciones
Especificación | Estado | Comentario |
---|---|---|
ECMAScript 2015 (6th Edition, ECMA-262) La definición de 'Set' en esta especificación. |
Standard | Definición inicial |
ECMAScript (ECMA-262) La definición de 'Set' en esta especificación. |
Living Standard |
Compatibilidad de navegadores
BCD tables only load in the browser