JavaScript

Notes repo. for JavaScript tutorial.

Content

In JavaScript, scope means where in your code a variable or function can be accessed.

---

1. Global Scope

• Declared outside of any block/function → accessible anywhere.

let name = "Abhigyan"; // global
console.log(name); // ✅ accessible here

function greet() {
    console.log(name); // ✅ accessible inside functions too
}

---

2. Function Scope

• Variables declared inside a function (var, let, const) are only accessible in that function.

function test() {
    let x = 10;
    console.log(x); // ✅ works
}
console.log(x); // ❌ Error: x is not defined

---

3. Block Scope

• Variables declared with let or const inside {} are only accessible inside that block.

if (true) {
    let y = 5;
    console.log(y); // ✅ works here
}
console.log(y); // ❌ Error: y is not defined

var ignores block scope and leaks outside the block (old JS behavior).

---

4. Lexical Scope

• Inner functions can access variables from their outer functions.

function outer() {
    let a = "Outer Var";
    function inner() {
        console.log(a); // ✅ can access outer variable
    }
    inner();
}
outer();

---

Data Types

JavaScript has 8 main data types — split into primitive and non-primitive.

In JavaScript, primitive and non-primitive (reference) types are categorized based on how the data is stored and accessed in memory.

• Primitive types → Stored directly in the stack as a single value.
• Non-primitive types → Store a reference (address) to the object in the heap.

That’s why primitives are copied by value, while non-primitives are copied by reference.

Primitive Type (immutable, stored directly)

1. String – text data

   let name = "Abhigyan";
   

2. Number – integers & decimals (no separate int/float)

   let age = 20;
   

3. Boolean – true or false

   let isStudent = true;
   

4. Undefined – declared but not assigned

   let city;
   

5. Null – intentional empty value, also a standalone value.

   let price = null;
   

6. Symbol – unique identifier, used for uniqueness

   let id = Symbol("id");
   

7. BigInt – large integers beyond Number limits

   let bigNum = 123456789012345678901234567890n;
   

---

Non-Primitive Type (Reference Type)

8. Object – collections of key–value pairs, arrays, functions, etc.

   let user = { name: "Abhigyan", age: 20 };
   

In JavaScript, reference data types (non-primitives) store a memory reference to the actual data in the heap.

Main reference types:

• Object
• Array
• Function
• Date
• RegExp
• Map, Set, WeakMap, WeakSet
• Any custom object you create

Key points:

• Copied by reference, not by value.
• Comparing two different references with === is false, even if they have the same content.

Example:

let a = { name: "Abhigyan" };
let b = a;
b.name = "Alex";

console.log(a.name); // "Alex" (because a and b reference same object)

Note -> JavaScript is dynamically typed.

That means you don’t need to declare the data type of a variable; the type is determined at runtime based on the value assigned, and it can change later.

Example:

let x = 5;      // number
x = "Hello";    // now a string

---

Memory

In JavaScript (and most programming languages), stack and heap are two different areas of memory with different purposes:

---

1. Stack 🗂️

• Stores primitive values (string, number, boolean, null, undefined, symbol, bigint).
• Fixed size, fast access.
• Data is stored by value (copy is created).
• Variables in the stack are removed automatically when they go out of scope.

Example (code):

let youtubename = "AbhigyanLabs"; // stored directly in stack
let anothername = youtubename;    // a copy is made
anothername = "Tech Incarnate";   // only this copy changes

console.log(youtubename); // "AbhigyanLabs"
console.log(anothername); // "Tech Incarnate"

---

2. Heap 📦

• Stores non-primitive values (object, array, function, etc.).
• Dynamic size, slower access than stack.
• Data is stored by reference (stack holds a pointer to the object in heap).
• Changing one reference affects all variables pointing to that object.

Example (code):

let userOne = {
    email: "abhigyan@google.com",
    age: 22
};

let userTwo = userOne; // both point to same heap object
userTwo.email = "vidyanshu@google.com"; // changes the shared object

console.log(userOne.email); // "vidyanshu@google.com"
console.log(userTwo.email); // "vidyanshu@google.com"

---

✅ Quick Summary

Feature	Stack	Heap
Stores	Primitives	Objects & functions
Access speed	Fast	Slower
Storage type	Value	Reference
Size	Fixed	Dynamic

Comparisons

JS Comparison vs Equality

• Comparison (<, >, <=, >=) → Converts to numbers

  • null → 0
  • undefined → NaN (always false)

• Loose equality (==) → Type conversion

  • null == undefined → true
  • Else, null only equals itself

• Strict equality (===) → No conversion

  • Types must match exactly

=== in JavaScript is strict equality → compares value + type without type conversion.

In modern JavaScript, template literals (${}) are preferred over string concatenation with +.

Example:

// Using +
let name = "Abhigyan";
let greeting = "Hello, " + name + "!";
console.log(greeting); // Hello, Abhigyan!

// Using template literal
let greeting2 = `Hello, ${name}!`;
console.log(greeting2); // Hello, Abhigyan!

Why ${} is better:

• Cleaner and more readable for multiple variables.
• Supports multi-line strings easily.
• Reduces errors from missing spaces or quotes.

In short: always prefer `${}` over + concatenation in modern JS.

---

🔢 Numbers

