Forem: Farzad Aziminia

Introduction to Mongodb for Node.js developers

Farzad Aziminia — Tue, 20 Jul 2021 23:06:05 +0000

What is Mongodb?

Mongodb is a document based database which is built to be distributed and highly available. All the documents stored in the Mongodb are JSON like format which makes Node.js a perfect programming language to choose. Mongodb is the front runner of the Nosql movement, it is the most popular Nosql database. It has a flexible Schema, meaning the documents that are stored in a collection can have different structures. Ok what is the document and what is the collection?

The Database in Nosql world is similar to schemas in relation database world, Collection is similar to tables and a document is a row in a table. So in summary, Database is a collection of collections, and collection is a collection of documents in Mongodb.

If you are coming from the relational database world and you are trying to design a Schema for your application using Mongodb, You need to put some of the normalization rules aside. Mongodb offers you more than just primitive RDBMS data types. You can have nested objects and arrays in your collections.
Imagine you want to design a system that tracks your users interests and locations. In the RDBMS world, you need to have at least 3 tables to accomplish the requirements (Users, interests and Locations). And if you want to retrieve a user’s information, you need to join all those tables together. With Mongodb, we can have all the information in one document. Can you already see how simple it is?

{
  Name: "Farzad",
  LastName: "Aziminia",
  Interests: ["development", "music", "cycling"],
  Locations: [{city: "Irvine", current: true}, {city: "dana point"}],
  Occupation: "Software Engineer",  
}

As you can see All of your user’s information can reside within one JSON document. There’s no need of nasty joins. The inserts and queries are blazing fast compared to traditional relational databases.
Interestingly, Mongodb's query language is also JSON like. Imagine you want to query all the users who are named “Farzad”. Your query will look like this: {Name: "Farzad"}. Amazing! Isn't it?

Run mongodb inside docker

docker run -d --name mongodb -e MONGO_INITDB_ROOT_USERNAME=root -e MONGO_INITDB_ROOT_PASSWORD=password -p 27017:27017 mongo

The above command will run a mongodb instance inside a docker container. We set an initial username and password to root/password and bind the port 27017 of our host to the docker’s 27017 port. Now we should be able to connect to our mongodb.

To connect to Mongodb, we will use the native Mongodb library, there are other good alternative line mongoose, but for this tutorial, we will use the native library.

Create Connection

To start, let's install mongod library, here is how your package.json should look like:

