Conjuntos en JavaScript

En este artículo, estaríamos discutiendo el objeto Set proporcionado por ES6. Un conjunto es una colección de elementos que son únicos, es decir, ningún elemento se puede repetir. Los conjuntos en ES6 están ordenados: los elementos del conjunto se pueden iterar en el orden de inserción. Set puede almacenar cualquier tipo de valores, ya sean primitivos u objetos.
Sintaxis: 
 

new Set([it]);

Parameter: 
it - It is an iterable object whose all elements are 
added to the new set created, 
If the parameter is not specified or null is passed 
then a new set created is empty.

Returns:
A new set object

Ahora vamos a crear algunos conjuntos: 
Ejemplo: 
 

// it contains
// ["sumit","amit","anil","anish"]
var set1 = new Set(["sumit","sumit","amit","anil","anish"]);
 
// it contains 'f', 'o', 'd'
var set2 = new Set("fooooooood");
 
// it contains [10, 20, 30, 40]
var set3 = new Set([10, 20, 30, 30, 40, 40]);
 
 // it is an  empty set
var set4 = new Set();

Propiedades: 
Set.prototype.size – Devuelve el número de elementos del Set .
Métodos: 
 

• Set.prototype.add() : agrega el nuevo elemento con un valor específico al final del objeto Set.
  Sintaxis: 
   

set1.add(val);

Parameter:
val - It is a value to be added to the set.

Returns: 
The set object

Ejemplo: 

// using Set.prototype.add(value)
// creating an empty set
var set1 = new Set();
 
// set contains 10, 20
set1.add(10);
set1.add(20);
 
// As this method returns
// the set object hence chaining
// of add method can be done.
set1.add(30).add(40).add(50);
 
// prints 10, 20, 30, 40, 50
console.log(set1);

• Set.prototype.delete() : elimina un elemento con el valor especificado del objeto Set. 
  Sintaxis: 
   

set1.delete(val);

Parameter:
val - It is a value to be deleted from the set.

Returns: 
true if the value is successfully deleted from the set else returns false.

Ejemplo: 

// using Set.prototype.delete(value)
// creating set it contains
// f, o , d, i, e
var set1 = new Set("foooodiiiieee");
 
// deleting e from the set
// it prints true
console.log(set1.delete('e'));
 
// set contains f, o, d, i
console.log(set1);
 
// deleting an element which is
// not in the set
// prints false
console.log(set1.delete('g'));

• Set.prototype.clear() : elimina todos los elementos del conjunto. 
  Sintaxis: 
   

set1.clear();

Parameter:
No parameters

Returns: 
undefined

Ejemplo: 

// Using Set.prototype.clear()
// creating a set
var set2 = new Set([10, 20, 30, 40, 50]);
 
// prints {10, 20, 30, 40, 50}
console.log(set2);
 
// clearing set2
set2.clear()
 
// prints {}
console.log(set2);

• Set.prototype.entries() : devuelve un objeto iterador que contiene una array con las entradas del conjunto, en el orden de inserción. 
  Sintaxis:

set1.entries();

Parameter:
No parameters

Returns: 
It returns an iterator object that contains an
array of [value, value] for every 
element of the set, in the insertion order. 

Ejemplo 

// Using Set.prototype.entries()
// creating set
var set1 = new Set();
 
// adding element to the set
set1.add(50);
set1.add(30);
set1.add(40);
set1.add(20);
set1.add(10);
 
// using entries to get iterator
var getEntriesArry = set1.entries();
 
// each iterator is array of [value, value]
// prints [50, 50]
console.log(getEntriesArry.next().value);
 
// prints [30, 30]
console.log(getEntriesArry.next().value);
 
// prints [40, 40]
console.log(getEntriesArry.next().value);

• Set.prototype.has() : devuelve verdadero si el valor especificado está presente en el objeto Set. 
  Sintaxis: 
   

set1.has(val);

Parameter:
val - The value to be searched in the Set

Returns: 
True if the value is present else it returns false.

