📘 JavaScript DSA Series - Fundamentals

📦 Variables & Constants

• Variable: A variable is like a container that stores a value. This value can change (or vary) as the program runs.

  let name = "Alice";

• Constant: A constant is similar to a variable, but once assigned a value, it cannot be changed.

  const PI = 3.14;

• const Keyword: Declares a constant whose value can't be reassigned.

🌳 Data Types in JavaScript

JavaScript variables can hold different types of data. These types are categorized into Primitive and Non-Primitive (Reference types).

🧩 Data Types Tree Structure

Data Types
├── Primitive
│   ├── Number
│   ├── String
│   ├── Boolean
│   ├── Null
│   ├── Undefined
│   ├── Symbol
│   └── BigInt
└── Non-Primitive (Reference)
    ├── Linear
    │   ├── Array
    │   └── Linked List (user-defined)
    └── Non-Linear
        ├── Tree (user-defined)
        └── Graph (user-defined)

🔹 Primitive Data Types

🔸 Non-Primitive (Reference) Data Types

🔹 Linear Data Structures

1. Array

• Stores elements in contiguous memory locations.
• Elements can be accessed via index.
• Best for random access.
• Dynamic in size in JS.

let arr = [10, 20, 30];
console.log(arr[1]); // 20

2. Linked List

• Consists of nodes, where each node contains data and a reference (pointer) to the next node.
• Does not store data in contiguous memory.
• Useful for dynamic insertions and deletions.

// Example representation
let node = {
  data: 10,
  next: {
    data: 20,
    next: null
  }
};

🔹 Non-Linear Data Structures

1. Tree

• A hierarchical structure where each node can have multiple children.
• Common types: Binary Tree, Binary Search Tree (BST).
• Useful in representing the DOM, folder structures, etc.

2. Graph

• A set of nodes (vertices) connected by edges.
• Can be directed/undirected, cyclic/acyclic.
• Used in routing algorithms, social networks, etc.

⚠️ Note: Tree and Graph are implemented manually in JS using objects/classes.

Operators vs Operands in JavaScript

In JavaScript, operators and operands are fundamental building blocks for performing operations. Understanding them is crucial for writing effective code.

What is an Operator?

An operator is a symbol that performs an operation on one or more operands.

let result = 10 + 5;
// Here, '+' is the operator (performs addition)

What is an Operand?

An operand is the value or variable on which the operator acts.

let result = 10 + 5;
// Here, '10' and '5' are operands

📚 Types of Operators

1️⃣ By Number of Operands

🔸 Unary Operators

• Work on a single operand
• Examples: -x, ++x, !x

let x = 5;
let y = -x;  // Unary minus
let z = !x;  // Logical NOT

🔸 Binary Operators

• Work on two operands
• Most common type

let sum = a + b;  // Addition operator
let product = x * y;  // Multiplication operator

🔸 Ternary Operator

• Works on three operands
• Used as a shorthand for if-else

let result = (age >= 18) ? "Adult" : "Minor";

2️⃣ By Operation Type

🔸 Arithmetic Operators

🔸 Comparison Operators

🔸 Logical Operators

🔸 Assignment Operators

🔸 Increment & Decrement

// Prefix vs Postfix
let x = 5;
let y = x++;  // y = 5, x = 6
let z = ++x;  // x = 7, z = 7

🔸 Bitwise Operators

🎓 Best Practices

1. Operator Precedence

   • Use parentheses to make operations clear
   • Don't rely on default operator precedence

   let result = (a + b) * c;  // Clear intention

2. Type Coercion

   • Use strict equality (===) over loose equality (==)
   • Be explicit about type conversions

   let num = Number("123");  // Explicit conversion

3. Short-Circuit Evaluation

   • Use && and || for conditional execution

   const name = user && user.name;  // Safe property access
   const defaultName = userName || "Guest";  // Default value

📝 Examples

Practical Usage

// Combining multiple operators
let score = 85;
let passing = 60;
let excellent = 90;
let result = score >= passing ? (score >= excellent ? "Excellent!" : "Pass") : "Fail";
 
// Short-circuit evaluation
function getUser(id) {
    const user = findUser(id);
    return user && user.isActive && user.name;
}
 
// Chaining assignments
let a, b, c;
a = b = c = 5;  // All variables get value 5

⚠️ Common Pitfalls

1. Unintended Type Coercion

   // Avoid
   if (5 == "5") { ... }  // true
   // Prefer
   if (5 === "5") { ... }  // false

2. Post/Pre Increment/Decrement Confusion

   let x = 5;
   console.log(x++);  // Shows 5, then x becomes 6
   console.log(++x);  // x becomes 7, then shows 7

3. Operator Precedence Issues

   // Unclear
   let result = a + b * c;
   // Clear
   let result = a + (b * c);

🔤 ASCII Table (Common Characters)