• JavaScript has only one numeric type:
• Number.MAX_VALUE → largest positive number (~1.79e308)
• Number.MIN_VALUE → smallest positive number (>0, ~5e-324)
• Number.MAX_SAFE_INTEGER → 9007199254740991
• Number.MIN_SAFE_INTEGER → -9007199254740991
• Number.isNaN(value) → checks if value is NaN (better than isNaN() global).
• Number.isFinite(value) → checks if value is a finite number.
• parseInt("42") → converts string to integer.
• parseFloat("42.5") → converts string to floating number.
• toFixed(n) → formats number to n decimal places (returns string).

---

📐 Math object

• Math.PI → 3.141592653589793

• Math.abs(x) → absolute value.

• Math.round(x) → rounds to nearest integer.

• Math.ceil(x) → rounds up.

• Math.floor(x) → rounds down.

• Math.trunc(x) → removes decimal without rounding.

• Math.sqrt(x) → square root.

• Math.pow(a, b) → a raised to power b (a ** b is shorter).

• Math.random() → random number 0 ≤ x < 1.

• Random in range:

  Math.floor(Math.random() * (max - min + 1)) + min
  

• Math.min(...values) / Math.max(...values) → smallest/largest value.

• Math.sign(x) → returns 1, -1, or 0 depending on sign of x.

---

💡 Tip: Avoid direct equality checks with floating-point numbers (0.1 + 0.2 === 0.3 → false). Use a small tolerance:

Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON

📌 Math & Number in JavaScript

🔢 Number Constants

• Number.MAX_VALUE → Largest positive number JS can represent.
• Number.MIN_VALUE → Smallest positive number (closest to 0).
• Number.MAX_SAFE_INTEGER → Largest integer that can be represented safely (2^53 - 1).
• Number.MIN_SAFE_INTEGER → Smallest safe integer (-(2^53 - 1)).
• Number.EPSILON → Smallest difference between two representable numbers.

---

🧮 Parsing & Conversion

• parseInt("42") → Converts string to integer (42).
• parseFloat("42.5") → Converts string to floating number (42.5).
• Number(value) → Converts any value to number.
• value.toFixed(n) → Formats number with n decimal places.

---

📐 Rounding

• Math.round(x) → Rounds to nearest integer.
• Math.ceil(x) → Rounds up.
• Math.floor(x) → Rounds down.
• Math.trunc(x) → Removes decimal part.

---

🎲 Random

• Math.random() → Returns a pseudo-random number 0 ≤ x < 1.

• Range Formula:

  Math.floor(Math.random() * (max - min + 1)) + min
  

  → Random integer between min and max (inclusive).

---

📊 Powers & Roots

• Math.pow(a, b) / a ** b → Exponentiation.
• Math.sqrt(x) → Square root.
• Math.cbrt(x) → Cube root.

---

📏 Comparison

• Math.min(...values) → Smallest value.
• Math.max(...values) → Largest value.
• Math.sign(x) → Returns -1, 0, or 1 depending on sign.
• Number.isFinite(x) → Checks if value is finite.
• Number.isNaN(x) → Checks if value is NaN.

---

💡 Tip

• Floating-point precision check:

  Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON
  // true
  

Dates

JavaScript Date Methods Quick Reference

Date is an object For rest refer to code file. It has commented and explained content.

JavaScript Arrays – Quick Notes

• Shallow Copy: Changes in nested objects/arrays of the copy also affect the original. Only top-level changes are independent.

• Deep Copy: Changes in the copy do NOT affect the original, even for nested objects/arrays.

Slice & Splice

slice() → returns a new array, original unchanged. splice() → changes the original array (remove/add elements).

Example:

let arr = [1,2,3,4];
arr.slice(1,3); // [2,3], arr unchanged
arr.splice(1,2); // removes 2 & 3, arr = [1,4]

---

1. Array Basics

• Can store mixed datatypes.
• Two ways to create:

const arr1 = [1, 2, 3];
const arr2 = new Array(4, 5, 6);

• Access elements: arr[0], arr[1]…

---

2. Adding/Removing Elements

Method	Description
push()	Add element at end
pop()	Remove element from end
unshift()	Add element at start
shift()	Remove element from start

---

3. Slice & Splice

• slice(start, end) → returns new array, original unchanged.
• splice(start, deleteCount, …items) → modifies original array.

let arr = [1,2,3,4];
arr.slice(1,3); // [2,3], original unchanged
arr.splice(1,2); // removes 2 & 3, arr = [1,4]

---

4. Combining Arrays

• concat() → combines arrays without changing originals.
• Spread operator (...) → combine multiple arrays easily.

const combined = [...arr1, ...arr2];

---

5. Nested Arrays

• flat(depth) → flattens nested arrays to specified depth.

let arr = [1,[2,3,[4]]];
arr.flat(2); // [1,2,3,4]

---

6. Array Utilities

Method	Description
Array.isArray()	Check if a value is an array
Array.from()	Convert iterable (string, etc.) to array
Array.of()	Create array from arguments

Array.from("Hello"); // ['H','e','l','l','o']
Array.of(1,2,3);    // [1,2,3]

---

✅ Tips

• Use slice for safe copies.
• Use splice for editing original array.
• Spread operator ... is handy for combining arrays.
• Use flat() for nested arrays