JavaScript Ideas to Know Before Learning Node.js

Before Node.js got here into existence,  JavaScript may solely be run on the browser. It may solely be used as a scripting language for frontend net growth.

Then, Node.js got here to free JavaScript from this confinement. It made JavaScript ubiquitous (that means it may now be run in every single place).

Node.js is a JavaScript runtime atmosphere that enables JavaScript builders to jot down command line instruments and server aspect scripts exterior of a browser.

Learning Node.js permits JavaScript builders to jot down server aspect code and code for embedded techniques. This opens up alternatives in backend growth and {hardware} programming.

But, earlier than diving into Node.js, a JavaScript developer has to be taught and perceive some JavaScript ideas.

In this text, you’ll be taught the JavaScript ideas you should perceive earlier than studying Node.js.

Before you proceed with the article, examine the stipulations.

Prerequisites

To comply with together with this text, it’s best to have some primary data of:

• JavaScript
• The browser console (that is the place you’ll run your code).

Now that we now have these out of our approach, let’s dive into the article, beginning with expressions.

Expressions

An expression is a unit or block of code that evaluates to a price.

There are 5 primary classes of expressions in JavaScript: major expressions, arithmetic expressions, string expressions, logical expressions, and left-hand aspect expressions.

Primary expressions

Primary expressions include primary key phrases in JavaScript. A standard instance is the this key phrase:

this['item'];

this.merchandise;

Later on on this article you’ll be taught extra in regards to the this key phrase.

Arithmetic expressions

An arithmetic operator takes numerical values as its operands and returns a numerical worth. The operands and the operator make up the arithmetic expression:

2 + 3;

2 * 3;

2 ** 3;

String expressions

When strings are concatenated they type string expressions:

console.log('My identify is' + 'Peter');

Logical expressions

Logical expressions are expressions through which varied values are in contrast:

10 > 2;
2 < 10;
c === 2 || d === 10;

Left-hand aspect expressions

Left-hand aspect expressions are expressions the place values are assigned to a variable:

// variables
a = 2;

// object properties
obj = {};
obj.identify="Paul";

Data Types

There are 8 information varieties in JavaScript: String, Number, Boolean, Object, Null, Undefined, Symbol, and LargeInt.

String

The string sort represents textual information. A string is surrounded by a single quote or a double quote.

Each component in a string occupies a sure place within the string. The first component is at index 0, and the second and third are at index 1 and a couple of respectively.

Here is an instance of a string:

let identify="Yusuf";
let newName = "Joseph";

Number

The quantity varieties are saved in 64-bit format, often known as double-precision floating level numbers.

They include numbers which are throughout the vary of -(2⁵³ – 1) and (2⁵³ – 1), with each of those numbers inclusive. These two numbers are often called the MIN_SAFE_INTEGER and the MAX_SAFE_INTEGER respectively.

Numbers that exceed this vary, belong to a different information sort known as LargeInt.

Here is an instance of  a optimistic integer, a float and a detrimental integer:

let quantity = 15;
let one otherNumber = 1.5;
let finalNumber = -3;

Boolean

The boolean sort is logical, and it has solely two values: true or false. It is often utilized in loops and conditional statements.

In the instance beneath, I declared variables and assigned them a price of true and false respectively.

Then, I created a conditional assertion that returns 1 if the bool variable is true or -1 whether it is false. It returns zero whether it is neither true nor false.

let optimistic = true;
let detrimental = false;
let bool = false;

// conditional assertion
if (bool) {
    return 1;
} else if (bool) {
    return -1;
} else {
    return 0;
}

Object

An object sort lets you retailer collections of information. The information are saved in a pair of curly braces and a key-value pair format. Object keys should be textual (for instance a string).

An object can retailer any of the opposite information varieties, like string, quantity, arrays, booleans, and so forth.

In the instance beneath I created an object named myObject, and gave it three keys with their corresponding values:

let myObject = {
    identify: "Gabriel",
    quantity: 15,
    developer: [true, "Daniel", 1]
}

Null

Null information varieties are particular information varieties. They have the worth null which signifies that the worth is unknown or empty:

let unknown = null;

Undefined

Unlike null, undefined signifies that a variable is said and never assigned a price. A variable may also be assigned undefined particularly:

let identify = undefined;

let newName;
console.log(newName);

Symbol

Symbols are used to create distinctive values. They are created by calling the Symbol() operate. Every time the Symbol() operate is invoked it creates a brand new distinctive worth.

Symbols are stored hidden or personal they usually can solely be used internally. For occasion, they can be utilized as keys in an object. When you attempt to get the checklist of keys in an object the place a logo is a part of its keys the image key won’t be displayed.

You can go a parameter to the image operate to function an outline for the image when debugging it within the console:

let firstSymbol = Symbol();

let one otherSymbol = Symbol(one otherSymbol);

LargeInt

LargeInt is a particular sort of quantity that gives help for numbers with a size {that a} regular quantity sort can’t maintain (akin to numbers that exceed the secure integer restrict).

It will be created by appending n to the tip of an integer or passing a quantity into the LargeInt operate:

let largeNumber = 175337823472347884278247898427427427642n;
let newBigNumber = LargeInt(1624743724724724898718247248744774227422n);

let anotherBigNumber = LargeInt(14);

Classes

A JavaScript class is a template for creating objects. It accommodates information and features that manipulate information.

Classes had been launched to JavaScript within the ECMAScript 2015 (ES6) model of JavaScript.

The features utilized in courses are known as strategies.

There is a primary syntax for declaring courses appears to be like one thing just like the next:

class TemplateClass {
    constructor() {...};
    technique() {...};
    technique() {...};
}

From the syntax you may create a category named Visitor:

class Visitor {
    constructor(identify) {
        this.identify = identify;
    }
    introduce() {
        console.log(`My identify is ${this.identify} and I'm a customer`)
    }
}

You can create a brand new class from this class by utilizing the brand new class syntax. The newly created class can entry any technique from its mum or dad class:

let customer = new Visitor("Jeff");

// customer can name the introduce technique in its mum or dad class.
customer.introduce();

Variables

A variable is a named storage for JavaScript information. JavaScript variables will be declared in 3 ways:

• Using the var key phrase
• Using the  let key phrase
• Using the const key phrase

How to declare variables utilizing the var key phrase

Variables declared with the var key phrase are operate scoped and they are often redeclared:

var num = 1;

// num will be redeclared
var num = 2;

How to declare variables utilizing the let key phrase

Variables declared with the let key phrase are block scoped they usually can’t be redeclared – they will solely be reassigned:

let fruit = "banana";

// fruit can solely be reassigned
fruit = "orange";

How to declare variables utilizing the const key phrase

Variables declared with the const key phrase are block scoped they usually can’t not be redeclared or reassigned (that means they’re fixed):

const bestStudent = "Daniel";

Functions

A operate is a block of code that performs a selected activity. It will be declared utilizing the operate key phrase:

operate doSomething() {
    return "Does Something";
}

A operate takes inputs known as arguments and outputs outcomes.

To execute a operate you’ll invoke the operate by calling the operate identify with enclosed brackets:

operate addNumbers(a, b) {
    return a + b;
}

addNumbers();

You can assign a operate to a variable and name the variable if you wish to invoke the operate:

operate addNumbers(a, b) {
    return a + b;
}

let numberAddition = addNumbers(2, 3)
numberAddition();

Arrow Functions

Arrow features are a concise and compact approach to write a operate. They have some deliberate limitations of their utilization:

• They can’t be used as a way.
• They can’t be used as a constructor.
• Arrow features can’t use yield inside their very own our bodies.

Below is the syntax for an arrow operate:

const doSomething = () => {
    return "Do one thing";
}

An arrow functoion may take an argument.

const multiplyNumbers = (a, b) => {
    return a * b;
}

this key phrase

The this key phrase in JavaScript refers to to an object that’s executing a operate or a code.

The this key phrase can be utilized in numerous contexts – the context through which the this key phrase is used determines what it refers to.

The this key phrase can be utilized:

• In an object technique.
• Alone.
• In object technique bindings.

