JavaScript Objects: Definitions · `this` · Iterations · Accessors · Management · Protection · Prototypes · Reference

const person = {
  firstName: "Tunde",
  lastName:  "Adeyemi",
  age:       32,
  isStudent: false,
  greet: function() {
    return "Hello, I'm " + this.firstName;
  }
};

{
  key   :  value  ,
  │         │
  property  can be any data type
  name      (string, number, boolean, array,
             another object, or a function)
}

// Dot notation (preferred for known property names)
console.log(person.firstName);    // Output: Tunde
console.log(person.age);          // Output: 32

// Bracket notation (required for dynamic or unusual property names)
console.log(person["lastName"]);  // Output: Adeyemi

const key = "age";
console.log(person[key]);         // Output: 32  ← key is a variable

console.log(person.greet());   // Output: Hello, I'm Tunde

const book = { title: "1984", author: "Orwell" };

// Adding a new property
book.year = 1949;
console.log(book.year);   // Output: 1949

// Modifying an existing property
book.author = "George Orwell";
console.log(book.author);   // Output: George Orwell

// Deleting a property
delete book.year;
console.log(book.year);   // Output: undefined
console.log("year" in book);   // Output: false

function Person(firstName, lastName, age) {
  this.firstName = firstName;
  this.lastName  = lastName;
  this.age       = age;
  this.greet     = function() {
    return "Hi, I'm " + this.firstName + " " + this.lastName;
  };
}

const alice = new Person("Alice", "Johnson", 30);
const bob   = new Person("Bob",   "Smith",   25);

console.log(alice.greet());   // Output: Hi, I'm Alice Johnson
console.log(bob.age);         // Output: 25

1. Creates a new empty object:  {}
2. Sets 'this' inside the function to point to that new object
3. Runs the function body — attaching properties to 'this'
4. Returns the new object automatically

console.log(alice instanceof Person);   // Output: true
console.log(bob instanceof Person);     // Output: true
console.log(typeof alice);             // Output: object

const animalBase = {
  type: "Animal",
  describe: function() {
    return this.name + " is a " + this.type;
  }
};

const dog = Object.create(animalBase);
dog.name = "Rex";
dog.type = "Dog";

console.log(dog.describe());        // Output: Rex is a Dog
console.log(Object.getPrototypeOf(dog) === animalBase);  // Output: true

class Car {
  constructor(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year  = year;
    this.speed = 0;
  }

  accelerate(amount) {
    this.speed += amount;
    return this.brand + " is now going " + this.speed + " km/h";
  }

  brake(amount) {
    this.speed = Math.max(0, this.speed - amount);
    return this.brand + " slowed to " + this.speed + " km/h";
  }

  describe() {
    return this.year + " " + this.brand + " " + this.model;
  }
}

const myCar = new Car("Toyota", "Corolla", 2022);
console.log(myCar.describe());         // Output: 2022 Toyota Corolla
console.log(myCar.accelerate(50));     // Output: Toyota is now going 50 km/h
console.log(myCar.brake(20));          // Output: Toyota slowed to 30 km/h

class ElectricCar extends Car {
  constructor(brand, model, year, batteryKwh) {
    super(brand, model, year);   // Call parent constructor
    this.batteryKwh = batteryKwh;
    this.charge = 100;
  }

  describe() {
    return super.describe() + " (Electric, " + this.batteryKwh + " kWh)";
  }

  charge(percent) {
    this.charge = Math.min(100, this.charge + percent);
    return "Battery at " + this.charge + "%";
  }
}

const tesla = new ElectricCar("Tesla", "Model 3", 2023, 75);
console.log(tesla.describe());        // Output: 2023 Tesla Model 3 (Electric, 75 kWh)
console.log(tesla.accelerate(100));   // Inherited from Car: Tesla is now going 100 km/h

const employee = {
  id: 101,
  name: {
    first: "Sara",
    last:  "Williams"
  },
  skills: ["JavaScript", "React", "Node.js"],
  address: {
    city:    "Lagos",
    country: "Nigeria"
  },
  getFullName: function() {
    return this.name.first + " " + this.name.last;
  }
};

console.log(employee.name.first);      // Output: Sara
console.log(employee.skills[1]);       // Output: React
console.log(employee.address.city);    // Output: Lagos
console.log(employee.getFullName());   // Output: Sara Williams

const name = "Alice";
const age  = 30;

// Old syntax:
const person = { name: name, age: age };

// ES6 shorthand (identical result):
const person = { name, age };

console.log(person);   // Output: { name: 'Alice', age: 30 }

// Old syntax:
const obj = {
  greet: function() { return "Hello"; }
};

// ES6 shorthand:
const obj = {
  greet() { return "Hello"; }
};

const field = "score";
const round = 1;

