Đối tượng, prototype và lớp

const user = {
  name: 'Anh',
  age: 22,
  isAdmin: false,
  greet: function() {
    return `Xin chào ${this.name}`;
  }
};

console.log(user.name);     // 'Anh'
console.log(user.greet());  // 'Xin chào Anh'

const name = 'Anh';
const age = 22;

// Cũ — lặp
const u1 = { name: name, age: age };

// Mới — shorthand
const u2 = { name, age };

// Dùng trong return
function makeUser(name, age) {
  return { name, age, createdAt: Date.now() };
}

const field = 'email';

const form = {
  [field]: 'anh@example.com',
  [`${field}_verified`]: true,
  [Symbol.for('id')]: 42
};

console.log(form.email);          // 'anh@example.com'
console.log(form.email_verified); // true

// Cũ
const api1 = {
  fetch: function() { return fetch('/api'); }
};

// Mới — method shorthand
const api2 = {
  fetch() { return fetch('/api'); },
  async load() { return await fetch('/api'); },
  *ids() { yield 1; yield 2; }
};

const user = { name: 'Anh', 'full name': 'Quách Việt Anh' };

// Dot — key là identifier hợp lệ
user.name;                // 'Anh'

// Bracket — bắt buộc khi key có khoảng trắng
user['full name'];        // 'Quách Việt Anh'

// Bracket — key động (dynamic key)
const field = 'name';
user[field];              // 'Anh'

// Truy cập property không tồn tại → undefined (không phải lỗi)
user.age;                 // undefined

const user = { name: 'Anh', address: null };

// Không có ?. — crash
user.address.city;
// TypeError: Cannot read properties of null

// Có ?. — short-circuit, trả undefined
user.address?.city;       // undefined ✅

// Chain nhiều cấp
user.address?.geo?.lat;   // undefined ✅

// ?. trên method — chỉ gọi nếu tồn tại
user.greet?.();          // undefined (greet không tồn tại)

// ?. trên bracket access
user.address?.['city'];   // undefined

const config = { volume: 0, label: '' };

// || coi 0 là falsy → trả default sai
config.volume || 50;        // 50 (sai — 0 là hợp lệ)

// ?? chỉ trả default khi null/undefined
config.volume ?? 50;        // 0 ✅
config.label ?? '(no label)'; // '' ✅
config.missing ?? 'fallback'; // 'fallback'

// Primitive — copy giá trị
let a = 5;
let b = a;      // b = 5 (copy độc lập)
b = 10;
console.log(a); // 5 — a không đổi
console.log(b); // 10

// Object — copy tham chiếu (cùng địa chỉ)
const a = { x: 1 };
const b = a;          // b trỏ về cùng object với a

b.x = 99;             // Mutate qua b

console.log(a.x);    // 99 ← a thấy luôn (cùng object)
console.log(a === b); // true (cùng reference)

{} === {};            // false — 2 object khác nhau
[] === [];            // false

const x = {};
const y = x;
x === y;              // true — cùng reference

// Object truyền vào function cũng là reference
function addAge(u) { u.age = 22; }
const me = { name: 'Anh' };
addAge(me);
console.log(me.age); // 22 — function mutate object gốc

const user = { name: 'Anh', age: 22, role: 'admin' };

Object.keys(user);
// ['name', 'age', 'role']

Object.values(user);
// ['Anh', 22, 'admin']

Object.entries(user);
// [['name','Anh'], ['age',22], ['role','admin']]

// Loop qua entries
for (const [k, v] of Object.entries(user)) {
  console.log(`${k}: ${v}`);
}

const base = { a: 1, b: 2 };
const extra = { b: 99, c: 3 };

// Spread — tạo object mới
const merged1 = { ...base, ...extra };
// { a: 1, b: 99, c: 3 } — extra ghi đè b

// Object.assign — mutate target
const target = {};
Object.assign(target, base, extra);
// target === { a: 1, b: 99, c: 3 }

// Pattern phổ biến: override một field
const user = { name: 'Anh', age: 22 };
const updated = { ...user, age: 23 };
// { name: 'Anh', age: 23 } — immutable update

const config = Object.freeze({
  apiUrl: 'https://api.example.com',
  timeout: 5000
});

config.apiUrl = 'hacked';     // Silent fail (hoặc throw ở strict mode)
console.log(config.apiUrl); // 'https://api.example.com' — không đổi

Object.isFrozen(config);    // true

const user = { name: 'Anh', age: 22, password: 'secret' };