How to make use of the this key phrase in an object technique

The this key phrase refers back to the object each time it’s used as an object technique:

intro : operate() {
    return "My identify is" + this.identify "and, I'm a" + this.occupation;
}

How to make use of the this key phrase alone

When this is used alone it refers back to the international object:

let wes = this;

How to make use of the this key phrase in object technique bindings

When this is utilized in an object technique, it refers back to the object:

let scholar = {
  firstName  : "Juliana",
  lastName   : "Carpe",
  myFunction : operate() {
    return this;
  }
};

Loops

Loops are helpful for executing a block of code for a specified variety of instances based mostly on some specified circumstances. There are several types of loops in JavaScript:

• for loops
• for ... in loops
• for ... of loops
• whereas loops
• do ... whereas loops  

How to make use of for loops

for loops are used to execute a block of code quite a few instances:

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

How to make use of for ... in loops

for ... in loops are used to loop by way of the properties of an object:

for (let prop in obj) {
    return obj.prop;
}

How to make use of for ... of loops

for ... of loops are used to loop by way of the values of iterable objects like arrays, strings, maps, and so forth:

let numArr = [2, 4, 6, 8]
for (let val of numArr) {
    return val ** 2
}

How to make use of whereas loops

whereas loops are used to excute a block of code whereas a sure situation nonetheless holds true:

whereas (i < 20) {
    return i;
    i++;
}

How to make use of do ... whereas loops

do ... whereas loops execute a block of code first with none circumstances. For so long as a sure situation nonetheless holds true it continues to execute the block of code:

let i = 3;
do {
    return i;
    i++;
} 
whereas (i < 4)

Scopes

The scope is the present context of execution. It is the place variables and expressions will be accessed.

There is an hierarchical association of scope in JavaScript. This makes  it doable for decrease scopes to entry increased scopes.

The scopes in JavaScript are:

• Global scope
• Module scope
• Function scope
• Block scope

The international scope is the default scope for all codes operating in script mode whereas the module scope is the default scope for all codes operating in module mode.

The operate scope is created by features whereas the block scope is created by variables.

Here is an instance of operate and block scope:

// operate scope
operate introduce(identify) {
    let age = 12;
    console.log(`My identify is ${identify}`);
    console.log(`I'm ${age} years outdated`);
}

let firstAge = 13

// block scope
if (firstAge === 13) {
    let secondAge = 20;
    console.log(`I'm ${secondAge} years outdated`);
}

Arrays

An array is a particular sort of an object that shops information in an ordered type.

Arrays will be declared in two methods:

• Using sq. brackets.
• Using the the Array() constructor.

How to declare arrays utilizing sq. brackets

This is the frequent approach of making an array. It is completed by wrapping the array’s objects in a pair of sq. brackets:

  let array = [1, 3, "a", "c"];

How to declare arrays utilizing the the Array() constructor

The Array() constructor does the identical factor because the bracket notation. It will be known as with or with out the new key phrase:

  let one otherArray = Array(1, 2, 3, "go");

How to entry array components

Array components will be accessed in 3 ways:

• utilizing their index.
• utilizing the array’s size property.
• utilizing a loop

How to entry an array component utilizing its index

You name the identify of the array with a sq. bracket containing the index you wish to entry:

 let newArray = ["Idris", "Daniel", "Joseph"];

  // To entry first component
  let firstElement = newArray[0]; 
  console.log(firstElement);  // Idris

  // To entry second component 
  let secondElement = newArray[1];  
  console.log(secondElement);  // Joseph

How to entry an array component utilizing the array’s size property

You can get the size of the array utilizing the size property. Then, you’ll subtract any quantity from it to get the index of the component you wish to entry:

let newArray = ["Idris", "Daniel", "Joseph"];

  let size = newArray.size;

  let firstElement = newArray[length - 3]; 
  console.log(firstElement);  // Idris

  let secondElement = newArray[length - 2];
  console.log(secondElement);  // Joseph

How to entry an array component utilizing a loop

