Hàm, phạm vi và bao đóng

function add(a, b) {
  return a + b;
}

add(2, 3);  // 5

// Hoisted toàn bộ — gọi trước dòng khai báo vẫn chạy:
sayHi();          // 'Xin chào!' ← vẫn chạy
function sayHi() {
  console.log('Xin chào!');
}

// Anonymous
const add = function(a, b) {
  return a + b;
};

// Named (tên chỉ dùng được bên trong function — hữu ích cho recursion + debug)
const fact = function factorial(n) {
  return n <= 1 ? 1 : n * factorial(n - 1);
};

// KHÔNG hoisted — gọi trước dòng khai báo lỗi:
greet();  // ReferenceError (let/const) hoặc TypeError (var)
const greet = function() { console.log('hi'); };

// Body block
const add = (a, b) => {
  return a + b;
};

// Body biểu thức — implicit return (không cần `return` keyword)
const add2 = (a, b) => a + b;

// 1 tham số — bỏ ngoặc
const square = x => x * x;

// 0 tham số — vẫn cần ngoặc rỗng
const hi = () => console.log('hi');

// Trả về object literal — phải bọc ngoặc tròn để JS không hiểu là block
const point = (x, y) => ({ x, y });

// Multi-line body block:
const processUser = (user) => {
  const name = user.name.trim();
  const age = user.age ?? 0;
  return { name, age };
};

// Cách cũ:
const user = {
  name: 'An',
  greet: function() { console.log(this.name); }
};

// Shorthand ES6:
const user2 = {
  name: 'An',
  greet() { console.log(this.name); }   // ← bỏ `: function`
};

// Trong class:
class User {
  constructor(name) { this.name = name; }
  greet() { console.log(this.name); }
}

// 1. Gán cho biến
const double = x => x * 2;

// 2. Truyền làm argument — callback
[1, 2, 3].map(double);   // [2, 4, 6]

// 3. Return function — higher-order function
function multiplier(n) {
  return x => x * n;     // trả về function
}
const triple = multiplier(3);
triple(10);  // 30

// 4. Lưu trong array/object
const ops = [
  x => x + 1,
  x => x * 2,
  x => x - 3,
];
const result = ops.reduce((acc, fn) => fn(acc), 10);
// (10+1)*2 - 3 = 19

const handlers = {
  onClick: () => console.log('click'),
  onHover: () => console.log('hover'),
};
handlers.onClick();

function greet(name = 'khách', greeting = 'Xin chào') {
  return `${greeting}, ${name}!`;
}

greet();                // 'Xin chào, khách!'
greet('An');            // 'Xin chào, An!'
greet('An', 'Chào');    // 'Chào, An!'

// Quan trọng: default chỉ áp dụng với `undefined`, KHÔNG với `null`
greet(null);            // 'Xin chào, null!' 🔥 (null không trigger default)
greet(undefined);       // 'Xin chào, khách!'

// Default có thể là biểu thức, thậm chí gọi function khác:
function log(msg, time = Date.now()) {
  console.log(time, msg);
}

function sum(...nums) {
  return nums.reduce((a, b) => a + b, 0);
}

sum(1, 2, 3);          // 6
sum(1, 2, 3, 4, 5);    // 15

// Kết hợp tham số thường + rest (rest phải ở CUỐI):
function tag(label, ...items) {
  return `${label}: ${items.join(', ')}`;
}
tag('fruits', 'apple', 'banana');  // 'fruits: apple, banana'

// So với arguments cũ:
function oldSum() {
  // arguments là array-like, không có .reduce/.map
  const arr = Array.from(arguments);
  return arr.reduce((a, b) => a + b, 0);
}

// Object destructuring
function createUser({ name, age = 18, role = 'user' }) {
  return { name, age, role };
}

createUser({ name: 'An', age: 25 });
// { name: 'An', age: 25, role: 'user' }

// Default cho cả object (tránh lỗi destructure undefined)
function init({ debug = false } = {}) {
  return debug;
}
init();           // false (không lỗi nhờ `= {}`)

// Array destructuring
function swap([a, b]) {
  return [b, a];
}
swap([1, 2]);   // [2, 1]

// Rename khi destructure
function printName({ name: fullName }) {
  console.log(fullName);
}

const user = {
  name: 'An',
  hobbies: ['code', 'gym'],

  // ❌ Function thường: this = undefined trong callback
  printBad() {
    this.hobbies.forEach(function(h) {
      console.log(this.name, h);  // `this` ở đây ≠ user
    });
  },

  // ✅ Arrow: kế thừa this từ printGood
  printGood() {
    this.hobbies.forEach(h => {
      console.log(this.name, h);  // `this` = user
    });
  },
};

function normal() {
  console.log(arguments);  // Arguments(3) [1, 2, 3]
}
normal(1, 2, 3);

const arrow = () => {
  console.log(arguments);  // ReferenceError (hoặc kế thừa từ scope ngoài nếu có)
};

// Thay thế: dùng rest params
const arrowFix = (...args) => console.log(args);
arrowFix(1, 2, 3);  // [1, 2, 3] (array thực)

function Point(x, y) {
  this.x = x;
  this.y = y;
}
const p = new Point(1, 2);  // OK

const ArrowPoint = (x, y) => {
  this.x = x;
};
new ArrowPoint(1, 2);  // ❌ TypeError: ArrowPoint is not a constructor

function foo() {}
console.log(foo.prototype);    // { constructor: foo }

const bar = () => {};
console.log(bar.prototype);    // undefined

'use strict';

function show() {
  console.log(this);
}

show();   // strict: undefined; sloppy: window/global

