JavaScript Map and Set
Map
A Map
object is a collection of key-value pairs where each key can be of any type. This means that you can use objects, strings, numbers, or even functions as keys. A Map
is similar to an object, but it provides additional functionality, such as built-in methods for adding, deleting, and updating key-value pairs.
Here's an example of how you can create a Map
object:
const myMap = new Map();
You can then add key-value pairs to the map using the set
method:
myMap.set('key1', 'value1');
myMap.set('key2', 'value2');
myMap.set('key3', 'value2');//add same value
myMap.set("key2", "value3"); //add same key
You can retrieve the value associated with a key using the get
method:
console.log(myMap.get('key1')); // output: 'value1'
You can also delete a key-value pair using the delete
method:
myMap.delete('key1');
Set
A Set
object is a collectionof unique values where each value can be of any type. This means that you can use objects, strings, numbers, or even functions as values. A Set
is useful when you want to store a collection of unique values and perform operations on them, such as finding the intersection or difference between two sets.
Here's an example of how you can create a Set
object:
const mySet = new Set();
You can then add values to the set using the add
method:
mySet.add('value1');
mySet.add('value2');
mySet.add("value2");// add same value
You can check if a value exists in the set using the has
method:
console.log(mySet.has('value1')); // output: true
You can also delete a value from the set using the delete
method:
mySet.delete('value1');
JavaScript Garbage Collection
Garbage collection in JavaScript is the process of automatically freeing up memory that is no longer being used by your code. This is important because JavaScript is a dynamically typed language, which means that you can create and destroy objects at runtime.
JavaScript engines use a technique called "mark and sweep" to perform garbage collection. This involves marking all the objects that are still being used by your code and then sweeping up the objects that are not marked. This process is performed periodically by the JavaScript engine and is completely transparent to your code.
Map vs WeakMap and when to use WeakMap
Map
and WeakMap
are both data structures in JavaScript, but they have some differences in terms of how they handle memory management.
A Map
object holds strong references to its keys and values, which means that as long as the Map
object exists, its keys and values will not be garbage collected. This can be useful in some cases, but it can also lead to memory leaks if you don't properly manage your Map
objects.
On the other hand, a WeakMap
object holds weak references to its keys. This means that if the only reference to a key is from the WeakMap
object, the key will be automatically garbage collected. This can be useful in cases where you want to associate additional data with an object without keeping a strong reference to that object.
One common use case for WeakMap
is in implementing private data for JavaScript objects. In JavaScript, there is no built-in support for private instance variables or methods, which can lead to issues with encapsulation and data hiding. However, WeakMap
can be used to simulate private instance variables in JavaScript.
Here's an example:
const privateData = new WeakMap();
class Counter {
constructor() {
privateData.set(this, { counter: 0 });
}
increment() {
const data = privateData.get(this);
data.counter++;
console.log(`Counter is now ${data.counter}`);
}
}
let counter1 = new Counter();
counter1.increment();
counter1.increment();
counter1.increment();
let counter2 = new Counter();
counter2.increment();
In this example, we're using WeakMap
to store private data for instances of MyClass
. The privateData
object is a WeakMap
that maps instances of MyClass
to an object containing the private data for that instance. The private data in this case is just a counter
property that we're incrementing in the incrementCounter
method.
Because privateData
is a WeakMap
, the private data for each instance of MyClass
can be garbage collected when the instance itself is no longer reachable. This means that the private data is truly private to each instance of MyClass
, and cannot be accessed from outside the class.
Another use case for WeakMap
is in caching. For example, you could use a WeakMap
to cache theresults of a time-consuming computation, where the keys are the arguments to the computation and the values are the results. Because WeakMap
holds weak references to its keys, the cached results can be garbage collected when the arguments are no longer reachable, which can help to free up memory.
Here's an example:
const cache = new WeakMap();
function computeResult(arg) {
if (cache.has(arg)) {
console.log('Using cached result');
return cache.get(arg);
}
console.log('Computing result');
const result = /* perform time-consuming computation */;
cache.set(arg, result);
return result;
}
In this example, we're using a WeakMap
to cache the results of the computeResult
function. The cache
object is a WeakMap
that maps arguments to results. When the function is called with a particular argument, we first check if the result is already cached. If it is, we return the cached result. If not, we perform the time-consuming computation to compute the result, and then cache the result in the WeakMap
.
Because cache
is a WeakMap
, the cached results can be garbage collected when the arguments are no longer reachable, which can help to free up memory. This can be especially useful if the arguments are large objects or collections that take up a lot of memory.
Conclusion
In summary, Map
and Set
are useful data structures in JavaScript for storing collections of key-value pairs and unique values, respectively. JavaScript garbage collection is the process of automatically freeing up memory that is no longer being used by your code. Finally, Map
and WeakMap
have some differences in terms of how they handle memory management, with WeakMap
being useful in cases where you want to associate additional data with an object without keeping a strong reference to that object.
Top comments (0)