const gameResult = {
  player: "Alice",
  [field]: 95,                    // Equivalent to score: 95
  ["round_" + round]: "Win",      // Equivalent to round_1: "Win"
};

console.log(gameResult.score);    // Output: 95
console.log(gameResult.round_1);  // Output: Win

function createConfig(keys, values) {
  const config = {};
  keys.forEach((key, i) => { config[key] = values[i]; });
  return config;
}

const cfg = createConfig(["host", "port", "db"], ["localhost", 5432, "mydb"]);
console.log(cfg.host);   // Output: localhost
console.log(cfg.port);   // Output: 5432

const defaults = { theme: "light", lang: "en", fontSize: 14 };
const userPrefs = { theme: "dark", fontSize: 16 };

// Merge — userPrefs properties override defaults where they overlap
const config = { ...defaults, ...userPrefs };
console.log(config);
// Output: { theme: 'dark', lang: 'en', fontSize: 16 }

const original = { name: "Alice", address: { city: "London" } };
const copy = { ...original };

copy.name = "Bob";               // Only affects 'copy'
copy.address.city = "Paris";     // ⚠️ Affects BOTH — address is shared!

console.log(original.name);          // Output: Alice  ✅
console.log(original.address.city);  // Output: Paris  ❌ — shared reference

const deepCopy = JSON.parse(JSON.stringify(original));
// Works for plain data objects. Doesn't copy functions, Date objects, or undefined values.

const { name, age, ...rest } = { name: "Alice", age: 30, city: "London", job: "Dev" };
console.log(name);   // Output: Alice
console.log(age);    // Output: 30
console.log(rest);   // Output: { city: 'London', job: 'Dev' }

const user = {
  profile: {
    address: {
      city: "Lagos"
    }
  }
};

// ❌ Without optional chaining — crashes if profile is missing:
console.log(user.profile.address.city);    // Output: Lagos (works here)
console.log(user.account.balance);          // ❌ TypeError: Cannot read properties of undefined

// ✅ With optional chaining — returns undefined instead of crashing:
console.log(user?.profile?.address?.city); // Output: Lagos
console.log(user?.account?.balance);        // Output: undefined  (no crash!)

const result = user.profile?.getAvatar?.();
// If getAvatar doesn't exist, returns undefined instead of throwing

const settings = { volume: 0, username: null };

// ❌ Using || (broken for falsy values like 0):
const volume   = settings.volume   || 50;    // Output: 50 — WRONG! 0 is valid
const username = settings.username || "Guest"; // Output: Guest — correct

// ✅ Using ?? (only triggers for null/undefined):
const volume2   = settings.volume   ?? 50;    // Output: 0   — correct!
const username2 = settings.username ?? "Guest"; // Output: Guest — correct

const bankAccount = {
  owner:   "Tunde",
  balance: 1000,

  deposit(amount) {
    this.balance += amount;
    return this.owner + "'s balance: £" + this.balance;
  },

  withdraw(amount) {
    if (amount > this.balance) {
      return "Insufficient funds";
    }
    this.balance -= amount;
    return this.owner + "'s balance: £" + this.balance;
  }
};

console.log(bankAccount.deposit(500));    // Output: Tunde's balance: £1500
console.log(bankAccount.withdraw(200));   // Output: Tunde's balance: £1300
console.log(bankAccount.withdraw(2000));  // Output: Insufficient funds

const obj1 = { name: "First",  showName() { console.log(this.name); } };
const obj2 = { name: "Second", showName() { console.log(this.name); } };

obj1.showName();   // Output: First   ← 'this' is obj1
obj2.showName();   // Output: Second  ← 'this' is obj2

function describe() {
  return this.brand + " costs £" + this.price;
}

const phone  = { brand: "Samsung", price: 699,  describe };
const laptop = { brand: "Dell",    price: 1099, describe };

console.log(phone.describe());    // Output: Samsung costs £699
console.log(laptop.describe());   // Output: Dell costs £1099

const order = {
  items: ["Coffee", "Cake", "Juice"],
  taxRate: 0.1,

  printItems: function() {
    // 'this' here is 'order' — correct
    this.items.forEach(function(item) {
      // ❌ 'this' inside this callback is NOT 'order'
      console.log(item + " (tax: " + this.taxRate + ")");
    });
  }
};

order.printItems();
// Output:
// Coffee (tax: undefined)    ← taxRate is undefined!
// Cake (tax: undefined)
// Juice (tax: undefined)

printItems: function() {
  this.items.forEach((item) => {
    console.log(item + " (tax: " + this.taxRate + ")");  // Arrow function inherits 'this'
  });
}
// Output: Coffee (tax: 0.1) ✅

printItems: function() {
  const self = this;   // Capture 'this' before it changes
  this.items.forEach(function(item) {
    console.log(item + " (tax: " + self.taxRate + ")");
  });
}

