top of page
  • Writer's pictureAnushka Shrivastava

JavaScript We Need To Know Before Node.js – PART 2

Updated: Oct 6, 2022

As Node.js uses JavaScript as its programming language, it is important to know about the basics to intermediate level of JavaScript. The official documentation of Node.js recommends having a good grasp on the following concepts:

  • Lexical Structure

  • Expressions

  • Types

  • Classes

  • Variables

  • Functions

  • This

  • Arrow functions

  • Loops

  • Scopes

  • Arrays

  • Template literals

  • Semicolons

  • Strict mode

  • ECMAScript 6, 2016, 2017

In this article, we will be dealing with the following areas of concepts –

This article is a sequel of “JavaScript We Need To Know Before Node.js PART-1”.

Other topics are covered in articles containing part-1 and part-3. You can refer to the following links for the same:

JavaScript We Need To Know Before Node.js – PART 1

JavaScript We Need To Know Before Node.js – PART 3

Let us try to understand and take an overview of above mentioned concepts for complete beginners to the subject.


Variables can be said as named containers for a value. Value can be anything like a number we use for finding sum, or a string we use in a sentence.

Declaring a variable

There are four ways in which variables can be declared in JavaScript. They are –

1. Using var keyword

Ex – var myVar1;

2. Using let keyword

Ex – let myVar2;

3. Using const keyword

Ex – const myVar3;

4. Using nothing

Ex – myVar4

In above examples, all the variables are declared without any value. So, the variables will have undefined as their value after the execution of the code.

Initializing a variable

Once we have declared a variable, we can initialize it with a value using an assignment operator (=).

Example –

myVar1 = 28.90;
myVar2 = “Tom”;

Variables can also be initialized during declaration.

Example –

let x = “JavaScript”;
const y = 10;

To know more variables in JavaScript, you can refer to -


Loops execute a block of code over and over again. Loops are useful as they are handy and they help us to run the same code a number of times, each time with same or different value as per the requirements.

For example – If we want to print a word “car” 5 times.

Instead of writing:


We can write it as:

for (let i= 0; i<5; i++) {


avaScript supports different kind of loops. They are –

  • for loop

  • for/in loop

  • for/of loop

  • while loop

  • do while loop

In this article, we will be discussing about for loop, for/in loop and while loop

for loop

Syntax –

for ( expressions 1; expression 2; expression 3 ) { //code block



Expression 1: It is executed one time before the execution of the block. It is normally used to initialize a variable which will be used in the loop. Expression 1 is optional.

Expression 2: It is used to define a condition for the loop to run. If the condition holds true, loop will start over again. If it returns false, the loop will end. Expression 2 is also optional.

Expression 3: It is used to increment or decrement the value of the initial variable. Expression 3 is also optional.

For example –

for (let i = 0; i<5; i++){

for in loop

Syntax –

for ( key in object ) {

//code block


The for-in loop operates over an object or array. In terms of objects, each iteration returns a key and the key is used to access the value of the key.

For example –

const person = {fname: “John”, age = 22, subject=”Maths”};

for ( let x in person ){

while loop

Syntax –

while (condition) {

//code block


While loop runs through a block of code unless the given condition is true.

For example –

let i=0;
while (i<10);{


Classes can be defined as special functions which are template for creating objects. Their main purpose is to encapsulate data with some code, to work on that data.

Classes have syntax. There are two main components of a class syntax – class expressions and class declaration. Let us look at them in brief.

Class declaration

There are two ways of declaring a class. One way is by using class keyword with the name of the class.

Syntax –

class class_name {

//code block


Example –

class square {
	constructor (side) {
	this.side = side;

Class Expressions

A class expression is another way of defining a class. A class can be named or unnamed via this method.

Syntax –

let variable_name = class {

//code block


console.log( // to access the unnamed class here.

Example –

let square = class {
    constructor (side){
        this.side = side;
//Output = square

Classes are a huge topic. To know more in depth, you can refer to -

Let us also try to understand about the this keyword.

The this keyword refers to an object. It refers to different objects on how it is used in the code


An example of this is shown in the above code example of classes. To know more about it, refer to -


Functions are the fundamental building blocks of a programming language. They are a set of statements which are designed to perform a particular task. It must be defined in the scope where we wish to call it.

Syntax -

function name ( parameter1, parameter2, parameter3 ){

//code to be executed


When JavaScript reaches at the return keyword, the function stops executing. The return value is returned to the caller.

Functions are invoked using () operator.

Example –

function productOf( a, b ){
    return a*b;
let num1=5;
let num2=10;

let result = productOf( num1 , num2 ); // calling function productOf()

//Output - 50


Arrow functions are alternative to traditional function expression. They allow us to write shorter code for functions.

Let us see code for traditional functions and arrow functions separately to understand them better.

Traditional method :

function product ( parameter1, parameter2 ) {
    return parameter1 * parameter2 ;
let result = product( 10 , 2 );
console.log ( result );

Using Arrow Function :

product = ( parameter1, parameter2 ) => {
return parameter1 * parameter2;
console.log( product );


Scopes can be defined as the current context of code execution, where a certain value is accessible. In short, we can say that scopes determine the accessibility of a variable or an expression.

There are mainly four types of scopes in JavaScript. They are –

  • Block Scope

  • Global Scope

  • Function Scope

  • Module Scope

Block Scope – Block scope is usually a block statement used to group some statements. These are created with curly braces that contain statements or declarations.

They only scope let and const declarations. var declarations are not scoped here.

Syntax –


Statement list


Example –

var x = 1;
    var x = 2;
console.log(x); // Output = 2 as, var declarations are not scoped

let z = 1;
    let z = 2;
    console.log(z) //Output - 2
console.log(z) // Output = 1;

Function Scope – These are the scopes which are only accessible within a function. A function creates a scope so that its variables cannot be accessed from outside the function.

Example –

const x = "Outside function";

function myFunction() {
	const x = "Inside function";

Global Scope – These are the default scopes for all the code running.

Module Scope – These are the scopes for code running in module mode.

Hope you got an idea of all the concepts discussed above. JavaScript is a vast language. Practice is the key to understanding it perfectly.

Thank you.

34 views0 comments

Recent Posts

See All
Graphic Cubes

Subscribe To Get Latest Updates

Subscribe to our newsletter • Don’t miss out!

Thanks for subscribing!

bottom of page