Ejemplo: 

// Using Set.prototype.has()
// creating set
var set1 = new Set();
 
// adding element to the set
set1.add(50);
set1.add(30);
             
// prints true
console.log(set1.has(50));
 
// prints false
console.log(set1.has(10));

• Set.prototype.values() : devuelve todos los valores del conjunto en el mismo orden de inserción. 
  Sintaxis: 
   

set1.values();

Parameter:
No parameters

Returns: 
An iterator object that contains all the values of the set in the same order 
as they are inserted. 

• Set.prototype.keys() : también devuelve todos los valores del conjunto en el orden de inserción. 
  Nota: – Es similar a los valores() en el caso de  la
  sintaxis de conjuntos: 
   

set1.keys();

Parameter:
No parameters

Returns: 
An iterator object that contains all the 
values of the set in the same order
as they are inserted. 

Ejemplo: 

// Using Set.prototype.values()
// Using Set.prototype.keys()
// creating set
var set1 = new Set();
 
// adding element to the set
set1.add(50);
set1.add(30);
set1.add(40);
set1.add("Geeks");
set1.add("GFG");
 
// getting all the values
var getValues = set1.values();
 
// prints a SetIterator
// that contains {50, 30, 40, "Geeks", "GFG"}
console.log(getValues);
 
// getting all the values
var getKeys = set1.keys();
 
// prints a SetIterator
// that contains {50, 30, 40, "Geeks", "GFG"}
console.log(getKeys);

• Set.prototype.forEach() : ejecuta la función dada una vez para cada elemento del conjunto, en el orden de inserción. 
  Sintaxis: 
   

set1.forEach(callback[,thisargument]);

Parameter:
callback - It is a function which is to be executed for each element of the Set.
thisargument - Value to be used as this when executing the callback.

Returns: 
Undefined

1. La función de devolución de llamada se proporciona con tres parámetros de la siguiente manera: 
   • la clave del elemento
   • el valor del elemento
   • el objeto Set a recorrer

• Set.prototype[@@iterator]() : devuelve una función de iterador Set que es la función de valores() de forma predeterminada. 
  Sintaxis: 
   

set1[Symbol.iterator]();

Parameter:
No parameters

Returns: 
A Set iterator function and it is values() by default.

Ejemplo: 

// using Set.prototype[@@Iterator]()
var set1 = new Set(["sumit","sumit","amit","anish"]);
 
var getit = set1[Symbol.iterator]();
 
// Printing the values in the
// iterator "getit"
 
// prints {value: "sumit", done: false}
console.log(getit.next());
 
// prints {value: "amit", done: false}
console.log(getit.next());
 
// prints {value: "anish", done: false}
console.log(getit.next());
 
// prints {value: undefined, done: true}
console.log(getit.next());

Establecer operaciones:  

• subSet() : devuelve verdadero si el Conjunto A es un subconjunto del Conjunto B. 
  Se dice que un Conjunto A es un subconjunto del Conjunto B , si todos los elementos del Conjunto A también están presentes en el Conjunto B. 
  Ahora implementemos y usemos la función de subconjunto. 
  Ejemplo: 
   

// check whether the set on which the
// method is invoked is the subset of
// otherset or not
Set.prototype.subSet = function(otherSet)
{
    // if size of this set is greater
    // than otherSet then it can't be
    //  a subset
    if(this.size > otherSet.size)
        return false;
    else
    {
        for(var elem of this)
        {
            // if any of the element of
            // this is not present in the
            // otherset then return false
            if(!otherSet.has(elem))
                return false;
        }
        return true;
    }
}
 
// using the subSet function
 
// Declaring different sets
var setA = new Set([10, 20, 30]);
var setB = new Set([50, 60, 10, 20, 30, 40]);
var setC = new Set([10, 30, 40, 50]);
 
// prints true
console.log(setA.subSet(setB));
 
// prints false
console.log(setA.subSet(setC));
 
// prints true
console.log(setC.subSet(setB));