printItems: function() {
  this.items.forEach(function(item) {
    console.log(item + " (tax: " + this.taxRate + ")");
  }.bind(this));
}

const calculator = {
  value: 0,
  add(n) { this.value += n; return this; },   // Return 'this' for chaining
  subtract(n) { this.value -= n; return this; },
  multiply(n) { this.value *= n; return this; },
  result() { return this.value; }
};

// Method chaining works because each method returns 'this'
const answer = calculator.add(10).multiply(3).subtract(5).result();
console.log(answer);   // Output: 25  (10×3=30, 30−5=25)

const laptop = {
  brand:  "Dell",
  ram:    "16GB",
  storage: "512GB SSD",
  price:  899
};

for (const key in laptop) {
  console.log(key + ": " + laptop[key]);
}
// Output:
// brand: Dell
// ram: 16GB
// storage: 512GB SSD
// price: 899

for (const key in laptop) {
  if (Object.hasOwn(laptop, key)) {    // Only own properties
    console.log(key + ": " + laptop[key]);
  }
}

const scores = { Alice: 92, Bob: 85, Carol: 78 };

const names = Object.keys(scores);
console.log(names);   // Output: ['Alice', 'Bob', 'Carol']

// Now you can use all array methods:
names.forEach(name => console.log(name + ": " + scores[name]));
// Output:
// Alice: 92
// Bob: 85
// Carol: 78

const prices = { coffee: 3.50, tea: 2.75, juice: 4.00 };

const amounts = Object.values(prices);
console.log(amounts);   // Output: [3.5, 2.75, 4]

const total = amounts.reduce((sum, price) => sum + price, 0);
console.log("Total: £" + total.toFixed(2));   // Output: Total: £10.25

const product = { name: "Headphones", price: 59.99, inStock: true };

const pairs = Object.entries(product);
console.log(pairs);
// Output: [['name', 'Headphones'], ['price', 59.99], ['inStock', true]]

// With destructuring (very clean):
for (const [key, value] of Object.entries(product)) {
  console.log(key + " → " + value);
}
// Output:
// name → Headphones
// price → 59.99
// inStock → true

const original = { a: 1, b: 2, c: 3 };

const doubled = Object.fromEntries(
  Object.entries(original).map(([key, val]) => [key, val * 2])
);

console.log(doubled);   // Output: { a: 2, b: 4, c: 6 }

const employees = [
  { name: "Alice", dept: "Engineering", salary: 75000 },
  { name: "Bob",   dept: "Design",      salary: 68000 },
  { name: "Carol", dept: "Engineering", salary: 82000 },
  { name: "David", dept: "Marketing",   salary: 61000 },
];

// Find all engineers:
const engineers = employees.filter(e => e.dept === "Engineering");
console.log(engineers.map(e => e.name));   // Output: ['Alice', 'Carol']

// Total salary bill:
const total = employees.reduce((sum, e) => sum + e.salary, 0);
console.log("Total: $" + total);   // Output: Total: $286000

// Sort by salary descending:
const sorted = [...employees].sort((a, b) => b.salary - a.salary);
sorted.forEach(e => console.log(e.name + ": $" + e.salary));
// Output:
// Carol: $82000
// Alice: $75000
// Bob: $68000
// David: $61000

const person = {
  firstName: "Tunde",
  lastName:  "Adeyemi",

  get fullName() {
    return this.firstName + " " + this.lastName;
  }
};

// Accessed like a property — no parentheses:
console.log(person.fullName);   // Output: Tunde Adeyemi

// Updates automatically when source properties change:
person.firstName = "Kwame";
console.log(person.fullName);   // Output: Kwame Adeyemi

const thermometer = {
  _celsius: 0,   // Underscore convention: "private" internal storage

  get celsius()    { return this._celsius; },
  get fahrenheit() { return this._celsius * 9/5 + 32; },
  get kelvin()     { return this._celsius + 273.15; }
};

thermometer._celsius = 100;
console.log(thermometer.celsius);    // Output: 100
console.log(thermometer.fahrenheit); // Output: 212
console.log(thermometer.kelvin);     // Output: 373.15

const user = {
  _age: 0,

  get age() {
    return this._age;
  },

  set age(value) {
    if (typeof value !== "number") {
      console.log("Age must be a number.");
      return;
    }
    if (value < 0 || value > 150) {
      console.log("Age must be between 0 and 150.");
      return;
    }
    this._age = value;
  }
};

user.age = 25;       // ✅ Accepted
console.log(user.age);   // Output: 25

user.age = -5;       // Output: Age must be between 0 and 150.
user.age = "old";    // Output: Age must be a number.
console.log(user.age);   // Output: 25  (unchanged — bad values were rejected)

set propertyName(parameterName) {
  // parameterName receives whatever is assigned
  // e.g., user.age = 25 → value = 25
}