{
 "name": "mongodb",
 "version": "1.0.0",
 "description": "",
 "main": "index.js",
 "scripts": {
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "author": "",
 "license": "ISC",
 "dependencies": {
   "mongodb": "^4.0.0"
 }
}

Ok, after you create package.json file and paste the above content to it, you can do npm install.

Now, let’s create a file called mongodb.js

const mongo = require('mongodb').MongoClient

const PARAMS = {
   useNewUrlParser: true,
   useUnifiedTopology: true,
};
const URI = 'mongodb://root:password@localhost:27017'

let connection

const connectMongo = async () => {
   connection = await mongo.connect(URI, PARAMS);
   console.log('Mongodb Connected');
}

module.exports = { connectMongo }

There is a lot going on. Let's get to it. In the first line, from the Mongodb package, I imported MongoClient and assigned it to a constant variable called mongo. We're gonna skip to 7, at line 7 we constructed our Mongodb connection string. Our docker image is mapped to our localhost port 27017 and the initial username password is root and password, line 13 we created a function to kick off the connection process by passing URI and the extra configuration. You can read more about the configuration here:
https://mongodb.github.io/node-mongodb-native/3.2/api/MongoClient.html
And at the last line, we expose our connection function to the other functions. Now lets Create our index.js file

Create our index.js file

const connectMongo = require('./mongodb').connectMongo

const startup = async () => {
   await connectMongo()
}

startup()

Now we can run our index.js file. if everything has been done correctly, you should be able to see the “Mongodb Connected” message.

Now let’s modify our mongodb.js file to expose our connection object

const mongo = require('mongodb').MongoClient

const PARAMS = {
   useNewUrlParser: true,
   useUnifiedTopology: true,
};
const URI = 'mongodb://root:password@localhost:27017'

let connection

const connectMongo = async () => {
   connection = await mongo.connect(URI, PARAMS);
   console.log('Mongodb Connected')
}

const getConnection = () => {
   return connection;
}

module.exports = { connectMongo, getConnection }

Now I’m gonna create a new file called user.js to create the necessary functions that facilitate the communication with Mongodb

const mongo = require('./mongodb');
const DB_NAME = 'users';
const COLLECTION_NAME = 'users';

const getUserCollection = () =>  mongo.getConnection().db(DB_NAME).collection(COLLECTION_NAME)

const createUser = async (user) => {
   return getUserCollection().insertOne(user);
}

const getUsers = async (criteria={}) => {
   return getUserCollection(criteria).find({});
}

const getSingleUser = async (criteria) => {
   return getUserCollection().findOne(criteria);
}

const deleteSingleUser = async (criteria) => {
   return getUserCollection().deleteOne(criteria);
}

const deleteAllUsers = async () => {
   return getUserCollection().deleteMany({})
}

module.exports = {
   deleteAllUsers,
   deleteSingleUser,
   getSingleUser,
   getUsers,
   createUser,
}

At line 6, I created a function to return the users inside users collection, to do that, first we need to point to our database Users, from there we can point to our collection Users. One thing I wanna mention is, unlike relational databases, you don’t need to create a database or collection before you can start inserting records. Mongodb will do all that for you. When you command Mongodb to insert a document into your collection, if the collection does not exist, it will create one for you.

Crud Operations

In order to interact with Mongodb driver, we have to utilize the functions that it designated for us. Mostly the functions do return a Promise. You can find the list of all the functions on the following link. https://mongodb.github.io/node-mongodb-native/3.2/api/Collection.html#find

One thing I wanna mention is, when you are trying to get a list of documents from a collection, the driver returns a Cursor Object. You can iterate through the cursor object differently. In our example I used toArry() method to convert it to an array.
You can read more here https://mongodb.github.io/node-mongodb-native/3.2/api/Cursor.html

Let’s start using our functions. For this example, I’m gonna create 3 users and then start writing some queries and at the end, delete all users.

Let’s start modifying our index.js file

const connectMongo = require('./mongodb').connectMongo
const User = require('./user')

const user1 = {
   name: 'Farzad',
   lastName: 'Aziminia',
   interests: ['Software Engineer', 'Music', 'Cycling'],
   locations: [{ city: 'Irvine', current: true }, { city: 'Dana Point' }],
};

const user2 = {
   name: 'Adam',
   lastName: 'Smith',
   interests: ['Construction Worker', 'Cars', 'Beer'],
   locations: [{ city: 'Los Angeles', current: true }, { city: 'Newport Beach' }],
};

const user3 = {
   name: 'Jack',
   lastName: 'Ryan',
   interests: ['Software Engineer', 'Cars', 'hiking'],
   locations: [{ city: 'Santa Ana' }],
};

const startup = async () => {
   await connectMongo()
   await User.createUser(user1);
   console.log('user1 created');
   await User.createUser(user2);
   console.log('user2 created');
   await User.createUser(user3);
   console.log('user3 created');
   const result = await User.getUsers();
   console.log(JSON.stringify(result));
}

startup()

If you run the code, you should be able to see all the users created in our collection. The result of our getAllUsers query should look like this:

[{"_id":"60f6332a75935a4199c3d615","name":"Farzad","lastName":"Aziminia","interests":["Software Engineer","Music","Cycling"],"locations":[{"city":"Irvine","current":true},{"city":"Dana Point"}]},{"_id":"60f6332a75935a4199c3d616","name":"Adam","lastName":"Smith","interests":["Construction Worker","Cars","Beer"],"locations":[{"city":"Los Angeles","current":true},{"city":"Newport Beach"}]},{"_id":"60f6332a75935a4199c3d617","name":"Jack","lastName":"Ryan","interests":["Software Engineer","Cars","hiking"],"locations":[{"city":"Santa Ana"}]}]

Have you noticed that all of our documents carry a new element called _id? Mongodb creates a unique identifier for every document and attaches it automatically.

Now I’m gonna get all the users that are named “Farzad”.

Note: from now on, I’m just gonna update the function startup, the rest of the index.js file will be the same as above

const startup = async () => {
   await connectMongo()
   const result = await User.getSingleUser({name: 'Farzad'});
   console.log(result);
}

The query that gets passed to the driver is { name: "Farzad" }. This is how you have to write your queries against the Mongodb. If I wanna get all users named jack, my query would look like this, { name: "Jack" }. Ok now let's get all the users that either name Farzad Or Jack.

const startup = async () => {
   await connectMongo()
   const result = await User.getUsers({$or:[{name: 'Farzad'}, {name: 'Jack'}]});
   console.log(result);
}

I used the $or operator, $or accepts an array of expressions and performs logical OR operation. In our case, we are saying return all the users that are named Farzad OR Jack.
The other thing I wanted to mention is: If you look at Users.js file, getUsers function uses find method but getSingleUser uses findOne method in the background. The difference is, find returns an array results but findOne only returns the first document that matches the criteria.
Ok, let's do an array operation. I want to get all the users who are interested in Cars:

const startup = async () => {
   await connectMongo()
   const result = await User.getUsers({interests: 'Cars'});
   console.log(result);
}

Querying arrays is similar to querying a normal object. Now I want to get the list of users who has the current location.

const startup = async () => {
   await connectMongo()
   const result = await User.getUsers({'locations.current':{$exists: true}});
   console.log(result);
}

This is how you can query the nested elements within an object. Now lets delete all users whose name is Jack and last name is Ryan.

const startup = async () => {
   await connectMongo()
   const result = await User.deleteSingleUser({name: 'Jack', lastName: 'Ryan'});
   console.log(result);
}

If you look at the result, you will see it gives you the number of deleted documents:

{ acknowledged: true, deletedCount: 1 }

And if you query the database again, you should see only 2 documents

const startup = async () => {
   await connectMongo()
   const result = await User.getUsers();
   console.log(JSON.stringify(result));
}

Lastly, lets delete all the documents

const startup = async () => {
   await connectMongo()
   const result = await User.deleteAllUsers();
   console.log(result);
   const records = await User.getUsers()
   console.log(records)
}

When you run the application, You should be able to see the following output:

Mongodb Connected
{ acknowledged: true, deletedCount: 2 }
[]

That will conclude our today’s tutorial. Stay tuned for more advance Mongodb tutorials

Conclusion:

Mongodb is a very high performance document based database
The query language of Mongodb is json, that’s why Node.js is a perfect fit since Javascript supports Json natively
Each record inside Mongodb called Document and a collection of documents called Document and within a database you can have N number of Collections

Introduction to RabbitMQ for Java Developers

Farzad Aziminia — Sat, 05 Jun 2021 20:09:52 +0000

Prerequisites

For this tutorial you need some background of Java, maven, and have docker installed on your machine

Queue

In computer science there’s the concept of queues. Queue is the set of messages that are meant to be delivered from one sender to one or more receivers. The messages can be delivered in order or out of order by design. The computer program that handles these transactions is called message broker. RabbitMQ is one the most popular message brokers that runs on top of Advanced Message Queuing Protocol (AMQP). There are four main components forming AMQP protocol: Publisher, Exchange, Queue, Consumer.

Publisher

Messages are Published to an exchange by a publisher, Publisher also is responsible for setting the attributes of the message which we will cover later.

Exchanges

Exchanges are responsible for routing the messages to one or more Queues, we will cover Queues Later. There are 4 different types of exchanges in rabbitmq.

1.Direct
2.Fanout
3.Topic
4.Header

For this tutorial we are going to cover only two: Direct, I’m gonna do another tutorial on the Fanout exchange later.

Direct exchanges are responsible for routing messages to a queue based on the Routing key. When you declare a queue you can “Bind” it to an exchange using a Routing key, we will cover this topic later. Direct queues are suitable for distributing tasks among Workers.

A Fanout exchange sends a message to all of the queues that are bound to the exchange by a routing key. When a message comes in, the exchange will send a copy of that message to all Queues. Fanout exchanges are useful to broadcast a message to multiple nodes in a distributed system.

Queues

Queues are responsible for storing the messages and delivering them to consumers. Queues need to get declared before you can start using them. A Queue needs to bind to an exchange so it can start receiving messages. Binding is a set of rules that exchanges use to route messages to one or more queues.

Consumers

Consumers are the last piece of the puzzle, they need to Subscribe to a queue so they can start receiving messages, when a consumer receives and processes a message, it needs to “Acknowledge” the message in order to get another one.

Installing rabbitMQ

We will use docker to install rabbitmq and it’s management UI.



docker run --rm -it --hostname my-rabbit -p 15672:15672 -p 5672:5672 rabbitmq:3-management

We need to use a client library on port 5672 to communicate with the rabbitMQ server.
Now let's create a direct exchange and a queue. But first we have to download the client library. I use maven, paste this dependency in your pom.xml then do a maven install to download the client.



<dependency>
     <groupId>com.rabbitmq</groupId>
     <artifactId>amqp-client</artifactId>
     <version>5.12.0</version>
 </dependency>

Now we have the library downloaded, let’s create a connection factory. I create a package called com.queue



package com.queue;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Queue {
   private static final String HOST = "localhost";
   private Channel channel;

   public Queue() {
       ConnectionFactory cf = new ConnectionFactory();
       cf.setHost(HOST);
       try {
           Connection connection = cf.newConnection();
           channel = connection.createChannel();
       } catch (Exception e) {
           System.err.println(e);
       }
   }

   public void createExchangeQueue(String queueName, String exchangeName, String exchangeType, String key) {
       try {
           channel.queueDeclare(queueName, false, false, false, null);
           channel.exchangeDeclare(exchangeName, exchangeType);
           channel.queueBind(queueName, exchangeName, key);
       } catch (Exception e) {
           System.err.println(e);
       }
   }
}

There are a lot happening, let’s break it down

I first created my public constructor called Queue. Then within that constructor opened the connection to rabbitMQ and created a channel and assigned the channel object to a variable called channel. After that, I created a public void method called createExchangeQueue to create a queue and an exchange and bind those two together over a key.

Ok now we have our Queue class. Let's use it. Just for fun I’m gonna write a program to calculate the square of a number.



package com.rabbit;
import com.queue.Queue;
public final class App {
   private static String QUEUE_NAME = "square";
   private static String EXCHANGE_NAME = "myExchange";
   private static String KEY_NAME = "key";
   public static void main(String[] args) {
       Queue queue = new Queue();
       queue.createExchangeQueue(QUEUE_NAME, EXCHANGE_NAME, "direct", KEY_NAME);
   }
}

After you run the above code you can navigate to the management interface and click on queues tab and you will see the square under the list of queues. Now let’s modify our Queue class to send messages to our square queue and consume messages from the queue.



package com.queue;

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.nio.charset.StandardCharsets;
import com.rabbitmq.client.DeliverCallback;

public class Queue {
   private static final String HOST = "localhost";
   private Channel channel;

   public Queue() {
       ConnectionFactory cf = new ConnectionFactory();
       cf.setHost(HOST);
       try {
           Connection connection = cf.newConnection();
           channel = connection.createChannel();
       } catch (Exception e) {
           System.err.println(e);
       }
   }

   public void sendMessage(String exchange, String key, String message){
       try {
           channel.basicPublish(exchange, key, null, message.getBytes(StandardCharsets.UTF_8));
       } catch (Exception e) {
           System.err.println(e);
       }
   }

   public void listenToQueue(String queueName, DeliverCallback dlr) {
       try {
           channel.basicConsume(queueName, true, dlr, consumerTag -> { });
       } catch (Exception e) {
           System.err.println(e);
       }
   }

   public void createExchangeQueue(String queueName, String exchangeName, String exchangeType, String key) {
       try {
           channel.queueDeclare(queueName, false, false, false, null);
           channel.exchangeDeclare(exchangeName, exchangeType);
           channel.queueBind(queueName, exchangeName, key);
       } catch (Exception e) {
           System.err.println(e);
       }
   }
}

I created two new methods. The first one is a public void method called sendMessage, what it does is it accepts exchange, key and message then it uses the basicPublish method of our channel object to deliver the message to our square queue. The second method is another public void one which accepts the queue name and a callbackFunction. The basicConsume method invokes our callbackFunction every time there’s a new message inside our square queue. Now we have our queue class fully written, let's start working on our square logic which is our consumer.



package com.square;
import com.rabbitmq.client.DeliverCallback;
import com.queue.Queue;

public class Square{
   private static String QUEUE_NAME = "square";
   private static String EXCHANGE_NAME = "myExchange";
   private static String KEY_NAME = "key";
   public void listenToMessage(){
       Queue queue = new Queue();
       queue.createExchangeQueue(QUEUE_NAME, EXCHANGE_NAME, "direct", KEY_NAME);
       queue.listenToQueue(QUEUE_NAME, findSquare);
   }

   DeliverCallback findSquare = (consumerTag, delivery) -> {
       String message = new String(delivery.getBody(), "UTF-8");
       int number = Integer.parseInt(message);
       int squareNumber = number * number;
       System.out.println("Square of " + message + " is: " + squareNumber );
   };
}

This is our Consumer, it has one public method, the first one opens a new connection, creates a new queue(the square queue already exists, so it’s just making sure it’s there before it starts listening to it) and then starts listening to the queue. Then we have a callback function called findSquare, it gets the message from the queue, parses the message (The message comes as a string), finds the square of the number and prints it into the screen.

And here’s our main Class



package com.rabbit;
import com.queue.Queue;
import com.square.Square;
public final class App {
   private static String QUEUE_NAME = "square";
   private static String EXCHANGE_NAME = "myExchange";
   private static String KEY_NAME = "key";
   public static void main(String[] args) {
       Queue queue = new Queue();
       queue.createExchangeQueue(QUEUE_NAME, EXCHANGE_NAME, "direct", KEY_NAME);
       queue.sendMessage(EXCHANGE_NAME, KEY_NAME, "5");
       Square sq = new Square();
       sq.listenToMessage();
   }
}

Now after you run the above code, you can navigate to your queue from the management ui and you’ll see that you have a message inside square queue

Let's consume that message and find the square



package com.rabbit;
import java.util.ArrayList;
import java.util.List;

import com.queue.Queue;
import com.square.Square;
public final class App {
   private static String QUEUE_NAME = "square";
   private static String EXCHANGE_NAME = "myExchange";
   private static String KEY_NAME = "key";
   public static void main(String[] args) {
       Queue queue = new Queue();
       queue.createExchangeQueue(QUEUE_NAME, EXCHANGE_NAME, "direct", KEY_NAME);
       List<String> numbers = new ArrayList<String>();
       numbers.add("1");
       numbers.add("2");
       numbers.add("3");
       numbers.add("4");
       numbers.add("5");
       numbers.forEach((n)-> queue.sendMessage(EXCHANGE_NAME, KEY_NAME, n));
       Square sq = new Square();
       sq.listenToMessage();
   }
}

Now we have a list of numbers instead of one, and we are using the forEach method to iterate through the list and send the numbers to the queue one by one. Now run your consumer and you will see the consumer automatically consumes all the messages and shows the square of all the numbers.

Conclusion

RabbitMQ is a popular message broker that runs on top of AMPQ protocol. AMPQ protocol is consist of 4 components: 1-Publisher, 2-Exchange, 3-Queue, 4-Consumer.

Introduction to RabbitMQ for Nodejs Developers

Farzad Aziminia — Mon, 31 May 2021 02:01:54 +0000

Prerequisites

For this tutorial you need some background of Node.js and have docker installed on your machine

Queue

Publisher

Messages are Published to an exchange by a publisher, Publisher also is responsible for setting the attributes of the message which we will cover later.

Exchanges

Exchanges are responsible for routing the messages to one or more Queues, we will cover Queues Later. There are 4 different types of exchanges in rabbitmq.

1.Direct
2.Fanout
3.Topic
4.Header

For this tutorial we are going to cover only two: Direct, I’m gonna do another tutorial on the Fanout exchange later.

Queues

Consumers

Installing rabbitMQ

We will use docker to install rabbitmq and it’s management UI.

docker run --rm -it --hostname my-rabbit -p 15672:15672 -p 5672:5672 rabbitmq:3-management

The above command will install rabbitmq and bind two ports to your local port: 5672 and 15672.
You can use 15672 to get into rabbitMQ management portal: http://localhost:15672 the default username password is guest/guest.
We need to use the amqplib library on port 5672 to communicate with the rabbitMQ server. Now lets create a direct exchange and a queue

const rabbit = require('amqplib');
const QUEUE_NAME = 'square';
const EXCHANGE_TYPE = 'direct';
const EXCHANGE_NAME = 'main';
const KEY = 'myKey';
const number = '5'
connection = rabbit.connect('amqp://localhost');
connection.then(async (conn)=>{
   const channel = await conn.createChannel();
   await channel.assertExchange(EXCHANGE_NAME, EXCHANGE_TYPE);
   await channel.assertQueue(QUEUE_NAME);
   channel.bindQueue(QUEUE_NAME, EXCHANGE_NAME, KEY);
})

There are a lot happening, let’s break it down

At line 1 I imported amqplib library then at line 7 I created a connection to rabbitmq
Line 9 I created a channel inside the connection, you need to create a channel before you can start interacting with rabbitmq. At line 10 I used assertExchage method to create an exchange. This method takes two arguments: name of the exchange and type of the exchange
At line 11 I used the assertQueue method to create a Queue called square. And at line 12 I used bindQueue method to bind main to square with the routing key myKey

After you run the above code you can navigate to the management interface and click on queues tab and you will see square under the list of queues

Let's write an application to calculate the square of a number

const rabbit = require('amqplib');
const QUEUE_NAME = 'square';
const EXCHANGE_TYPE = 'direct';
const EXCHANGE_NAME = 'main';
const KEY = 'myKey';
const number = '5'
connection = rabbit.connect('amqp://localhost');
connection.then(async (conn)=>{
   const channel = await conn.createChannel();
   await channel.assertExchange(EXCHANGE_NAME, EXCHANGE_TYPE);
   await channel.assertQueue(QUEUE_NAME);
   channel.bindQueue(QUEUE_NAME, EXCHANGE_NAME, KEY);
   channel.sendToQueue(QUEUE_NAME, Buffer.from(number))
})

We can use the sendToQueue method to send messages to the square queue. sendToQueue method takes two arguments, name of the queue and the content which you want to send. The only caveat is the content should be in the buffer format.

Now after you run the above code, you can navigate to your queue from the management ui and you’ll see that you have a message inside square queue

Let's consume that message and find the square

const rabbit = require('amqplib');
const QUEUE_NAME = 'square';
connection = rabbit.connect('amqp://localhost');
connection.then(async (conn)=>{
   const channel = await conn.createChannel();
   channel.consume(QUEUE_NAME, (m)=>{
       const number = parseInt(m.content.toString())
       const square = number * number
       console.log(square)
       channel.ack(m)
   })
})

It’s pretty much similar to our publisher in many ways, we need to open a connection and create a channel then we can use the consume method that is exposed from our channel object. The consume method accepts two arguments, the queue name and a callback. Whenever a message gets published to the square queue, this callback function will be invoked. The callback function accepts an argument which is the message object. We can find our number under the content property. If you remember, when we published our message, we had to convert our number to a buffer, so when we consume the content, we have to convert it back to the number. First we need to convert the number from buffer to string, then from string to number. When we have our number, we can find the square and console log it to the screen and finally we can use ack method to acknowledge the message and tell rabbitmq to remove that message from the queue and send the next one if any. So first run your publisher and then consumer to see the effect. You can also have the management console open and watch the activity on your queue.

Next lets run two consumer and one modify our publisher a bit

const rabbit = require('amqplib');
const QUEUE_NAME = 'square';
const EXCHANGE_TYPE = 'direct';
const EXCHANGE_NAME = 'main';
const KEY = 'myKey';
const numbers = ['1', '2', '3', '4', '5']
connection = rabbit.connect('amqp://localhost');
connection.then(async (conn)=>{
   const channel = await conn.createChannel();
   await channel.assertExchange(EXCHANGE_NAME, EXCHANGE_TYPE);
   await channel.assertQueue(QUEUE_NAME);
   channel.bindQueue(QUEUE_NAME, EXCHANGE_NAME, KEY);
   numbers.forEach((number)=>{
       channel.sendToQueue(QUEUE_NAME, Buffer.from(number))
   })
})

Now we have an array of numbers instead of one, and we are using the forEach method to iterate through the array and send the numbers to the queue one by one. Now run your consumer and you will see the consumer automatically consume all the messages and show the square of the numbers.

Conclusion

RabbitMQ is a popular message broker that runs on top of AMPQ protocol. AMPQ protocol is consist of 4 components: 1-Publisher, 2-Exchange, 3-Queue, 4-Consumer.

In order to comunicate to rabbitmq we need to open a connection and inside the connection create a channel.Then we can both publish a message to a queue or consume messages form a queue or queues.

An Introduction to Object.Freeze and Const for Javascript Developers

Farzad Aziminia — Sun, 29 Mar 2020 17:39:25 +0000

Prerequisites

Basic knowledge of javascript
Javascript Objects

In the world of javascript, Object is everything. W3School puts it this way: “If you understand objects, you understand JavaScript”. But what is a javascript object and why is it so important?
Javascript Object is a set of associations between keys and values. Objects can hold values to the “Primitive” data types (String, Number, Boolean, Null, Undefined) or in the form of a function.
You can learn more here. Now let's do some codding:

let student = {
   firstName: 'John',
   lastName: 'Doe',
   gpa: 3.7,
   print: ()=>{
       console.log(`Student Name: ${student.firstName} ${student.lastName},
       GPA: ${student.gpa}`);
   }
};

student.print();

In the code above we created an object called student with 4 properties (keys) and then we ran the “print” function inside our object. So that's basically how you can create an object in javascript.

let student = {
   firstName: 'John',
   lastName: 'Doe',
   gpa: 3.7,
   print: ()=>{
       console.log(`Student Name: ${student.firstName} ${student.lastName},
       GPA: ${student.gpa}`);
   }
};
student.print();

student.firstName = 'Jared';
student.lastName = 'James';

student.print();

In the code above, as you can see, we can modify the values of student’s properties directly. There would be a situation where you don’t wanna allow yourself or other developers to modify your object. This can be either you want to follow the Immutability paradigm (You can learn more from one of my previews entries) or your object is carrying some sensitive global information such as configuration.

Const

ES6 introduced the concept of “Constants”. If you are familiar with Object-oriented, it’s when you declare a variable as “final”, you cannot reassign that variable or modify its value. The same goes for “const” in javascript. In Javascript (ES6+) When you initiate a variable with const, you no longer can re-assign that variable. If you want to be able to re-assign a variable, you should use the let keyword.

let name = 'John';
console.log(name);
name = 'James';
console.log(name);
const name2 = 'Joe';
name2 = "Jack"

You may think now, the problem is solved, now I can define my student object with const and nobody can modify its property. That’s somehow true. If you define your student object with const, no one would be able to re-assign it with other objects but you still can modify its properties.

const student = {
   firstName: 'John',
   lastName: 'Doe',
   gpa: 3.7,
   print: ()=>{
       console.log(`Student Name: ${student.firstName} ${student.lastName},
       GPA: ${student.gpa}`);
   }
};
student.print();

student.firstName = 'Jared';
student.lastName = 'James';

student.print();

student = {};

If you run the above code, You’ll see it runs up to the last line when you reassign the student object to an empty object. That’s where it throws errors. So what is the solution?

Object.freeze

const student = {
   firstName: 'John',
   lastName: 'Doe',
   gpa: 3.7,
   print: ()=>{
       console.log(`Student Name: ${student.firstName} ${student.lastName},
       GPA: ${student.gpa}`);
   }
};

Object.freeze(student);
student.print();

student.firstName = 'Jared';
student.lastName = 'James';

student.print();

Object.Freeze is one of the Object’s methods. If you run the above code, you will see the result of the second print is identical to the first print. The reason is: after I created the student object, I used Object.freeze to “freeze” my object. In another word, when an object gets frozen by Object.freeze, you no longer would be able to add, modify or delete the properties of that particular object. But there is a pitfall, consider the following code:

const student = {
   name:{
       first: 'John',
       last: 'Doe'
   },
   print: ()=>{
       console.log(`Student Name: ${student.name.first} ${student.name.last}`)
   }
};

Object.freeze(student);
student.print();

student.name.first = 'Jared';
student.name.last = 'James';

student.print();

You would expect the result of the two prints to be identical. The difference is: Object.freeze is not freezing the name object under student.
Here how you can fix it:

const student = {
   name:{
       first: 'John',
       last: 'Doe'
   },
   print: ()=>{
       console.log(`Student Name: ${student.name.first} ${student.name.last}`)
   }
};

Object.freeze(student);
Object.freeze(student.name);

student.print();

student.name.first = 'Jared';
student.name.last = 'James';

student.print();

Conclusion

We talked about how to create an object in javascript, Then we talked about creating a constant. We talked about why we need Object.freeze and what the limitations are. Next, I’ll talk about queues in node.js and introduce RabbitMQ

A practical introduction to Redis for the Node.js developers

Farzad Aziminia — Sun, 08 Mar 2020 15:49:16 +0000

Redis

Redis is a Key-Value “In-memory Database”. Ok, what is the “In-memory Database”? What is a Key-Value Store?

key-value database

According to Wikipedia “A key-value database, or key-value store, is a data storage paradigm designed for storing, retrieving, and managing associative arrays, and a data structure more commonly known today as a dictionary or hash table.”
In a simpler explanation: You create a key, for example, “username” and assign a value to it, for example, “john”. From there, you can get, update or delete the value associated with your key. Let’s see that in action. First, We need to install Redis. I’m using docker. If that is not your preferred way, visit https://redis.io/download.

docker run --name test-redis -p 6379:6379 -d redis

Then verify your installation by running docker ps

Now let’s get into coding. We need to install the Redis client library.

Now create your package.json file and insert following code:

{
 "name": "redisexample",
 "version": "1.0.0",
 "author": "Farzad Aziminia",
 "license": "ISC",
 "dependencies": {
   "redis": "^3.0.2"
 }
}

Now run

npm install

Ok, It’s time to get our hands dirty. Create a file called app.js and insert the code below to it. Now run the node app.js

const redis = require('redis');
const client = redis.createClient();

client.set('foo', 'bar', redis.print);
client.get(‘foo’, redis.print);

You create a “key” called “foo” and you set the value of “bar” to it. Next, you got the value of “foo” back. This is the “Key-Value” store in a nutshell.
Because I’m using Redis’s default authentication (Which is not recommended for production), I don’t need to pass username, password to createClient method. Redis.print basically prints the result of callback from the set and the get method.
Now we know what is Key-Value datastore, What is In-Memory Database?

In-Memory Database

In-Memory Database (IMDB) is a data management paradigm that utilizes computer memory to attain minimal response time by eliminating disk operations. We store our data in memory because usually memory access is way faster than disk access. You may ask: What are the downsides? Why do we still need to use DMS which relies on disk? Although solutions like Redis offer persistence, one drawback of using an in-memory database is: You will lose all of your data when the machine loses power or restarts, Another drawback can be related to cost, Computer memory tends to be more expensive than disk. These days you can purchase terabytes of disk space for a few hundred dollars.

Data structures

Unlike common key-value stores, Redis offers more than just string values. I'm not gonna cover all of them but you can learn more on https://redis.io/topics/data-types-intro.

Binary-safe strings

This is the most common data structure among key-value stores. Like we described above, simply pick a key and assign a value to it. Since both the key and the value are string in this structure, we can say it is a string to string binding.
The common operations are, Set, Get, Delete. Let’s update our example.

const redis = require('redis');
const client = redis.createClient();
client.set('user', 'admin', redis.print);
client.get('user', redis.print);
// Update our user
client.set('user', 'bob', redis.print);
client.get('user', redis.print);
client.del('user', redis.print);
client.get('user', redis.print);

One of the nice features that Redis is providing us is the expiration date or time to live. You can create a key and assign a “time to live” to it.

const redis = require('redis');
const client = redis.createClient();
client.set('session', '123', redis.print);
client.expire('session', 3, redis.print);
client.get('session', redis.print);

setTimeout(()=>{client.get('session', redis.print);}, 3000);

As you can see, after you create a key you can the expire method to set expiration in seconds. If you get an expired key you’ll get null.

Hashes

Hashes are a set of key values associated with a key. There is no limit to the number of fields you can add to a key. This is very similar to JSON. Common methods associated with the hashes are, hmset, hget, and hgetall. Let’s use them in an example:

const redis = require('redis');
const client = redis.createClient();

client.hmset('user01', 'name', 'bob', 'interest', 'football', redis.print);
client.hmset('user02', 'name', 'edward', 'interest', 'basketbal', redis.print);
client.hget('user01', 'name', redis.print);
client.hget('user02', 'name', redis.print);
client.hgetall('user01', (err, user)=>console.log(user));

Hashes are very memory efficient and a very good way of storing objects temporarily for frequent access.

Sets

Sets are an unordered collection of strings. You can call it “an unordered array of strings”. One thing that you need to keep in your mind is, Sets are non-repeating. Meaning you cannot repeat a given string in the set. Here is how you can create a set and get the members of a set:

const redis = require('redis');
const client = redis.createClient();

client.sadd('daysOfWeek', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday');
client.smembers('daysOfWeek', (err, value)=>console.log(value))

As you can see, You can add a member to a given list with the “sadd” method and get the list of all members of a list by “smembers” method also The returned result is not in the same order that you have saved. This is totally normal behavior of Redis set. That bring us to Ordered Sets

Ordered Sets
Ordered Sets are very similar to Sets. They are non-repeating set of string but the difference is, every member is associated with a “Score”. Redis uses that score in order to sort the array.

const redis = require('redis');
const client = redis.createClient();

client.zadd('daysOfWeek', 1, 'Sunday', 2, 'Monday', 3, 'Tuesday', 4, 'Wednesday', 5, 'Thursday');
client.zrange('daysOfWeek', 0, -1, (err, value) => console.log(value))

Zadd is the method you need to use in order to create an ordered set and insert members to it. You start with naming your set and add score followed by the value associated with the score. In our example, 1 is associated with Sunday, 2 with Monday, etc….
Then we used zrange to query our set. With zrange you can specify the start point and the endpoint of your range then Redis will return the result. It’s important to remember that the result is already sorted by the score that you provided. Zrange accepts both positive and negative numbers where 0 is the first element and 1 is the second element. Also, -1 is the last element and -2 is the one before the last element. In our case, we stated 0 which is the first element as our start point and -1 which is the last element of the set as our endpoint.

Conclusion
We talked about the concept of the In-memory Database in general and why we need it. We used Docker to run the Redis server and used redis-client library to connect to it. Then we talked about some of the important data types available and we did a couple of coding exercises.

Next, I’ll talk about Javascript Objects and variable instantiation.

Immutability, Map, Filter

Farzad Aziminia — Sat, 15 Feb 2020 01:17:22 +0000

Welcome to "JavaScript: Tricks and tips" In this series of blogs, I'll show you some development tips and will solve some of the problems that I've faced during my career as a Software engineer.
Writing the Immutable JavaScript code is getting more popular every day. If you just google immutable javaScript, there are dozen of libraries and articles around it. But what is immutable?

Immutability

In short, an Immutable object cannot be changed once created. Let me give you an example: Let’s say we have an array of users and we want to add a new user to it: here is the mutable way of doing it:

let users = ['David', 'frank'];
users.push('John');
console.log(users.toString());

It works, but we broke the immutability rule, we changed our User array. Let’s fix it:

const users = ['David', 'frank'];
const newUsers = [...users, 'John'];
console.log(users.toString());
console.log(newUsers.toString());

Perfect. Now we have both original users array and newUsers array. You may ask, both approaches are working and produce the same result! Why should I bother myself? The answer is Immutability make programming safer by means, you do not modify the current state of the application by that, you have a single source of truth. In our first example, after you add john to the array and let's say you want to compare the old list to the new list, you may find it hard. But with the second approach, it’s easier since you have both arrays. Let’s do another example: Imagine we have a list of grades and we want to find the average. Simple right?

const grades = [90, 86, 40, 82];

let total = 0;

for (let i of grades){
   total += i;
}

const average = total / grades.length;

console.log(average);

Let’s do it immutable way:


const grades = [90, 86, 40, 82];

const average = grades.reduce((pre, curr) => {
   return pre + curr;
}) / grades.length;

console.log(average);

As you can see, the immutable approach is way cleaner and easier to read. This is another reason why I like to write immutable code.
Now, I like to introduce you to one of the most useful javaScript methods.

Filter

The filter method runs all of the array elements against a function that you provide and if they pass the criteria, it will create a new array and store that element. Because it does not modify the original array it is considered immutable. Let’s revisit our grade example and let’s say we want to print all the grades less than 85;

const grades = [90, 86, 40, 82];

const filtered = grades.filter(n => n < 85);

console.log(filtered);

It is really amazing how easy and powerful this method is. In general, immutability can lead to more readable code. Let’s do another example. This time we want to solve the famous problem of “You have an array of numbers, find even numbers and print them”. Let’s use the filter method and solve that problem:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

function isEven(number) {
   return (number % 2 === 0);
}
const evenNumbers = numbers.filter(isEven);

console.log(evenNumbers.toString());

For every member of numbers array, filter method calls isEven function and if the result comes back true, It adds it into the evenNumbers array.

Here comes the fun part! What if our isEven function is an async. Let’s try it.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

function isEven(number) {
   return new Promise((resolve)=>{
       resolve((number % 2 === 0));
   })
}

const evenNumbers = numbers.filter(isEven);

console.log(evenNumbers.toString());

When you run the code, the result would be “1, 2, 3, 4, 5, 6, 7, 8, 9”. Interesting! Our isEven function no longer works. The reason is “filter” does not support async functions (at least now). That gets us to another very popular method.

Map

“Map” is another popular native javaScript method. Its behavior is very similar to “Filter”, But the difference is it runs all of the array elements against a function that you provide and it will create a new array and store all the results. Let’s do it in action:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

function isEven (number) {
   return {isEven: number % 2 === 0, entry: number}
}

const evenOdd = numbers.map(isEven);

console.log(evenOdd);

The “Map” method calls isEven function for every array element in numbers array and isEven function returns a JSON representation of if the number is even and the number itself.
Now we know how the Map method is working, let’s put that in use and try to fix our async filter problem:

(async function () {
   const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];
   function isEven(number) {
       return new Promise((resolve) => {
           resolve({isEven: number % 2 === 0, entry: number})
       })
   }
const result = (await Promise.all(numbers.map(isEven)))
    .filter(n => n.isEven);
   console.log(result);

})()

I know there is a lot happening here. It can be overwhelming. So let’s see what’s happening here.

I wrapped the whole execution around-invoking function. The reason I wrapped my code around that is I wanted to use async, wait type of promise. You can read more on this subject on https://javascript.info/async-await. Then I’m using Map to call isEven function. isEven function returns a promise so I add each and every promise into “Promise.all” method. “Promise.all” method takes an array of Promises and returns a single promise to fulfill and when all promises resolve, it returns an array of results which a JSON looks like this: [{isEven: true, entry: 2}, {isEven: false, entry: 3}]. Then I use the filter method to filter out all odd numbers.

Conclusion

We talked about Immutability and why it is important. We also talked about the filter method and discussed how we can use it to write immutable code. We talked about why we cannot use filter against an async function. Then we covered the map method and finally, we solved the mystery of how to filter an array with a function that returns a Promise.

Next, I'll do a two-part series on how to load-balance at the application layer.

Environment Variables

Farzad Aziminia — Fri, 07 Feb 2020 05:01:52 +0000

Welcome to "Javascript: Tricks and tips" In this series of blogs, I'll show you some development tips and will solve some of the problems that I've faced during my career as a Software engineer.

Every time we write a backend application, regardless of its stack, there are configurations that we want to apply to our application: Like tokens, endpoints, keys, etc. There are many reasons we need to avoid “Hard-Coding” (saving those values in our code base). Security (We don’t want to expose our credential information), Dynamic variable (Endpoints, ports, etc..), Scalability(Multiple server and environments), etc…

There are tools out there (paid and free) built for you. But wait for a second! Do we always need a separate application to handle our configurations?. The answer is no.

Environment Variables

An environment variable is a Key-value store hosted by Operating System. Think about it as a javascript variable but defined outside of the program. Most modern operating systems are supporting Environment Variables. Environment Variables are bind to a process. Means you can define a variable called PORT for example for a given process and give it the value of 80 and define PORT for another process and assign 8080. They not gonna step on each other toes.

When you are using Node.js, at runtime, environment variables get load and accessible through “process.env”. Let’s run an example: create a file called app.js

const http = require('http');
http.createServer().listen(8080).on('listening', ()=>{
   console.log('listening on port ' + 8080);
});

Run the app.js

node app.js

You would see listening on port 8080 in the console. Now, Let’s use environment variables

const http = require('http');
http.createServer().listen(process.env.PORT).on('listening', ()=>{
   console.log('listening on port ' + process.env.PORT);
});

Now you need to run:

PORT=8080 node app.js

Here you are defining a variable called PORT in the scope of app.js and assigning it with value 8080. It’s important to remember, the variable port is only accessible in the process that app.js running.

Now let’s be more creative.

const http = require('http');

const port = (process.env.NODE_ENV === 'prod') ? process.env.PROD_PORT : process.env.DEV_PORT 

http.createServer().listen(port).on('listening', ()=>{
    console.log('listening on port ' + port);
});

Now we need to define three variables: NODE_ENV, PROD_PORT, DEV_PORT.

If you want to run the application in development mode you should run:

PROD_PORT=3000 NODE_ENV=dev DEV_PORT=8080 node app.js

Result: listening on port 8080

Prod mode:

PROD_PORT=3000 NODE_ENV=prod DEV_PORT=8080 node app.js

Result: listening on port 3000

I guess you already realized what are the problems with this approach. first, When the number of variables increases, It’ll be hard to manage, and It’s error-prone.

Dotenv

Dotenv is a library that loads all of your environment variables from a .env file into your process.env. It is a very convenient way of separating your configuration from your codebase. Now let’s rewrite our application. First, install dotenv:

npm install dotenv

Now we have dotenv, create a file in your root call .env:

NODE_ENV=prod
PROD_PORT=3000
DEV_PORT=8080

We need to load our environment variables using dotenv:

require('dotenv').config();
const http = require('http');

const port = (process.env.NODE_ENV === 'prod') ? process.env.PROD_PORT : process.env.DEV_PORT 

http.createServer().listen(port).on('listening', ()=>{
    console.log('listening on port ' + port);
});

Now just run app.js! Yea that’s simple! But remember, if you keep any confidential information in your .env file such as passwords, secrets, keys, token, etc… DO NOT PUT YOUR .env FILE IN YOUR CODEBASE. Keep it separate, somewhere safe. Make sure you include .env in your .gitigore file.

My concern right now is what if our deployment goes wrong and for whatever reason, we fail to include our .env at runtime? There are so many different ways to solve that as simple as if statement. But I want to talk about my favorite approach.

Joi

Joi is a very powerful validation tool. It allows you to create complex schemas and validate your object in real time. Let’s create ours: first, install the Joi

Npm install @hapi/joi

Joi has a really simple declarative syntax.

const joi = require('@hapi/joi');

const envSchema = joi.object({
   devPort: joi.number().required(),
   prodPort: joi.number().required(),
   env: joi.string().required(),
});

Now validation is as simple as:

const http = require('http');
const joi = require('@hapi/joi');
require('dotenv').config();

const envSchema = joi.object({
   devPort: joi.number().required(),
   prodPort: joi.number().required(),
   env: joi.string().required(),
});

const environment = envSchema.validate({
   devPort: process.env.DEV_PORT,
   prodPort: process.env.PROD_PORT,
   env: process.env.NODE_ENV,
});

if (environment.error)
   throw (environment.error);

const port = (environment.value.env === 'prod') ? environment.value.prodPort : environment.value.devPort;

http.createServer().listen(port).on('listening', ()=>{
   console.log('listening on port ' + port);
});

When you declare a Joi schema, it exposes a method called validate which accepts a value and compares it against the schema which you declared. It returns an object with value and error. If no error occurs during the validation process it should be null and you can take the value continue with your code. But if the error is not null, it means validation failed. From here it’s up to you how you want to handle the error. In my case, I want to throw it and kill the process.

You can experiment with the above code snippet by including or excluding some required values in your .env file and see the different results. Now let’s separate our environment from our app.js for the sake of separation of concerns. For start create a file called environment.js:

const joi = require('@hapi/joi');
require('dotenv').config();

const envSchema = joi.object({
   devPort: joi.number().required(),
   prodPort: joi.number().required(),
   env: joi.string().required(),
});

module.exports = envSchema.validate({
   devPort: process.env.DEV_PORT,
   prodPort: process.env.PROD_PORT,
   env: process.env.NODE_ENV,
});

Now Our app.js should look like this:

const http = require('http');
const environment = require('./environment');

if (environment.error)
   throw (environment.error);

const port = (environment.value.env === 'prod') ? environment.value.prodPort : environment.value.devPort;

http.createServer().listen(port).on('listening', ()=>{
   console.log('listening on port ' + port);
});

Simple isn’t it. Now you have peace of mind. If your deployment breaks your deployment team will notice and will fix it.

Conclusion

Today we covered Environment variables and how we can utilize it to make our applications more secure and scalable. We talked about dotenv and discussed how using that library will make our codebase less error-prone. We also talked about Joi, how to create schemas and how to validate our objects.

I hope you enjoyed my blog today, next time I’ll talk about "How to filter an array based on async function!".

Control the speed of the JavaScript loop (Throttle).

Farzad Aziminia — Tue, 28 Jan 2020 05:39:09 +0000

Welcome to "Javascript: Tricks and tips" In this series of blogs, I'll show you some development tips and will solve some of the problems that I've faced during my career as a Software engineer.

JavaScript is one of the most popular programming languages. it’s dominated the web world and gaining popularity outside of the web. Node.js opened the door to the backend and Cordova took it into mobile.

It first appeared back in 1995 and it’s evolving since. Because of its age, there are so many different coding styles and development paradigms out there. One of the challenges that we may face during our development is: how can we control the speed of JavaScript loops? Although there are several different ways to achieve that, today I’ll discuss my favorite approach.

But first Let’s start with basic loops in javaScript:

For loop

For loop is the most basic and powerful way of running a block of code a number of times. We will not get into the gory details, but basically, a for loop is consists of a starting variable, end condition, and increments or negative increments statement.

console.log('start');
const count = 3;
for (let i = 0; i <= count; i++){
   console.log(i);
}
console.log('end');

output

start
0
1
2
3
end

Now we have our basic for loop, Let’s see how we can control the speed of that loop. One way to you can accomplish that goal is, wrap your console.log around setTimeout. But first, let’s talk about the setTimeout method and see how we can utilize that to achieve our goal.

setTimeout

setTimeoiut is one of the many native Javascript methods that enables scheduling execution of a given function in the future time. The method accepts a function, number in milliseconds, and optional parameters. For example:

console.log('start');

const myFunction = (parameter)=>{
 console.log('myFunction is called with parameter => ' + parameter)
}

setTimeout(myFunction, 2000, 'Book')

output:

start
myFunction is called with parameter => Book

As you can see, the “myFunction” function scheduled to execute in 2 seconds (2000 milliseconds) with “Book” as its parameter. After the function gets called, it prints “myFunctions is called with parameter => Book”.
The part that I want to emphasize is the parameters that you can pass to the function. You can do so many things with those parameters. With that in your mind, let’s re-write our for loop:

console.log('start');
const count = 3;
for (let i = 0; i <= count; i++){
  console.log('Block:' + i);
  setTimeout((ix)=>{
     console.log(ix);
  }, 1000 * i, i)
}
console.log('end');

output:

start
Block:0
Block:1
Block:2
Block:3
end
0
1
2
3

If you look at the outputs, you can see for each iteration, console.log gets scheduled for (“i” * 1000) in the future, with “i” passed as a parameter. So for the first iteration “i” is zero and console.log scheduled for immediate execution. The second time “i” is 1 and console.log scheduled for execution in 1 second and …. Next, we will talk about one of my favorite subjects in computer programming “Recursion”

Recursion

A recursive function is a function that calls itself in order to repeat a block of code to solve a problem. In the following code snippet, you can see how I iterated from 0 to 3.

console.log('start');
function loop(index, count){
   console.log(index);
   if (index < count){
       index ++;
       loop(index, count);
   }
}

loop(0, 3);
console.log('end');

output:

start
0
1
2
3
End

Now it’s the time to control the speed of our recursive function:

console.log('start');
function loop(index, limit, count){
  console.log('block:' + index);
  console.log(index);
  if (index < count){
      index ++;
      setTimeout(()=>{
          loop(index, limit, count);
      }, limit)
  }
}
loop(0, 1000, 3);
console.log('end');

output:

start
Block:0
0
end
Block:1
1
Block:2
2
Block:3
3

Hooray! But wait! As you can see the problem of our approach is, “end” gets printed after our first iteration. That’s because of the async nature of the javascript and how javascript manages its call stack. I don’t get into detail, but I’ll show you how you can fix it.

console.log('start');
function loop(index, limit, count){
   console.log(index);
   if (index < count){
       index ++;
       setTimeout(()=>{
           loop(index, limit, count);
       }, limit)
   } else {
       printEnd();
   }
}

loop(0, 1000, 3);

function printEnd(){
   console.log('end');
}

output

start
0
1
2
3
end

Let’s go through the steps to find out what happens once we run the code:

Start gets printed.
line 15 executes loop function and passes 0 as its parameter.
index gets printed which at this point is 0.
index is still 0 so our if statement returns true, index incremented by 1 and by using setTimeout function, we schedule our recursion to be executed in 1 second.
index gets printed which at this point is 1.
the Same pattern repeats until ”I” gets to 3
index is 3 so our if statement returns false, now our else statement gets executed and it’s calling “printEnd” function which prints “end“.

Conclusion

There are different ways to control the speed of Javascript Loop. Today we talked about two different ways of achieving that goal. We also discussed the setTimeout method and how it relates to our topic. We talked about recursion in general and how we can use that to loop. It’s really up to you which approach do you wanna take to throttle your loop, both works just fine, it depends on your use case.

In my next post, I will talk about the environmental variables. Stay tuned.