1// ❌ These all cause SyntaxError — cannot use keywords as names:
2// let let    = 5;       // SyntaxError: Unexpected strict mode reserved word
3// let const  = 5;       // SyntaxError
4// let for    = 5;       // SyntaxError
5// let if     = 5;       // SyntaxError
6// let class  = 5;       // SyntaxError
7// let return = 5;       // SyntaxError
8// let new    = 5;       // SyntaxError
9
10// ✅ But you CAN use a keyword as part of a longer name:
11let letValue    = 5;      // 'let' is part of the name — OK
12let myClass     = 'Math'; // 'class' is part of the name — OK
13let returnValue = 42;     // 'return' is part of the name — OK
14let forLoop     = true;   // 'for' is part of the name — OK
15let newUser     = 'Alice'; // 'new' is part of the name — OK
16
17console.log(letValue, myClass, returnValue, forLoop, newUser);
18
19// ✅ Keywords work fine as object property keys (not identifiers)
20const obj = {
21  if: 'this works',
22  for: 'this works too',
23  class: 'also works'
24};
25console.log(obj.if, obj.for, obj.class);

1// var — old way to declare a variable (avoid in modern code)
2var oldScore = 50;
3console.log('var:', oldScore);
4
5// let — modern variable — can be changed later
6let score = 100;
7score = 95;  // OK — let allows reassignment
8console.log('let:', score);
9
10// const — constant — cannot be reassigned
11const MAX_SCORE = 100;
12// MAX_SCORE = 200;  // ❌ TypeError
13console.log('const:', MAX_SCORE);
14
15// function — declares a function
16function greet(name) {
17  return 'Hello, ' + name + '!';
18}
19console.log(greet('Alice'));
20
21// class — declares a class (blueprint for objects)
22class Animal {
23  constructor(name) {
24    this.name = name;
25  }
26  speak() {
27    return this.name + ' makes a sound.';
28  }
29}
30const cat = new Animal('Cat');
31console.log(cat.speak());

1// if / else — run code based on a condition
2const temperature = 28;
3
4if (temperature > 35) {
5  console.log('Very hot!');
6} else if (temperature > 25) {
7  console.log('Warm day.');    // this runs
8} else {
9  console.log('Cool or cold.');
10}
11
12// switch / case / default / break — choose between many options
13const day = 'Monday';
14
15switch (day) {
16  case 'Monday':
17  case 'Tuesday':
18  case 'Wednesday':
19  case 'Thursday':
20  case 'Friday':
21    console.log('Weekday — time to work!');
22    break;     // stop here — do not fall through to next case
23  case 'Saturday':
24  case 'Sunday':
25    console.log('Weekend — time to rest!');
26    break;
27  default:
28    console.log('Unknown day');
29    break;
30}

1// for — repeat code a set number of times
2for (let i = 1; i <= 5; i++) {
3  if (i === 3) continue;  // skip 3
4  if (i === 5) break;     // stop at 5
5  console.log('for:', i);  // prints 1, 2, 4
6}
7
8// while — repeat while a condition is true
9let count = 3;
10while (count > 0) {
11  console.log('while countdown:', count);
12  count--;
13}
14
15// do...while — runs at least once, then checks condition
16let attempts = 0;
17do {
18  attempts++;
19  console.log('Attempt:', attempts);
20} while (attempts < 3);
21
22// return — exits a function and gives back a value
23function multiply(a, b) {
24  return a * b;   // stops the function and sends back the result
25}
26console.log('5 x 4 =', multiply(5, 4));

1// try — wrap code that might cause an error
2// catch — runs if an error happens inside try
3// finally — ALWAYS runs at the end, error or not
4
5function parseUserData(jsonString) {
6  try {
7    const data = JSON.parse(jsonString);   // might throw SyntaxError
8    console.log('Parsed successfully:', data.name);
9    return data;
10  } catch (error) {
11    console.log('Error:', error.message);  // handle the error
12    return null;
13  } finally {
14    console.log('Done — always runs.')     // cleanup code
15  }
16}
17
18parseUserData('{"name": "Alice"}');   // works
19parseUserData('{ bad json }');         // caught
20
21// throw — create your own error on purpose
22function divide(a, b) {
23  if (b === 0) {
24    throw new Error('Cannot divide by zero!');  // throw keyword
25  }
26  return a / b;
27}
28
29try {
30  console.log(divide(10, 2));  // 5
31  console.log(divide(10, 0)); // throws
32} catch (e) {
33  console.log('Caught:', e.message);
34}