class BankAccount {
  constructor(owner, initialBalance) {
    this._owner   = owner;
    this._balance = initialBalance;
    this._transactions = [];
  }

  get balance() {
    return this._balance;
  }

  get owner() {
    return this._owner;
  }

  get transactionCount() {
    return this._transactions.length;
  }

  set deposit(amount) {
    if (amount <= 0) {
      console.log("Deposit must be positive.");
      return;
    }
    this._balance += amount;
    this._transactions.push({ type: "deposit", amount });
    console.log("Deposited £" + amount + ". New balance: £" + this._balance);
  }

  set withdraw(amount) {
    if (amount > this._balance) {
      console.log("Insufficient funds.");
      return;
    }
    this._balance -= amount;
    this._transactions.push({ type: "withdrawal", amount });
    console.log("Withdrew £" + amount + ". New balance: £" + this._balance);
  }
}

const acc = new BankAccount("Alice", 500);
acc.deposit  = 200;         // Output: Deposited £200. New balance: £700
acc.withdraw = 100;         // Output: Withdrew £100. New balance: £600
acc.withdraw = 1000;        // Output: Insufficient funds.
console.log(acc.balance);   // Output: 600
console.log(acc.transactionCount);  // Output: 2

const product = { _price: 100 };

Object.defineProperty(product, "price", {
  get() {
    return "£" + this._price.toFixed(2);
  },
  set(value) {
    if (value >= 0) this._price = value;
  },
  enumerable: true,    // Shows up in Object.keys() and for...in
  configurable: true   // Can be redefined later
});

product.price = 149.99;
console.log(product.price);   // Output: £149.99

const target  = { a: 1, b: 2 };
const source1 = { b: 3, c: 4 };   // 'b' will override target's 'b'
const source2 = { d: 5 };

const result = Object.assign(target, source1, source2);

console.log(result);   // Output: { a: 1, b: 3, c: 4, d: 5 }
console.log(target === result);   // Output: true  ← target was modified in place!

const original = { name: "Alice", score: 95 };
const copy = Object.assign({}, original);   // Empty object as target

copy.name = "Bob";
console.log(original.name);   // Output: Alice  ← unchanged
console.log(copy.name);       // Output: Bob

const original = { name: "Alice", address: { city: "London" } };
const deepCopy  = structuredClone(original);

deepCopy.address.city = "Paris";
console.log(original.address.city);  // Output: London  ✅ truly independent

const config = {};

Object.defineProperty(config, "version", {
  value:        "3.1.4",
  writable:     false,    // Cannot be changed
  enumerable:   true,     // Appears in Object.keys()
  configurable: false     // Cannot be redefined or deleted
});

console.log(config.version);   // Output: 3.1.4

config.version = "4.0.0";      // Silently fails (throws in strict mode)
console.log(config.version);   // Output: 3.1.4  ← unchanged

delete config.version;          // Silently fails
console.log(config.version);   // Output: 3.1.4  ← still there

const circle = {};

Object.defineProperties(circle, {
  _radius: { value: 5, writable: true, enumerable: false, configurable: false },
  radius: {
    get() { return this._radius; },
    set(r) { if (r > 0) this._radius = r; },
    enumerable: true, configurable: false
  },
  area: {
    get() { return Math.PI * this._radius ** 2; },
    enumerable: true, configurable: false
  }
});

console.log(circle.radius);         // Output: 5
console.log(circle.area.toFixed(2)); // Output: 78.54
circle.radius = 10;
console.log(circle.area.toFixed(2)); // Output: 314.16

const person = { name: "Alice" };

const desc = Object.getOwnPropertyDescriptor(person, "name");
console.log(desc);
// Output: { value: 'Alice', writable: true, enumerable: true, configurable: true }

const obj = {};
Object.defineProperty(obj, "hidden", { value: 42, enumerable: false });
obj.visible = "yes";

console.log(Object.keys(obj));                  // Output: ['visible']
console.log(Object.getOwnPropertyNames(obj));   // Output: ['hidden', 'visible']

const settings = { theme: "dark", lang: "en" };

Object.preventExtensions(settings);

settings.theme = "light";   // ✅ Modifying existing — allowed
delete settings.lang;       // ✅ Deleting existing — allowed
settings.debug = true;      // ❌ Adding new — silently fails (throws in strict mode)

console.log(settings);            // Output: { theme: 'light' }
console.log(Object.isExtensible(settings));   // Output: false

const user = { name: "Alice", role: "admin" };

Object.seal(user);

user.name = "Bob";     // ✅ Changing existing value — allowed
user.age = 30;         // ❌ Adding new property — silently fails
delete user.role;      // ❌ Deleting — silently fails

console.log(user);            // Output: { name: 'Bob', role: 'admin' }
console.log(Object.isSealed(user));   // Output: true

