11.[Async/Await](async-await.md)

12.[Classes-Objects](classes-objects.md)

13.[ES6-classes](ES6-classes.md)

14.[Memory](memory.md)

14.[Iterators and Generators](iterators-generators.md)

15.[Memory](memory.md)

As ES6 introduced new syntax, it also introduced new protocols, these protocols can be implemented by any object respecting some conventions.

iterable protocol allows javascript objects to define or customize their iteration behavior such as what values are looped over in a`for .. of` construct.

some types has built-in interation behavior, this means that you can directly contrcut`for .. of` on these types example:

1. Array

2. Map

3. String

constmyArray= [1,2,3];

for(constnumof myArray) {

console.log(num);

}

As we can see in this example myArray (of type`Array`) has a built-in iteration behavior

An example of non iterable type is`Object`, but we can make an`Object` iterable by implementing`@@iterator` method, this means that the Object or its prototype needs to have a property with key`@@iterator` this is available via a constant`Symbol.iterator`

`Symbol.iterator` is a zero argument function that returns an object, conforming to the iterator protocol

Iterator protocol defines a standard way to produce a sequence of values, an object is iterator when it implements a`next()` method with the following semantics

1. 0 argument function`next()` that returns an object

2. The returned object should contain 2 properties`done` (Boolean) and`value` (Any javascript type value)

As we discussed for an object to be iterable it has to contain a property with key`Symbol.iterator` that contains a 0 argument function, where that function should return an iterator Object that contains`next()` method, where that method returns an Object that contains`value` and`done` properties:D !!!

let numbersIterable= {};

numbersIterable[Symbol.iterator]=function() {

let number=0;

return {

next:function() {

if(number<10) {

return { done:false, value:++number };

}else {

return { done:true };

}

}

}

}

for(let numof numbersIterable) {

console.log(num);

}

As we can see from example 14.1 we had to create iterator object to make`numberIterable` iterable, it is very important to differentiate between`iterable` and`iterator`, in the next example we will create iterator

letnumbersIterator=function(max) {

let number=0;

return {

next:function() {

if(number< max) {

return { done:false, value:++number };

}else {

return { done:true };

}

}

}

}

constmyNumbersIterator=numbersIterator(6);

console.log(myNumbersIterator.next().value);// 1

console.log(myNumbersIterator.next().value);// 2

console.log(myNumbersIterator.next().value);// 3

console.log(myNumbersIterator.next().value);// 4

console.log(myNumbersIterator.next().value);// 5

console.log(myNumbersIterator.next().value);// 6

console.log(myNumbersIterator.next().value);// undefined

1.`for-of` loop

2.`[]` array destrcuturing pattern

3.`...` spread operator

var num=10;// allocates memory for number

This is the most naive garbage collection algorithm. This algorithm reduces the definition of`an object is not needed anymore` to`an object has no other objects referencing it`. An object is considered garbage collectible if there are zero references pointing at this object.

There is a limitation when it comes to cycles. In the following example, two objects are created and reference one another, thus creating a cycle. They will go out of scope after the function call, so they are effectively useless and could be freed. However, the reference-counting algorithm considers that since each of the two objects is referenced at least once, neither can be garbage-collected.

functionf() {

In javascript using an undeclared variable will create a new variable in global object, in browser it will be created under`window` object

In this example we will see how initializing a variable without declaring it can cause an unintended leak.

We can avoid this by adding`use strict` at the beginning of our javascript file, this will switch to strict mode in javascript execution and prevent such unintended global variables creation.

In this example we will see how incorrect usage of[`this`](context.md) can cause unintended global variables and as a result Leak.