// Hidden case — vẫn là default binding:
const obj = {
  name: 'An',
  greet() { console.log(this); }
};
const fn = obj.greet;
fn();    // undefined — vì không có obj. trước fn()

const user = {
  name: 'An',
  greet() { console.log(this.name); }
};

user.greet();   // 'An' (this = user)

// Chain — `this` luôn là object cuối cùng trước dấu chấm:
const a = { name: 'A', fn: user.greet };
const b = { name: 'B', inner: a };

b.inner.fn();  // 'A' (this = a, không phải b)

function greet(greeting, punct) {
  console.log(`${greeting}, ${this.name}${punct}`);
}

const user = { name: 'An' };

// call(thisArg, ...args)
greet.call(user, 'Xin chào', '!');  // 'Xin chào, An!'

// apply(thisArg, [args])
greet.apply(user, ['Chào', '.']);    // 'Chào, An.'

// bind(thisArg, ...args) — trả về function MỚI, không gọi ngay
const greetAn = greet.bind(user, 'Hi');
greetAn('?');   // 'Hi, An?'
greetAn('!');   // 'Hi, An!' (this đã bị "khóa" với user vĩnh viễn)

function User(name) {
  // this = {} mới
  this.name = name;
  // return this ngầm
}

const u = new User('An');
console.log(u);  // User { name: 'An' }

const obj = {
  name: 'An',
  arrow: () => console.log(this?.name),
  regular() { console.log(this.name); }
};

obj.arrow();    // undefined (this kế thừa từ global, không phải obj)
obj.regular();  // 'An'

// Cả bind cũng KHÔNG đổi được this của arrow:
const bound = obj.arrow.bind({ name: 'B' });
bound();           // vẫn undefined

const g = 'global';          // global scope

function outer() {
  const f = 'function';      // function scope

  if (true) {
    var   v = 'var-in-block';  // FUNCTION scope (var ignore block!)
    let   l = 'let-in-block';  // block scope
    const c = 'const-in-block'; // block scope
  }

  console.log(v);  // 'var-in-block' ← var leak ra function
  console.log(l);  // ReferenceError
  console.log(c);  // ReferenceError
}

const a = 1;          // global

function outer() {
  const b = 2;        // outer

  function inner() {
    const c = 3;      // inner
    console.log(a, b, c);  // 1 2 3 — chain: inner → outer → global
  }
  inner();
}
outer();

// ✅ Function declaration — hoist full
sayHi();   // 'hi'
function sayHi() { console.log('hi'); }

// ⚠️  var + function expression — chỉ hoist tên
sayHo();   // ❌ TypeError: sayHo is not a function
var sayHo = function() { console.log('ho'); };
// Lúc gọi: sayHo là undefined → undefined() → TypeError

// ❌ const/let arrow — TDZ
sayHey();  // ❌ ReferenceError: Cannot access 'sayHey' before initialization
const sayHey = () => console.log('hey');

function makeCounter() {
  let n = 0;             // biến local của makeCounter
  return () => ++n;     // inner function "đóng gói" biến n
}

const c1 = makeCounter();
c1();  // 1
c1();  // 2
c1();  // 3 — n vẫn tồn tại sau khi makeCounter return!

const c2 = makeCounter();  // scope mới, n mới
c2();  // 1 — c1 và c2 độc lập
c1();  // 4

function createAccount(initialBalance) {
  let balance = initialBalance;   // private — không cách nào truy cập trực tiếp

  return {
    deposit(amount) { balance += amount; },
    withdraw(amount) {
      if (amount > balance) throw new Error('Insufficient');
      balance -= amount;
    },
    getBalance() { return balance; }
  };
}

const acc = createAccount(100);
acc.deposit(50);
acc.getBalance();   // 150
acc.balance;        // undefined — không có property này

function multiplier(factor) {
  return x => x * factor;
}

const double = multiplier(2);
const triple = multiplier(3);
const half   = multiplier(0.5);

[1, 2, 3].map(double);  // [2, 4, 6]
[10, 20].map(half);     // [5, 10]

function memoize(fn) {
  const cache = new Map();   // private cache, sống cùng wrapped fn
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

const slowSquare = (n) => {
  for (let i = 0; i < 1e7; i++) {}  // giả lập chậm
  return n * n;
};

const fastSquare = memoize(slowSquare);
fastSquare(5);   // chậm lần đầu
fastSquare(5);   // instant — đọc cache

function once(fn) {
  let called = false;
  let result;
  return (...args) => {
    if (!called) {
      result = fn(...args);
      called = true;
    }
    return result;
  };
}

const init = once(() => console.log('Khởi tạo'));
init();   // 'Khởi tạo'
init();   // (không in gì, trả lại undefined cached)

// Curry thủ công cho 3 tham số:
const add = a => b => c => a + b + c;
add(1)(2)(3);   // 6

// Curry tự động cho bất kỳ arity:
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...next) => curried(...args, ...next);
  };
}

const sum3 = (a, b, c) => a + b + c;
const curriedSum = curry(sum3);

curriedSum(1)(2)(3);   // 6
curriedSum(1, 2)(3);   // 6
curriedSum(1)(2, 3);   // 6
curriedSum(1, 2, 3);   // 6

// Cú pháp truyền thống — bọc trong ngoặc
(function() {
  const secret = 42;   // scope riêng, không leak ra global
  console.log(secret);
})();

// Arrow IIFE
(() => {
  const x = 1;
  console.log(x);
})();

// Truyền argument vào IIFE
((name) => {
  console.log(`Hello ${name}`);
})('JS');

// Trả về giá trị
const config = (() => {
  const env = process.env.NODE_ENV;
  return { debug: env !== 'production' };
})();