const PI_VALUES = {
  pi:  3.14159265,
  tau: 6.28318530,
  e:   2.71828182
};

Object.freeze(PI_VALUES);

PI_VALUES.pi  = 3;            // ❌ Silently fails
PI_VALUES.phi = 1.618;        // ❌ Silently fails
delete PI_VALUES.e;           // ❌ Silently fails

console.log(PI_VALUES.pi);            // Output: 3.14159265  ← unchanged
console.log(Object.isFrozen(PI_VALUES));  // Output: true

const config = Object.freeze({
  server: { host: "localhost", port: 3000 },
  debug: false
});

config.debug = true;           // ❌ Fails — top-level is frozen
config.server.port = 8080;     // ✅ Works! — nested object is NOT frozen

console.log(config.debug);          // Output: false
console.log(config.server.port);    // Output: 8080  ← was changed!

function deepFreeze(obj) {
  // Freeze all nested objects first
  Object.getOwnPropertyNames(obj).forEach(name => {
    const value = obj[name];
    if (value && typeof value === "object") {
      deepFreeze(value);   // Recursively freeze nested objects
    }
  });
  return Object.freeze(obj);
}

const safeConfig = deepFreeze({
  server: { host: "localhost", port: 3000 },
  debug: false
});

safeConfig.server.port = 8080;  // ❌ Now fails — nested object is also frozen
console.log(safeConfig.server.port);  // Output: 3000

const obj = { name: "Alice" };

obj = { name: "Bob" };     // ❌ TypeError — const prevents reassignment
obj.name = "Bob";          // ✅ Works — const does NOT protect the object's contents

// Full protection requires BOTH:
const frozen = Object.freeze({ name: "Alice" });
frozen.name = "Bob";   // ❌ freeze prevents mutation
frozen = {};           // ❌ const prevents reassignment

class BankAccount {
  #balance;         // Private field declaration
  #owner;

  constructor(owner, balance) {
    this.#owner   = owner;
    this.#balance = balance;
  }

  deposit(amount) {
    if (amount > 0) this.#balance += amount;
    return this;
  }

  get balance() {
    return this.#balance;
  }

  get summary() {
    return this.#owner + ": £" + this.#balance;
  }
}

const acc = new BankAccount("Alice", 1000);
acc.deposit(500);
console.log(acc.balance);    // Output: 1500
console.log(acc.summary);    // Output: Alice: £1500
console.log(acc.#balance);   // ❌ SyntaxError — truly inaccessible

const animal = {
  type: "Animal",
  describe() {
    return this.name + " is a " + this.type;
  }
};

const dog = Object.create(animal);  // dog's prototype is 'animal'
dog.name = "Rex";
dog.type = "Dog";

console.log(dog.describe());        // Output: Rex is a Dog
// dog doesn't have 'describe' — JavaScript finds it on 'animal'

console.log(Object.getPrototypeOf(dog) === animal);  // Output: true

dog.describe()
  → Look in dog itself for 'describe' → Not found
  → Look in dog's prototype (animal) for 'describe' → Found! Run it.

function Person(name, age) {
  this.name = name;
  this.age  = age;
}

// Add a method to the prototype — shared by ALL Person instances
Person.prototype.greet = function() {
  return "Hi, I'm " + this.name;
};

Person.prototype.isAdult = function() {
  return this.age >= 18;
};

const alice = new Person("Alice", 30);
const bob   = new Person("Bob",   15);

console.log(alice.greet());     // Output: Hi, I'm Alice
console.log(bob.greet());       // Output: Hi, I'm Bob
console.log(alice.isAdult());   // Output: true
console.log(bob.isAdult());     // Output: false

function Animal(name) {
  this.name = name;
}

Animal.prototype.describe = function() {
  return "I am " + this.name;
};

function Dog(name, breed) {
  Animal.call(this, name);   // Inherit instance properties
  this.breed = breed;
}

// Set up prototype chain: Dog → Animal → Object
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;   // Restore constructor reference (important!)

Dog.prototype.bark = function() {
  return this.name + " says: Woof!";
};

const rex = new Dog("Rex", "Labrador");
console.log(rex.describe());   // Output: I am Rex  (inherited from Animal)
console.log(rex.bark());       // Output: Rex says: Woof! (own Dog method)
console.log(rex instanceof Dog);    // Output: true
console.log(rex instanceof Animal); // Output: true  ← prototype chain confirmed

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return this.name + " makes a noise.";
  }

  toString() {
    return "Animal: " + this.name;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);       // Must call super() before using 'this'
    this.breed = breed;
  }

  speak() {
    return this.name + " barks: Woof!";  // Override parent method
  }

  describe() {
    return super.toString() + " (Breed: " + this.breed + ")";
    // super.toString() calls Animal's toString()
  }
}