Array components will be accessed utilizing loops. You could make use of a for loop, whereas loop, or a for ... of loop:

  let newArray = ["Idris", "Daniel", "Joseph"];
  for (let i = 0; i < newArray.size; i++) {
      return newArray[i]
  }

Important Array strategies

There are over fifteen array strategies in JavaScript. In this text, you’ll be taught those which are most helpful in Node.js:

• push() and pop()
• shift() and unshift()
• map()
• type()
• forEach()

How to make use of the push() and pop() strategies

The push() technique is used so as to add an merchandise to the tip of an array, whereas the pop() technique is used to take away an merchandise from the tip of an array:

let arr = [1, 2, 3, 9]

arr.push(21);

console.log(arr)    // [1, 2, 3, 9, 21]

arr.pop()

console.log(arr)    // [1, 2, 3, 9]

How to make use of the unshift() and shift() strategies

The unshift() technique is used so as to add an merchandise to the start of an array, whereas the shift() technique is used to take away an merchandise from the start of an array:

let arr = [1, 2, 3];

arr.unshift(0);

console.log(arr);	// [0, 1, 2, 3]

arr.shift();

connsole.log(arr);	// [1, 2, 3]

How to make use of the map() technique

The map() technique iterates by way of the weather of an array and calls a operate on every component of the array. It returns a brand new array that accommodates the results of every operate name:

let fruits = ["Apple", "Grape", "Cashew"];

let mappedFruits = fruits.map(merchandise => merchandise + "s");
console.log(mappedFruits); // ["Apples", "Grapes", "Cashews"]

How to make use of the type() technique

The type() technique kinds an array in place and returns the identical array in a sorted type.

The default order of the type() technique is ascending order. Strings are sorted in alphabetical order:

let numbers = [8, 7, 5];
let fruits = ["Apple", "Grape", "Cashew"];

let sortedNumbers = numbers.type();
let sortedFruits = fruits.type()

console.log(sortedNumbers);  // [5, 7, 8]
console.log(sortedFruits);  // ["Apple", "Cashew", "Grape"]

How to make use of the forEach() technique

The forEach() technique loops by way of the array and calls a operate for each component of the array:

let fruits = ["Apple", "Grape", "Cashew"];

fruits.forEach(fruit => console.log(fruit));
//  "Apple"
//  "Grape"
//  "Cashew"

Template Literals

Template literals are enclosed in backticks, identical to strings are enclosed in quotes. They permit you to retailer multiline strings and in addition interpolate strings with embedded expressions.

The instance beneath exhibits a primary template literal:

let primary = `I write codes`

You can write a template literal that shops multiline strings like this:

let multiLine = `I write codes                     
		I debug codes`;

You can use the greenback signal and curly braces to embed expressions in template literals.

In the instance beneath, the operate myName is embedded within the show variable with a template literal:

operate myName(Musab, Habeeb) {        
    alert("Musab Habeeb");    
}    

let show = `This shows my identify ${myName()}`

Strict mode

JavaScript is a sloppy language within the sense that it lets you write code that isn’t allowed in different languages. Some of the code you write in JavaScript has errors however, JavaScript doesn’t throw an error.

Strict mode does the next:

• It throws errors for JavaScript silent errors.
• It fixes errors that makes it troublesome for JavaScript engines to carry out optimizations.
• It prohibits some syntax prone to be outlined in future variations of the ECMAScript.

Strict mode works in a whole script file and features, nevertheless it doesn’t work in block scopes.

To invoke script mode you’ll add the "use strict"; syntax to the highest of the code you wish to apply it to. You can apply strict mode to a script like this:

"use strict";

let identify = "Musab";

console.log(identify);

Also, you may apply strict mode to a operate like this:

operate sayHi(identify) {
    "use strict";
    console.log(`Hi ${identify}`);
}

Conclusion

Finally, you might be achieved with studying the JavaScript ideas you should perceive earlier than studying Node.js.

All these ideas are vital ideas {that a} JavaScript Developer aspiring to be taught Node.js ought to perceive. Understanding these ideas will make studying Node.js simpler.

But, to know these ideas in depth, you are able to do extra analysis on every of them and browse different articles. Keep studying, preserve constructing.