let   x = 10;          // reassignable
const y = 20;          // constant — prefer this
// var z;               ← avoid! (function-scoped)

let name  = 'Alice';    // string
let age   = 25;         // number (int+float same type)
let ok    = true;       // boolean
let empty = null;       // intentionally empty
let undef;              // undefined (never assigned)
let big   = 9007n;      // BigInt
let sym   = Symbol('id'); // unique

typeof 'hi'    // 'string'
typeof 42     // 'number'
typeof null   // 'object'  ← historic JS bug!

function greet(name) {
  return `Hello ${name}`;
}

// Arrow — shorter, inherits outer `this`
const add    = (a, b) => a + b;
const square = n => n * n;
const hi     = () => 'hi';

// Default parameter
const welcome = (name = 'World') =>
  `Welcome, ${name}`;

// Rest — collects remaining args into array
const sum = (...nums) =>
  nums.reduce((a, b) => a + b, 0);
sum(1, 2, 3); // → 6

const arr = [1, 2, 3, 4];

// Mutating (changes original):
arr.push(5)         // add end → [1,2,3,4,5]
arr.pop()          // remove last
arr.unshift(0)      // add front
arr.splice(1,1)    // remove 1 item at index 1
arr.sort((a,b)=>a-b) // numeric sort — always pass fn!

// Non-mutating (returns new array):
arr.map(x => x * 2)      // [2,4,6,8]
arr.filter(x => x > 2)    // [3,4]
arr.slice(1, 3)          // [2,3]

// Returns a single value:
arr.reduce((acc,x)=>acc+x, 0) // 10
arr.find(x => x > 2)          // 3
arr.includes(2)               // true
arr.some(x => x > 3)          // true
arr.every(x => x > 0)          // true

const user = { name: 'Alice', age: 25 };

user.name;        // dot access
user['age'];     // bracket (dynamic key)

// Destructuring — unpack multiple at once
const { name, age } = user;
const { name: n, age = 18 } = user;
//              ↑ rename   ↑ default

// Spread — copy + override (immutable update)
const updated = { ...user, age: 26 };

// Shorthand — when key = variable name
const city = 'Jakarta';
const obj = { name, city }; // same as name:name

Object.keys(user)    // ['name','age']
Object.values(user)  // ['Alice',25]
Object.entries(user) // [['name','Alice'],['age',25]]

async function getUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`);
    if (!res.ok) throw new Error(res.status);
    return await res.json();
  } catch (err) {
    console.error('Failed:', err);
  }
}

// Parallel requests — much faster!
const [users, posts] = await Promise.all([
  fetch('/api/users').then(r => r.json()),
  fetch('/api/posts').then(r => r.json()),
]);

// allSettled — gets results even if some fail
const results = await Promise.allSettled([p1, p2]);

// Custom delay
const delay = ms => new Promise(
  res => setTimeout(res, ms));
await delay(1000); // pause 1s

// Ternary — inline if/else
const label = age >= 18 ? 'adult' : 'minor';

// ?? — fallback for null/undefined ONLY
const val = input ?? 'default';
// 0, '', false still pass through!

// ?. — safe property access chain
const city = user?.address?.city;
const r    = fn?.();   // call only if fn exists

// Loops
for (const item of arr)  {} // values
for (const key  in obj)  {} // keys
arr.forEach((v, i) => {}) // can't break early

// Short-circuit
isAdmin && showPanel(); // right runs only if left truthy
val || 'fallback';     // right if left is ANY falsy
val ?? 'fallback';     // right only if null/undefined

class Animal {
  #sound = '...';    // private field
  static count = 0;   // class-level
  constructor(name) {
    this.name = name;
    Animal.count++;
  }
  speak() { return this.#sound; }
}
class Dog extends Animal {
  speak() { return 'Woof!'; }
}

// Closure — function remembers its birthplace
function makeCounter() {
  let n = 0;
  return () => ++n; // closes over n
}
const c = makeCounter(); c(); // 1  c(); // 2

// ES Modules
export const PI = 3.14;           // named
export default function main() {}    // default
import main, { PI } from './mod';

try {
  const d = JSON.parse(badStr);
} catch (err) {
  if (err instanceof SyntaxError) {
    console.error('Bad JSON');
  } else throw err; // re-throw unknown!
} finally {
  // always runs — cleanup here
}

// Custom error class
class AppError extends Error {
  constructor(msg, statusCode = 500) {
    super(msg);
    this.statusCode = statusCode;
    this.name = 'AppError';
  }
}
throw new AppError('Not found', 404);

// Safe JSON parse helper
const safeJSON = (str, fallback = null) => {
  try { return JSON.parse(str); }
  catch { return fallback; }
};