const rex = new Dog("Rex", "Labrador");
console.log(rex.speak());     // Output: Rex barks: Woof!  (overridden)
console.log(rex.describe());  // Output: Animal: Rex (Breed: Labrador)
console.log(rex instanceof Dog);    // Output: true
console.log(rex instanceof Animal); // Output: true

const alice = new Person("Alice", 30);

console.log(Object.hasOwn(alice, "name"));    // Output: true  ← own property
console.log(Object.hasOwn(alice, "greet"));   // Output: false ← inherited from prototype
console.log("greet" in alice);                 // Output: true  ← 'in' includes prototype chain

// Adding a method to all arrays:
Array.prototype.last = function() {
  return this[this.length - 1];
};

const nums = [10, 20, 30];
console.log(nums.last());   // Output: 30

// ⚠️ Risks:
// 1. Conflicts with future JavaScript standards (e.g., if 'last' is added natively)
// 2. Affects ALL arrays everywhere in your codebase and in third-party libraries
// 3. Can break libraries that use 'for...in' on arrays

const base = { type: "base" };
const child = { name: "child" };

// Check prototype:
console.log(Object.getPrototypeOf(child));   // Object.prototype (default)

// Change prototype:
Object.setPrototypeOf(child, base);
console.log(child.type);   // Output: base  ← inherited from 'base'
console.log(Object.getPrototypeOf(child) === base);   // Output: true

// Edge case 1: NaN
console.log(NaN === NaN);         // Output: false  (the notorious NaN issue)
console.log(Object.is(NaN, NaN)); // Output: true   ✅

// Edge case 2: -0 and +0
console.log(-0 === +0);           // Output: true
console.log(Object.is(-0, +0));   // Output: false  ✅ (they are different values)

// Normal comparisons — same as ===:
console.log(Object.is(1, 1));     // Output: true
console.log(Object.is("a", "a")); // Output: true
console.log(Object.is(null, null)); // Output: true

const map = new Map([
  ["name", "Alice"],
  ["role", "admin"],
  ["score", 95]
]);

const obj = Object.fromEntries(map);
console.log(obj);   // Output: { name: 'Alice', role: 'admin', score: 95 }

const prices = { apple: 1.2, banana: 0.5, cherry: 3.0 };

// Apply 10% discount to all prices:
const discounted = Object.fromEntries(
  Object.entries(prices).map(([item, price]) => [item, +(price * 0.9).toFixed(2)])
);

console.log(discounted);
// Output: { apple: 1.08, banana: 0.45, cherry: 2.7 }

const source = {
  _x: 10,
  get x() { return this._x; },
  set x(v) { if (v >= 0) this._x = v; }
};

// ❌ Object.assign — copies the VALUE of x, not the getter/setter:
const badCopy = Object.assign({}, source);
console.log(Object.getOwnPropertyDescriptor(badCopy, "x"));
// Output: { value: 10, ... }  ← getter is gone!

// ✅ defineProperties + getOwnPropertyDescriptors — copies accessor definitions:
const goodCopy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(source));
goodCopy.x = 20;
console.log(goodCopy.x);   // Output: 20  ← setter works!
goodCopy.x = -5;
console.log(goodCopy.x);   // Output: 20  ← validation works too!

class Employee {
  #id;
  #name;
  #email;
  #department;
  #salary;
  #startDate;

  constructor(id, name, email, department, salary) {
    this.#id         = id;
    this.#name       = name;
    this.#email      = email;
    this.#department = department;
    this.#salary     = salary;
    this.#startDate  = new Date();
  }

