In this article we would be discussing Set object provided by ES6. A set is a collection of items which are unique i.e no element can be repeated. Set in ES6 are ordered : elements of the set can be iterated in the insertion order. Set can store any types of values whether primitive or objects.
Syntax:
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 new set created is empty. Returns: A new set object
Now lets create some sets:
Example:
// 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(); |
Properties:
Set.prototype.size – It returns the number of elements in the Set.
Methods:
- Set.prototype.add() – It adds the new element with a specified value at the end of the Set object.
Syntax:
set1.add(val); Parameter: val - It is a value to be added to the set. Returns: The set object
Example:
// 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 chanining
// 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() – It deletes an element with the specified value from the Set object.
Syntax:set1.delete(val); Parameter: val - It is a value to be deleted from the set. Returns: true if the value is succesfully deleted from the set else returns false.
Example:
// using Set.protoype.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() – It removes all the element from the set.
Syntax:set1.clear(); Parameter: No parameters Returns: undefined
Example:
// 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() – It returns an iterator object which contains an array having the entries of the set, in the insertion order.
Syntax: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.
Example
// 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() – It returns true if the specified value is present in the Set object.
Syntax:set1.has(val); Parameter: val - The value to be searched in the Set Returns: True if the value is present else it returns false.
Example:
// 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() – It returns all the values from the Set in the same insertion order.
Syntax: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() – It also returns all the values from the Set in the insertion order.
Note: – It is similar to the values() in case of Sets
Syntax: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.
Example:
// 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() – It executes the given function once for every element in the Set, in the insertion order.
Syntax: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 callback. Returns: Undefined
The callback function is provided with three parameters as follows:
- the element key
- the element value
- the Set object to be traversed
Example:
// Using Set.prototype.forEach(callback[, thisarg])
// creating set
var set1 =
new
Set();
// adding element to the set
set1.add({Firstname:
"Sumit"
, Lastname:
"Ghosh"
});
set1.add(
50
);
set1.add(
30
);
set1.add(
40
);
set1.add(
"Geeks"
);
set1.add(
"GFG"
);
// Declaring a call back function
// we are using only one parameter value
// so it will ignore other two .
function printOne(values)
{
console.log(values);
}
// It prints value of all the element
// of the set
set1.forEach(printOne);
// Declaring a call back function
// we are using two parameter value
// so it will ignore last one
function printTwo(key, values)
{
console.log(key+
" "
+values);
}
// As key and values are same in set
// so it will print values twice
set1.forEach(printTwo);
// Declaring a call back function
// we are using all three paramter value
function printThree(key, values, set)
{
// it will print key and value
// and the set object
console.log(key+
" "
+values);
console.log(set);
}
// It prints key and value of each
// element and the entire set object
set1.forEach(printThree);
Note:- In the above example we use a simple callback function which just print an element in the console, it can be designed to perform any complex operation as per requirement
- Set.protoype[@@iterator]() – It returns a Set iterator function which is values() function by default.
Syntax:set1[Symbol.iterator](); Parameter: No parameters Returns: A Set iterator function and it is values() by default.
Example:
// using Set.protoype[@@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());
Set Operations:
- subSet() – It returns true if Set A is a subset of Set B.
A Set A is said to be a subset of Set B, if all the elements of Set A is also present in Set B.
Now lets implement and use the subset function.
Example:
// 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'nt 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() – It returns a Set which consists of union of Set A and Set B
A Set is said to be a union of two set, if it contains all element of Set A as well as all elements of Set B, but it does’nt contains duplicate elements.
For Example: If an element is present in both Set A and Set B then union of Set A and B will contain the single copy of the element.
Let implement and use the union function
Example:// 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() – It returns the intersection of Set A and Set B.
A Set is said to be the intersection of Set A and B if contains element which is present both in Set A and Set B.
Let implement and use the intersection function
Example:// 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() – It returns the Set which contains difference of Set A and Set B.
A Set is said to be a difference of Set A and B if it contains set of element e which are present in Set A but not in Set B.
Let’s implement and use the difference function
Example:// Performs difference operation between
// called set and otherSet
Set.prototype.difference = function(otherSet)
{
// creating new set to store differnce
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);
Reference:
https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Set
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
leave a comment
0 Comments