# Javascript Data Structure Tutorial - Javascript Set

A set is a collection of unique elements.

The elements of a set are called members.

The members of a set are unordered and that no member can occur in a set more than once.

A set containing no members is called the empty set.

Two sets are considered equal if they contain exactly the same members.

A set is considered a subset of another set if all the members of the first set are contained in the second set.

## Set Operations

The fundamental operations performed on sets are:

• Union - A new set is created by combining the members of one set with the members of another set.
• Intersection - A new set is created by adding all the members of one set that also exist in a second set.
• Difference - A new set is created by adding all the members of one set except those that also exist in a second set.

## The Set Class Implementation

The Set class implementation is built around an array.

``````
function Set() { /*from  w  w w .  java2  s.c  o  m*/
this.dataStore = [];
this.remove = remove;
this.size = size;
this.union = union;
this.intersect = intersect;
this.subset = subset;
this.difference = difference;
this.show = show;
this.contains = contains;
this.union = union;
this.intersect = intersect;
this.subset = subset;
this.size = size;
this.difference = difference;
}
if (this.dataStore.indexOf(data) < 0) {
this.dataStore.push(data);
return true;
} else {
return false;
}
}
function remove(data) {
var pos = this.dataStore.indexOf(data);
if (pos > -1) {
this.dataStore.splice(pos,1);
return true;
} else {
return false;
}
}
function show() {
return this.dataStore;
}
function contains(data) {
if (this.dataStore.indexOf(data) > -1) {
return true;
} else {
return false;
}
}
function union(set) {
var tempSet = new Set();
for (var i = 0; i < this.dataStore.length; ++i) {
}
for (var i = 0; i < set.dataStore.length; ++i) {
if (!tempSet.contains(set.dataStore[i])) {
tempSet.dataStore.push(set.dataStore[i]);
}
}
return tempSet;
}
function intersect(set) {
var tempSet = new Set();
for (var i = 0; i < this.dataStore.length; ++i) {
if (set.contains(this.dataStore[i])) {
}
}
return tempSet;
}

function subset(set) {
if (this.size() > set.size()) {
return false;
} else {
for (var member in this.dataStore) {
if (!set.contains(member)) {
return false;
}
}
}
return true;
}
function size() {
return this.dataStore.length;
}
function difference(set) {
var tempSet = new Set();
for (var i = 0; i < this.dataStore.length; ++i) {
if (!set.contains(this.dataStore[i])) {
}
}
return tempSet;
}

var names = new Set();
} else {
}
console.log(names.show());
var removed = "M";
if (names.remove(removed)) {
console.log(removed + " removed.");
} else {
console.log(removed + " not removed.");
}
console.log(names.show());
removed = "A";
if (names.remove(removed)) {
console.log(removed + " removed.");
} else {
console.log(removed + " not removed.");
}

var cis = new Set();
var dmp = new Set();
var it = new Set();
it = cis.union(dmp);
console.log(it.show());

var inter = cis.intersect(dmp);
console.log(inter.show());

var it = new Set();

if (dmp.subset(it)) {
console.log("DMP is a subset of IT.");
} else {
console.log("DMP is not a subset of IT.");
}

var diff = new Set();
diff = cis.difference(it);
console.log("[" + cis.show() + "] difference [" + it.show() + "] -> [" + diff.show() + "]");
``````

The code above generates the following result.

## Example 2

The following code shows how to create Set data structure with prototype.

``````
var Set = function(){
this._storage = {};// w  ww.ja  v  a 2  s.  c o m
};

Set.prototype.generateKey = function(value) {
var type = typeof value;
if (type === 'function') {
value = value.toString();
}
else if (type === 'undefined') {
return 'undefined';
}
//NaN
else if (type === 'number' && !value && value !== 0) {
return 'NaN';
}
else {
value = JSON.stringify(value);
}
return value;
};

value = this.generateKey(value);
this._storage[value] = value;
};

Set.prototype.contains = function(value){
value = this.generateKey(value);
return this._storage[value] === value;
};

Set.prototype.remove = function(value){
value = this.generateKey(value);
var temp = this._storage[value];
return (delete this._storage[value]) && temp;
};

var set = new Set();