  // --- Getters ---
  get id()         { return this.#id; }
  get name()       { return this.#name; }
  get email()      { return this.#email; }
  get department() { return this.#department; }
  get salary()     { return this.#salary; }
  get startDate()  { return this.#startDate.toLocaleDateString(); }

  get yearsOfService() {
    const ms    = Date.now() - this.#startDate.getTime();
    const years = ms / (1000 * 60 * 60 * 24 * 365.25);
    return Math.floor(years);
  }

  get summary() {
    return `[${this.#id}] ${this.#name} | ${this.#department} | £${this.#salary.toLocaleString()}`;
  }

  // --- Setters ---
  set name(value) {
    if (typeof value !== "string" || value.trim().length < 2) {
      throw new Error("Name must be at least 2 characters.");
    }
    this.#name = value.trim();
  }

  set email(value) {
    const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!re.test(value)) throw new Error("Invalid email address.");
    this.#email = value;
  }

  set salary(value) {
    if (typeof value !== "number" || value < 0) {
      throw new Error("Salary must be a non-negative number.");
    }
    this.#salary = value;
  }

  set department(value) {
    const valid = ["Engineering", "Design", "Marketing", "HR", "Finance"];
    if (!valid.includes(value)) {
      throw new Error("Invalid department: " + value);
    }
    this.#department = value;
  }

  // Serialise to plain object for export/display:
  toJSON() {
    return {
      id:         this.#id,
      name:       this.#name,
      email:      this.#email,
      department: this.#department,
      salary:     this.#salary,
      startDate:  this.startDate,
    };
  }
}

const emp = new Employee(1, "Alice Johnson", "alice@company.com", "Engineering", 75000);
console.log(emp.summary);
// Output: [1] Alice Johnson | Engineering | £75,000

emp.salary = 80000;
console.log(emp.salary);    // Output: 80000

try {
  emp.email = "not-an-email";
} catch (e) {
  console.log(e.message);   // Output: Invalid email address.
}

class Manager extends Employee {
  #reports;
  #budget;

  constructor(id, name, email, department, salary, budget) {
    super(id, name, email, department, salary);
    this.#reports = [];
    this.#budget  = budget;
  }

  get budget()      { return this.#budget; }
  get teamSize()    { return this.#reports.length; }
  get reportNames() { return this.#reports.map(e => e.name); }

  addReport(employee) {
    if (!(employee instanceof Employee)) {
      throw new Error("Can only manage Employee instances.");
    }
    this.#reports.push(employee);
    return this;   // Allow chaining
  }

  get summary() {
    return super.summary + ` | Manages ${this.teamSize} reports | Budget: £${this.#budget.toLocaleString()}`;
  }

  getTeamReport() {
    const total = this.#reports.reduce((sum, e) => sum + e.salary, 0);
    return {
      manager:     this.name,
      teamSize:    this.teamSize,
      members:     this.reportNames,
      totalSalary: total,
      avgSalary:   Math.round(total / (this.teamSize || 1))
    };
  }
}

class Director extends Manager {
  #division;

  constructor(id, name, email, department, salary, budget, division) {
    super(id, name, email, department, salary, budget);
    this.#division = division;
  }

  get division() { return this.#division; }

  get summary() {
    return super.summary + ` | Division: ${this.#division}`;
  }
}

const mgr = new Manager(2, "Bob Smith", "bob@company.com", "Engineering", 95000, 500000);
const dev1 = new Employee(3, "Carol Lee",  "carol@company.com",  "Engineering", 72000);
const dev2 = new Employee(4, "David Kim",  "david@company.com",  "Engineering", 68000);

mgr.addReport(dev1).addReport(dev2);   // Method chaining using 'return this'

console.log(mgr.summary);
// Output: [2] Bob Smith | Engineering | £95,000 | Manages 2 reports | Budget: £500,000

const report = mgr.getTeamReport();
console.log(report);
// Output: { manager: 'Bob Smith', teamSize: 2, members: ['Carol Lee','David Kim'], totalSalary: 140000, avgSalary: 70000 }

console.log(mgr instanceof Manager);   // Output: true
console.log(mgr instanceof Employee);  // Output: true

const HRSystem = (function() {
  // Private state
  let _employees = new Map();    // id → Employee instance
  let _nextId = 1000;
  const _auditLog = [];

  // Frozen configuration — cannot be changed after initialisation
  const CONFIG = Object.freeze({
    maxEmployeesPerDept: 50,
    departments:         Object.freeze(["Engineering", "Design", "Marketing", "HR", "Finance"]),
    salaryBands:         Object.freeze({ min: 20000, max: 250000 })
  });

  function _audit(action, employeeId, detail = "") {
    _auditLog.push({
      timestamp:  new Date().toISOString(),
      action,
      employeeId,
      detail
    });
  }

  function _validateSalary(salary) {
    return salary >= CONFIG.salaryBands.min && salary <= CONFIG.salaryBands.max;
  }

  // --- Public API ---
  return {
    hire(name, email, department, salary, isManager = false, budget = 0) {
      if (!CONFIG.departments.includes(department)) {
        throw new Error("Unknown department: " + department);
      }
      if (!_validateSalary(salary)) {
        throw new Error(`Salary must be between £${CONFIG.salaryBands.min} and £${CONFIG.salaryBands.max}`);
      }

      const id  = ++_nextId;
      const emp = isManager
        ? new Manager(id, name, email, department, salary, budget)
        : new Employee(id, name, email, department, salary);

      _employees.set(id, emp);
      _audit("HIRE", id, name + " joined " + department);
      return emp;
    },

    terminate(id) {
      const emp = _employees.get(id);
      if (!emp) throw new Error("Employee not found: " + id);
      _employees.delete(id);
      _audit("TERMINATE", id, emp.name);
      return true;
    },

    promote(id, newSalary, newDepartment) {
      const emp = _employees.get(id);
      if (!emp) throw new Error("Employee not found: " + id);
      if (!_validateSalary(newSalary)) throw new Error("Salary out of band.");
      const oldSalary = emp.salary;
      emp.salary = newSalary;
      if (newDepartment) emp.department = newDepartment;
      _audit("PROMOTE", id, `£${oldSalary} → £${newSalary}`);
      return emp;
    },

    getEmployee(id) {
      return _employees.get(id) || null;
    },

    // --- Reporting using Object iteration ---
    getDepartmentReport() {
      const report = {};

      for (const emp of _employees.values()) {
        const dept = emp.department;
        if (!report[dept]) {
          report[dept] = { count: 0, totalSalary: 0, employees: [] };
        }
        report[dept].count++;
        report[dept].totalSalary += emp.salary;
        report[dept].employees.push(emp.name);
      }

      // Add computed averages using Object.entries + Object.fromEntries:
      return Object.fromEntries(
        Object.entries(report).map(([dept, data]) => [
          dept,
          { ...data, avgSalary: Math.round(data.totalSalary / data.count) }
        ])
      );
    },

    getHeadcount() {
      return _employees.size;
    },

    getAuditLog() {
      return [..._auditLog];   // Return a copy
    },

    getConfig() {
      return Object.assign({}, CONFIG);   // Return a shallow copy
    },

    getAllEmployees() {
      // Return plain objects (not class instances) for safe external use
      return Array.from(_employees.values()).map(e => e.toJSON());
    }
  };
})();

// Hire employees
const alice = HRSystem.hire("Alice Johnson", "alice@co.com", "Engineering", 75000);
const bob   = HRSystem.hire("Bob Smith",     "bob@co.com",   "Engineering", 95000, true, 400000);
const carol = HRSystem.hire("Carol Lee",     "carol@co.com", "Design",      68000);
const david = HRSystem.hire("David Kim",     "david@co.com", "Engineering", 72000);
const eve   = HRSystem.hire("Eve Brown",     "eve@co.com",   "Marketing",   61000);

// Assign reports to manager
bob.addReport(alice).addReport(david);

// Promote Alice
HRSystem.promote(alice.id, 82000);

// Department report
const deptReport = HRSystem.getDepartmentReport();
console.log("\n--- Department Report ---");
for (const [dept, data] of Object.entries(deptReport)) {
  console.log(`\n${dept}:`);
  console.log(`  Headcount:  ${data.count}`);
  console.log(`  Total Pay:  £${data.totalSalary.toLocaleString()}`);
  console.log(`  Avg Salary: £${data.avgSalary.toLocaleString()}`);
  console.log(`  Team:       ${data.employees.join(", ")}`);
}

// Terminate an employee
HRSystem.terminate(eve.id);

// Audit log
console.log("\n--- Audit Log ---");
HRSystem.getAuditLog().forEach(entry => {
  console.log(`[${entry.action}] ${entry.detail}`);
});

--- Department Report ---

Engineering:
  Headcount:  3
  Total Pay:  £249,000
  Avg Salary: £83,000
  Team:       Alice Johnson, Bob Smith, David Kim

Design:
  Headcount:  1
  Total Pay:  £68,000
  Avg Salary: £68,000
  Team:       Carol Lee

Marketing:
  Headcount:  1
  Total Pay:  £61,000
  Avg Salary: £61,000
  Team:       Eve Brown

--- Audit Log ---
[HIRE] Alice Johnson joined Engineering
[HIRE] Bob Smith joined Engineering
[HIRE] Carol Lee joined Design
[HIRE] David Kim joined Engineering
[HIRE] Eve Brown joined Marketing
[PROMOTE] £75000 → £82000
[TERMINATE] Eve Brown

function describeObject(obj) {
  console.log("=== Own Properties ===");
  Object.getOwnPropertyNames(obj).forEach(name => {
    const desc = Object.getOwnPropertyDescriptor(obj, name);
    const type = desc.get ? "getter" : desc.set ? "setter" : typeof desc.value;
    console.log(`  ${name}: [${type}]`, {
      writable:     desc.writable     ?? "N/A",
      enumerable:   desc.enumerable,
      configurable: desc.configurable
    });
  });

  console.log("\n=== Prototype Chain ===");
  let proto = Object.getPrototypeOf(obj);
  let level = 1;
  while (proto && proto !== Object.prototype) {
    const ctorName = proto.constructor?.name ?? "Anonymous";
    const methods  = Object.getOwnPropertyNames(proto).filter(n => n !== "constructor");
    console.log(`  Level ${level}: ${ctorName} (${methods.join(", ")})`);
    proto = Object.getPrototypeOf(proto);
    level++;
  }
}

describeObject(alice);

const location = {
  street: "123 Main St",
  city:   "Lagos",
  country: "Nigeria",
  // add fullAddress getter here
};
// location.fullAddress → "123 Main St, Lagos, Nigeria"

get fullAddress() {
  return this.street + ", " + this.city + ", " + this.country;
}