• union() : devuelve un conjunto que consiste en la unión del conjunto A y el conjunto B. 
  Se dice que un conjunto es una unión de dos conjuntos, si contiene todos los elementos del conjunto A , así como todos los elementos del conjunto B , pero no lo hace. ‘nt contiene elementos duplicados. 
  Por ejemplo: si un elemento está presente tanto en el Conjunto A como en el Conjunto B , la unión de los Conjuntos A y B contendrá la copia única del elemento. 
  Vamos a implementar y usar la función de unión 
  Ejemplo: 
   

// Perform union operation between
// called set and otherSet
Set.prototype.union = function(otherSet)
{
    // creating new set to store union
    var unionSet = new Set();
 
    // iterate over the values and add
    // it to unionSet
    for (var elem of this)
    {
        unionSet.add(elem);
    }
 
    // iterate over the values and add it to
    // the unionSet
    for(var elem of otherSet)
        unionSet.add(elem);
 
    // return the values of unionSet
    return unionSet;
}
 
// using the union function
// Declaring values for set1 and set2
var set1 = new Set([10, 20, 30, 40, 50]);
var set2 = new Set([40, 50, 60, 70, 80]); 
 
// performing union operation
// and storing the resultant set in
// unionSet
var unionSet = set1.union(set2);
 
// prints [10, 20, 30, 40, 50, 60, 70, 80]
console.log(unionSet.values());

• intersection() : devuelve la intersección del Conjunto A y el Conjunto B. 
  Se dice que un Conjunto es la intersección del Conjunto A y B si contiene un elemento que está presente tanto en el Conjunto A como  en el Conjunto B.
  Implementemos y usemos la función de intersección 
  Ejemplo: 
   

// Performs intersection operation between
// called set and otherSet
Set.prototype.intersection = function(otherSet)
{
    // creating new set to store intersection
    var intersectionSet = new Set();
 
    // Iterate over the values
    for(var elem of otherSet)
    {
        // if the other set contains a
        // similar value as of value[i]
        // then add it to intersectionSet
        if(this.has(elem))
            intersectionSet.add(elem);
    }
 
// return values of intersectionSet
return intersectionSet;               
}
// using intersection function
// Declaring values for set1 and set2
var set1 = new Set([10, 20, 30, 40, 50]);
var set2 = new Set([40, 50, 60, 70, 80]); 
 
// performing union operation
// and storing the resultant set in
// intersectionset
var intersectionSet = set1.intersection(set2);
 
// prints {40, 50}
console.log(intersectionSet.values());

• difference() : devuelve el conjunto que contiene la diferencia del conjunto A y el conjunto B. 
  Se dice que un Conjunto es una diferencia del Conjunto A y B si contiene un conjunto de elementos e que están presentes en el Conjunto A pero no en el Conjunto B. 
  Implementemos y usemos la función de diferencia 
  Ejemplo: 
   

// Performs difference operation between
// called set and otherSet
Set.prototype.difference = function(otherSet)
{
    // creating new set to store difference
     var differenceSet = new Set();
 
    // iterate over the values
    for(var elem of this)
    {
        // if the value[i] is not present
        // in otherSet add to the differenceSet
        if(!otherSet.has(elem))
            differenceSet.add(elem);
    }
 
    // returns values of differenceSet
    return differenceSet;
}
 
// using difference function
// Declaring values for set1 and set2
var set1 = new Set([10, 20, 30, 40, 50]);
var set2 = new Set([40, 50, 60, 70, 80]); 
 
// performing union operation
// and storing the resultant set in
// intersectionset
var differenceSet = set1.difference(set2);
 
// prints {10, 20, 30}
console.log(differenceSet);

Referencia:  
https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Set
Este artículo es una contribución de Sumit Ghosh . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

JavaScript es mejor conocido por el desarrollo de páginas web, pero también se usa en una variedad de entornos que no son de navegador. Puede aprender JavaScript desde cero siguiendo este tutorial de JavaScript y ejemplos de JavaScript .