// Loại bỏ password
const safe = Object.fromEntries(
  Object.entries(user).filter(([k]) => k !== 'password')
);
// { name: 'Anh', age: 22 }

// Map → uppercase keys
const upper = Object.fromEntries(
  Object.entries(user).map(([k, v]) => [k.toUpperCase(), v])
);
// { NAME: 'Anh', AGE: 22, PASSWORD: 'secret' }

// Convert Map → object
const m = new Map([['a', 1], ['b', 2]]);
Object.fromEntries(m); // { a: 1, b: 2 }

const parent = { greet() { return 'hi'; } };
const child  = Object.create(parent);
child.name = 'Anh';

child.name;            // 'Anh' — tìm thấy ngay trên child
child.greet();         // 'hi'  — leo lên parent
child.toString();      // '[object Object]' — leo lên Object.prototype
child.foo;             // undefined — hết chain

Object.getPrototypeOf(child) === parent; // true

const animal = {
  eat() { return `${this.name} đang ăn`; }
};

const dog = Object.create(animal);
dog.name = 'Lulu';
dog.bark = () => 'Woof!';

dog.eat();   // 'Lulu đang ăn' — kế thừa eat từ animal
dog.bark();  // 'Woof!'

// Tạo object KHÔNG có prototype — không kế thừa từ Object.prototype
const dict = Object.create(null);
dict.x = 1;
dict.toString;  // undefined! — không có Object.prototype.toString

class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `Xin chào ${this.name}`;
  }
}

const u = new User('Anh', 22);
u.greet();                            // 'Xin chào Anh'

// Behind the scenes:
u.__proto__ === User.prototype;     // true
typeof User;                          // 'function' (!!)
User.prototype.greet;                // [Function: greet]

class Counter {
  count = 0;                // class field — public, init khi new
  step  = 1;

  increment() {
    this.count += this.step;
  }
}

const c = new Counter();
c.increment();
c.count; // 1

class User {
  static count = 0;            // static field

  constructor(name) {
    this.name = name;
    User.count++;
  }

  static makeAdmin(name) {     // factory method
    const u = new User(name);
    u.isAdmin = true;
    return u;
  }
}

const a = new User('Anh');
const b = User.makeAdmin('Bình');

User.count;        // 2
a.count;            // undefined — static không nằm trên instance
a.makeAdmin;        // undefined

class User {
  constructor(first, last) {
    this.first = first;
    this.last  = last;
  }

  get fullName() {
    return `${this.first} ${this.last}`;
  }

  set fullName(value) {
    if (typeof value !== 'string') {
      throw new TypeError('fullName phải là string');
    }
    [this.first, this.last] = value.split(' ');
  }
}

const u = new User('Anh', 'Quách');
u.fullName;                  // 'Anh Quách' — gọi getter
u.fullName = 'Bình Trần';     // gọi setter
u.first;                     // 'Bình'

class User {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `Hi ${this.name}`;
  }
}

class Admin extends User {
  constructor(name, level) {
    super(name);            // PHẢI gọi trước khi dùng this
    this.level = level;
  }

  greet() {
    return super.greet() + ` (lv ${this.level})`;
  }
}

const a = new Admin('Anh', 3);
a.greet();              // 'Hi Anh (lv 3)'
a instanceof Admin; // true
a instanceof User;  // true (chain qua User)

class BankAccount {
  #balance = 0;          // private — chỉ truy cập trong class

  deposit(amount) {
    if (amount <= 0) throw new Error('amount > 0');
    this.#balance += amount;
  }

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

const acc = new BankAccount();
acc.deposit(100);
acc.balance;       // 100 ✅
acc.#balance;      // SyntaxError — không thể truy cập từ ngoài
acc['#balance'];   // undefined — không phải string key thường

// Các capability riêng lẻ — đều là object trả ra method
const canEat = (state) => ({
  eat(food) { state.energy += 10; return `${state.name} ăn ${food}`; }
});

const canWalk = (state) => ({
  walk() { state.energy -= 5; return `${state.name} đi bộ`; }
});

const canSwim = (state) => ({
  swim() { state.energy -= 15; return `${state.name} bơi`; }
});

// Ghép tùy ý — không cần class hierarchy
function createDuck(name) {
  const state = { name, energy: 100 };
  return { ...state, ...canEat(state), ...canWalk(state), ...canSwim(state) };
}

const d = createDuck('Donald');
d.eat('cá');   // 'Donald ăn cá'
d.swim();      // 'Donald bơi'