Object
Toolbox

const user = {
  name: "Asha",
  age: 29,
  "home city": "Pune",           // a key with a space needs quotes
  greet() { return `Hi, I am ${this.name}`; },
};

console.log(user.name);          // dot: when you know the key
console.log(user["home city"]);  // brackets: spaces or a key in a variable
const field = "age";
console.log(user[field]);
console.log(user.greet());       // a function inside an object is a method
console.log(user.email);         // a missing key gives undefined, not an error

const order = { id: 7, customer: { name: "Ravi" } };

// ?. stops early instead of crashing when something is missing
console.log(order.customer?.name);
console.log(order.shipping?.city);          // undefined, no crash

// ?? gives a fallback only for null or undefined
console.log(order.shipping?.city ?? "not set");

// checking if a key exists
console.log("id" in order, Object.hasOwn(order, "total"));

const name = "Meera";
const role = "admin";
const key = "last login";

const account = {
  name,                  // same as name: name
  role,
  [key]: "today",        // computed key: the value of key becomes the name
  [`is_${role}`]: true,
};
console.log(account);

const prices = { tea: 20, coffee: 45, juice: 60 };

console.log(Object.keys(prices));     // the names
console.log(Object.values(prices));   // the values
console.log(Object.entries(prices));  // [name, value] pairs

for (const [item, price] of Object.entries(prices)) {
  console.log(`${item} costs ${price}`);
}
console.log(Object.keys(prices).length, "items");

const car = { brand: "Tata", year: 2021 };

car.color = "blue";        // add a new key
car.year = 2022;           // update an existing key
delete car.brand;          // remove a key
console.log(car);

// spread builds a new object; later keys win
const base = { theme: "light", size: 14 };
const mine = { size: 16 };
console.log({ ...base, ...mine, lang: "hi" });

// Object.assign copies keys into the first object and changes it
const target = { a: 1 };
Object.assign(target, { b: 2 }, { c: 3 });
console.log(target);

const original = { name: "Kiran", tags: ["new"] };

const sameBox = original;              // not a copy, just a second name
sameBox.name = "Kiran R";
console.log(original.name);

const shallow = { ...original };       // copies the top level only
shallow.name = "K";
shallow.tags.push("vip");              // the inner array is still shared
console.log(original.name, original.tags);

const deep = structuredClone(original); // copies every level
deep.tags.push("gold");
console.log(original.tags, deep.tags);

// entries in, object out
const pairs = [["red", "#FF4D6D"], ["amber", "#FFB703"]];
console.log(Object.fromEntries(pairs));

// the change pattern: entries, then map, then fromEntries
const stock = { pens: 12, books: 3, bags: 0 };
const doubled = Object.fromEntries(
  Object.entries(stock).map(([item, qty]) => [item, qty * 2])
);
console.log(doubled);

// keep only some keys
const inStock = Object.fromEntries(
  Object.entries(stock).filter(([, qty]) => qty > 0)
);
console.log(inStock);

const people = [
  { name: "Asha", team: "backend" },
  { name: "Ravi", team: "frontend" },
  { name: "Meera", team: "backend" },
];

// Object.groupBy sorts a list into buckets by the key you return
const byTeam = Object.groupBy(people, (p) => p.team);
console.log(Object.keys(byTeam));
console.log(byTeam.backend.map((p) => p.name));

"use strict";
const config = Object.freeze({ port: 3000, db: { host: "localhost" } });

try {
  config.port = 8080;               // not allowed on a frozen object
} catch (err) {
  console.log(err.constructor.name + ":", err.message);
}
config.db.host = "db.internal";     // freeze is shallow: inner objects can change
console.log(config.port, config.db.host);

const seal = Object.seal({ level: 1 });
seal.level = 2;                     // sealed: changing is fine
try { seal.extra = true; } catch (err) { console.log("seal blocks new keys"); }
console.log(seal, Object.isFrozen(config), Object.isSealed(seal));

const book = { title: "Dune", pages: 412, author: { name: "Frank" } };

// pull keys out into variables
const { title, pages } = book;
console.log(title, pages);

// rename, give a default, and reach inside
const { title: heading, rating = 4, author: { name } } = book;
console.log(heading, rating, name);

// rest collects the keys you did not name
const { pages: _, ...withoutPages } = book;
console.log(withoutPages);

const a = { x: 1 };
const b = { x: 1 };
const c = a;

console.log(a === b);   // false: two different boxes with the same inside
console.log(a === c);   // true: the same box

// a simple equal check for flat objects
const sameShape = (p, q) =>
  Object.keys(p).length === Object.keys(q).length &&
  Object.keys(p).every((k) => p[k] === q[k]);
console.log(sameShape(a, b), sameShape(a, { x: 2 }));

// defaults the app ships with, frozen so nobody changes them by mistake
const DEFAULTS = Object.freeze({ theme: "light", fontSize: 14, alerts: true });

// what one person saved, which may be partial
const saved = { fontSize: 18, alerts: false, oldKey: "x" };

// 1. merge: saved values win over defaults
const merged = { ...DEFAULTS, ...saved };

// 2. keep only keys the app knows about
const clean = Object.fromEntries(
  Object.entries(merged).filter(([key]) => Object.hasOwn(DEFAULTS, key))
);

// 3. list what this person changed
const changed = Object.keys(clean).filter((k) => clean[k] !== DEFAULTS[k]);

// 4. unpack what the page needs
const { theme, fontSize = 14 } = clean;

console.log(clean);
console.log("changed:", changed.join(", "));
console.log(`render ${theme} theme at ${fontSize}px`);