Semicolons are optional in JavaScript, but it’s good practice to use them to avoid unexpected behavior.

Copy Codelet x = 10;  // Semicolon used
let y = 20  // Semicolon optional

JavaScript has two types of equality checks: == (loose equality) and ===(strict equality). Always prefer ===.

Copy Codeconsole.log(5 == "5");  // true (loose equality)
console.log(5 === "5"); // false (strict equality)

Functions can be declared using function, arrow functions , or as function expressions.

Copy Code// Traditional function
function add(a, b) {
    return a + b;
}

// Arrow function
const add = (a, b) => a + b;

// Function expression
const add = function(a, b) {
    return a + b;
};

JavaScript hoists variable and function declarations to the top of their scope. This can lead to unexpected behavior.

Copy Codeconsole.log(x);  // undefined (not an error)
var x = 10;

Use backticks ( ` ) for template literals to embed variables and multi-line strings.

Copy Codeconst name = "Alice";
console.log(`Hello, ${name}!`);  // Hello, Alice!

// Multi-line string
const message = `
This is a
multi-line string
`;

Promises and async/await are used to handle asynchronous operations.

Copy Code// Using Promises
const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("Done!"), 1000);
});

promise.then(result => console.log(result));  // Done!

// Using async/await
async function fetchData() {
    const result = await promise;
    console.log(result);  // Done!
}

JavaScript does not have a direct equivalent of system("cls"). Use console.clear() to clear the console.

Copy Codeconsole.clear();  // Clears the console

JavaScript uses import and export for modular code.

Copy Code// Exporting
export const add = (a, b) => a + b;

// Importing
import { add } from './math.js';

Destructuring allows you to unpack values from arrays or objects into variables.

Copy Code// Array destructuring
const [a, b] = [1, 2];

// Object destructuring
const { name, age } = { name: "Alice", age: 25 };

The spread ( ... ) operator is used to expand elements, while the rest operator is used to collect them.

Copy Code// Spread operator
const arr = [1, 2, 3];
const newArr = [...arr, 4];  // [1, 2, 3, 4]

// Rest operator
function sum(...numbers) {
    return numbers.reduce((acc, num) => acc + num, 0);
}

Copy Code// 📦 Variable declarations
let mutableVar = 10;       // Block-scoped, reassignable
const immutableVar = 20;   // Block-scoped, constant
var functionScoped = 30;   // ⚠️ Avoid (hoisting, function scope)

Copy Code// 🏷️ Primitive types
const str = "text";
const num = 42;
const bool = true;
const nullVal = null;
const undefinedVal = undefined;
const symbol = Symbol('id');

// 🧩 Reference types
const obj = {a: 1};
const arr = [1, 2, 3];
const func = () => {};

Copy Code// 🤔 Decision making
if (score > 90) {
    grade = 'A';
} else if (score > 75) {
    grade = 'B';
} else {
    grade = 'C';
}

// 🔀 Switch statement
switch(day) {
    case 1: console.log('Monday'); break;
    default: console.log('Unknown'); break;
}

Copy Code// 🔄 Iteration methods
for (let i=0; i<5; i++) { ... }
while (condition) { ... }

// 🎯 Array operations
arr.forEach(item => { ... });
const newArr = arr.map(item => item * 2);

Copy Code// 📜 Function types
function add(a, b) { return a + b; }  // Declaration
const multiply = (a, b) => a * b;      // Arrow function

// 🚀 Immediately Invoked
(() => { console.log('Running now!'); })();

Copy Code// 🎨 String formatting
const name = 'Alice';
console.log(`Hello ${name}!`);
console.log(`Multi-line
string example`);

Copy Code// 🌐 DOM interactions
const btn = document.querySelector('#submit');
const list = document.getElementById('items');

// ✏️ DOM modifications
btn.textContent = 'Click Me';
list.innerHTML = '<li>New Item</li>';

Copy Code// 🖱️ Event listeners
btn.addEventListener('click', handleClick);

// 🎯 Delegation pattern
document.body.addEventListener('click', e => {
    if (e.target.matches('.item')) {
        handleItemClick(e.target);
    }
});

Copy Code// 💾 Storage methods
localStorage.setItem('key', JSON.stringify(data));
const saved = JSON.parse(localStorage.getItem('key'));

// 🍪 Cookie handling
document.cookie = 'username=John; expires=Thu, 18 Dec 2025 12:00:00 UTC; path=/';

Copy Code// 📶 Array operations
const nums = [1, 2, 3];
nums.push(4);       // [1,2,3,4]
nums.splice(1, 1);  // Remove at index 1
const sum = nums.reduce((acc, val) => acc + val, 0);

Copy Code// 🎯 Unique collections
const unique = new Set([1, 2, 2, 3]); // {1,2,3}

Copy Code// 🗺️ Key-value storage
const map = new Map();
map.set('key', 'value');

Copy Code// 🕸️ Garbage-collected maps
const weakMap = new WeakMap();
const objKey = {};
weakMap.set(objKey, 'private data');

Copy Code// 🏗️ Class structure
class Person {
    #privateField;  // 🔒 Private field
    
    constructor(name) {
        this.name = name;
        this.#privateField = 'secret';
    }
    
    static species = 'Homo sapiens';  // 🧳 Static property
    
    greet() {
        console.log(`Hello ${this.name}`);
    }
}

Copy Code// 🧬 Prototypal inheritance
function Animal(name) {
    this.name = name;
}
Animal.prototype.speak = function() { ... };

class Dog extends Animal {
    bark() { ... }
}

Copy Code// 🔗 Binding context
const boundFunc = obj.method.bind(obj);
boundFunc.call(context);
boundFunc.apply(context, args);

Copy Code// ⏳ Promise chain
fetch('url')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error(error))
    .finally(() => cleanup());

Copy Code// 🕒 Async operations
async function fetchData() {
    try {
        const res = await fetch('url');
        return await res.json();
    } catch (err) {
        handleError(err);
    }
}

Copy Code// 🚨 Error handling
try {
    riskyOperation();
} catch (err) {
    console.error('Caught:', err.message);
} finally {
    cleanup();
}

Copy Code// 🛠️ Custom error type
class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
    }
}