JS 算法學習復盤
閉包、高階函式與那些坑

function makeCounter() {
  let n = 0;          // 這個 n 被內層函式「記住」

  return function() {
    return n++;       // 先回傳 n 的當前值，然後 n 才加 1
  };
}

const counter = makeCounter();
console.log(counter()); // 0  ← 回傳 0，n 變成 1
console.log(counter()); // 1  ← 回傳 1，n 變成 2
console.log(counter()); // 2  ← 回傳 2，n 變成 3

// 物件字面值：{ key: value }
// value 可以是任何東西，包含函式（方法）

const expect = (val) => {
  return {
    // toBe 是 key，後面的箭頭函式是 value
    toBe: (expected) => {
      if (val !== expected) throw new Error("Not Equal");
      return true;
    },
    // notToBe 也是一個 key，value 同樣是函式
    notToBe: (expected) => {
      if (val === expected) throw new Error("Equal");
      return true;
    },
  };
};

// 鏈式呼叫：expect(5).toBe(5) → true
// expect(5).notToBe(6) → true

// ...args 收集所有參數成陣列
const argumentsLength = (...args) => args.length;

argumentsLength(1, 2, 3);        // 3
argumentsLength("a", "b");       // 2
argumentsLength();               // 0

// ⚠️ 舊寫法：arguments 物件（類陣列，不是真正的陣列）
function old() {
  console.log(arguments);      // Arguments [1, 2, 3]
  console.log(arguments.length); // 3
  // arguments.map(...)  ← 這會報錯！不是真陣列
}

// ✅ 現代寫法：用 rest params，是真正的陣列
const modern = (...args) => {
  args.map(x => x * 2); // ✅ 可以用所有陣列方法
};

const compose = (functions) => {
  // 如果沒有函式，就直接回傳輸入值
  if (functions.length === 0) return (x) => x;

  return function(x) {
    // reduceRight 從陣列最後一個元素開始往左走
    // 每次把上一輪的結果餵給下一個函式
    return functions.reduceRight(
      (result, fn) => fn(result),
      x  // 初始值是 x
    );
  };
};

// 使用範例
const double = (x) => x * 2;
const addOne = (x) => x + 1;
const square = (x) => x * x;

// compose([double, addOne, square])(4)
// = double(addOne(square(4)))
// = double(addOne(16))
// = double(17)
// = 34