JavaScript

Hoisting

• Hoisting is a JavaScript behavior where variable and function declarations are moved (conceptually) to the top of their scope before the code runs.

• This means we can sometimes use a variable or function before it is declared — but what gets hoisted and how depends on whether it’s var, let, const, or a function.

Why does hoisting exist?

• JavaScript engine makes two passes:

  • Compilation phase → sets up scopes, hoists declarations

  • Execution phase → runs code top-down

• This design helps make functions available throughout their scope.

Strict Mode

• It removes the silent errors from the code, such as you can't use the variable without declaration, you can't modify the readable property of the object, etc.

• To enble strcit mode, write the following literal expression to the top of the code −

'use strict';

• It can enabled globally or locally

Primitive Data Types:

Number

let a = 42;

let b = 3.14;

let c = Infinity;

let d = NaN; // Not a Number (still a number!)

BigInt: A special numeric type for very large integers beyond Number limits

let big = 123456789012345678901234567890n;

• Used for high-precision integer operations.

String: Text enclosed in " ", ' ', or backticks `, which allow interpolation

let s = "Hello";

let name = 'User';

let msg = `Hi ${name}`;

• Strings are immutable.

Boolean

let isReady = true;

let flag = false;

Undefined: "a variable has been declared but not assigned."

let x;

console.log(x); // ReferenceError: undefined

• Also the default value of missing function parameters

Null: Intentional absence of a value

let x = null;

Symbol: Unique identifier values used for special keys (cannot be duplicated).

let id = Symbol("id");

• • Often used in libraries/frameworks to create hidden object properties.

Non-Primitive Type: Object (includes Arrays, Functions, Dates, custom objects, etc.)

Object literal

let obj = { name: "Alice" };

Array

let arr = [1, 2, 3];

Function = Objects with a callable behavior.

function foo() {}

Date

let now = new Date();

RegExp

let pattern = /abc/;

Map

let m = new Map();

Set

let s = new Set();

WeakMap, WeakSet

• Used for special memory-optimized references.

ArrayBuffer, TypedArray

• Used for raw binary data.

Custom classes

class Person {}

Implicit Type Conversion (Coercion)

To String:

"100" + 24;    // Converts 24 to string

'100' + false; // Converts false boolean value to string

"100" + null;  // Converts null keyword to string

To Number:

'100' / 50;     // Converts '100' to 100

'100' - '50';   // Converts '100' and '50' to 100 and 50

'100' * true;   // Converts true to 1

'100' - false;  // Converts false to 0

'tp' / 50       // converts 'tp' to NaN

Explicit Type Conversion (Type Casting)

To String:

String(100);   // number to string

String(null);  // null to string

String(true);  // boolean to string

To Number:

Number('100'); // Converts '100' to 100

Number(false); // Converts false to 0

Number(null);  // Converts null to 0

num = +"200";  // Using the unary operator

• parseFloat(): To extract the floating point number from the string

• parseInt(): To extract the integer from the string

Operators

typeof: A built-in JavaScript operator that returns a string describing the type of the value

• Syntax:

typeof value

typeof (value)

Nullish Coalescing Operator

• Syntax: op1 ?? op2 → returns the op2 if op1 is null or undefined.

let x = null;

let y = x ?? 5;  // y = 5;

Safe Assignment Operator

• Syntax: variable ?= value; → if variable is null , it'll be assigned to value.

let username = null;

username ?= "Guest"; // username = "Guest"

delete: deletes/ removes a property from an object

• It removes the property as well as value of the property from the object. It works only with the objects NOT with the variables or functions.

• Deleting Object Property:

const obj = {

      product: "Mobile",

      price: 20000

   }  

delete obj.color;

• Deleting Array Element:

const arr = [10, 20, 30, 40, 50];

delete arr[1]; // deleting 2nd element from array

Comma Operator

• Syntax: var answer = (exp1, exp2, ...);

• Evaluate multiple expressions from left to right, and returns resultant value of the last expression only.

let a = 5;

let ans = (a = 8, a++, a += 2); // ans = 11

let lang = ("JavaScript", "Python", "HTML"); // lang = "HTML"

yield and Generator function

• When a generator function is called, it returns a generator object.

• next() method of this object → it resumes the execution, and pauses at the yield and returns the expression of the yield.

function* test() {

    yield 20;

    yield [1,2,3];

    yield "Hello World";

}

let res = test();

res.next();  // { value: 20, done: false }

res.next();  // { value: [ 1, 2, 3 ], done: false }

res.next();  // { value: 'Hello World', done: false }

res.next();  // { value: undefined, done: true }

Spread Operator (...): Allows to spread out elements of an iterable such as an array

let x = ["Hello", "World"];

console.log(x);    // [ 'Hello', 'World' ]

console.log(...x); // Hello World

• Spread operator to concatenate the arrays:

const nums1 = [1, 2, 0];

const nums2 = [4, 5, 6];

const res = [...nums1, ...nums2];