1// true and false — boolean values
2const isLoggedIn = true;
3const isAdmin    = false;
4
5if (isLoggedIn) {
6  console.log('Welcome back!');
7}
8console.log('isAdmin:', isAdmin);
9
10// null — intentional empty value (you set it on purpose)
11let currentUser = null;      // no user yet
12console.log('currentUser:', currentUser);  // null
13console.log('type of null:', typeof null); // 'object' (a famous JS quirk)
14
15// undefined — a variable exists but has no value assigned
16let notAssigned;             // declared but not given a value
17console.log('notAssigned:', notAssigned);  // undefined
18
19function noReturn() {
20  // no return statement
21}
22console.log('noReturn():', noReturn());    // undefined
23
24// null vs undefined
25console.log(null == undefined);   // true  — both mean 'empty'
26console.log(null === undefined);  // false — different types

1// class and extends — create a class that inherits from another
2class Animal {
3  constructor(name) {
4    this.name = name;     // 'this' refers to the current object
5  }
6  speak() {
7    return this.name + ' makes a sound.';
8  }
9}
10
11class Dog extends Animal {     // 'extends' inherits from Animal
12  constructor(name) {
13    super(name);               // 'super' calls the parent constructor
14  }
15  speak() {
16    return this.name + ' barks!';
17  }
18}
19
20// new — creates a new instance of a class or function
21const animal = new Animal('Cat');
22const dog    = new Dog('Rex');
23
24console.log(animal.speak());   // Cat makes a sound.
25console.log(dog.speak());      // Rex barks!
26
27// instanceof — checks if an object is an instance of a class
28console.log(dog instanceof Dog);    // true
29console.log(dog instanceof Animal); // true — because Dog extends Animal
30console.log(dog instanceof Array);  // false
31
32// typeof — tells you the type of any value
33console.log(typeof 42);        // 'number'
34console.log(typeof 'hello');   // 'string'
35console.log(typeof true);      // 'boolean'
36console.log(typeof dog);       // 'object'
37console.log(typeof undefined); // 'undefined'
38
39// delete — removes a property from an object
40const user = { name: 'Alice', age: 25, role: 'admin' };
41console.log('before:', user);
42delete user.role;
43console.log('after delete:', user); // role is gone

1// ── math.js — EXPORTING ───────────────────────────────────
2
3// Named export — you can have many of these
4export const PI = 3.14159;
5
6export function add(a, b) {
7  return a + b;
8}
9
10export function multiply(a, b) {
11  return a * b;
12}
13
14// Default export — only one per file
15export default function subtract(a, b) {
16  return a - b;
17}
18
19
20// ── app.js — IMPORTING ────────────────────────────────────
21
22// Import named exports — use exact name inside { }
23import { PI, add, multiply } from './math.js';
24
25// Import the default export — any name works
26import subtract from './math.js';
27
28// Import everything into one object
29import * as MathUtils from './math.js';
30
31console.log(PI);             // 3.14159
32console.log(add(3, 4));      // 7
33console.log(subtract(10, 3)); // 7
34console.log(MathUtils.multiply(5, 4)); // 20
35
36// Dynamic import — load a file only when needed
37async function loadChart() {
38  const { Chart } = await import('./chart.js');
39  Chart.render();
40}

1// in — checks if a property exists in an object
2const person = { name: 'Alice', age: 25 };
3console.log('name' in person);    // true
4console.log('salary' in person);  // false
5
6// for...in — loops over object property NAMES (keys)
7for (const key in person) {
8  console.log(key + ':', person[key]);
9}
10
11// for...of — loops over VALUES in an iterable (array, string, etc.)
12const fruits = ['apple', 'banana', 'cherry'];
13for (const fruit of fruits) {
14  console.log(fruit);
15}
16
17// typeof — returns the type of a value as a string
18console.log(typeof 42);          // 'number'
19console.log(typeof 'hello');     // 'string'
20console.log(typeof true);        // 'boolean'
21console.log(typeof null);        // 'object' (historical JS bug)
22console.log(typeof undefined);   // 'undefined'
23console.log(typeof function(){}); // 'function'
24
25// void — evaluates an expression and returns undefined
26console.log(void 0);    // undefined
27console.log(void 'anything'); // undefined (always undefined)
28
29// debugger — pauses code in browser DevTools (for debugging)
30// Uncomment in browser to pause here:
31// debugger;

1// async — marks a function as asynchronous (it can wait)
2// await — pauses inside an async function until a promise finishes
3
4async function fetchUserName(id) {
5  // Simulate waiting 1 second for server response
6  const result = await new Promise((resolve) => {
7    setTimeout(() => resolve({ id, name: 'Alice' }), 100);
8  });
9  return result.name;
10}
11
12// You must use await inside an async function
13async function main() {
14  const name = await fetchUserName(1);
15  console.log('Fetched user:', name); // Alice
16
17  // Without async/await, you use .then() — older style
18  fetchUserName(2).then(n => console.log('Then style:', n));
19}
20
21main();
22console.log('This runs while waiting for main() to finish.');