函式（Function）

什麼是函式？

比喻：函式就像一台果汁機 🍹

放入水果（參數）→ 果汁機運作（執行程式）→ 產出果汁（回傳值）。 你可以重複使用這台果汁機，不用每次都重新造一台。

函式宣告

// 方式 1：函式宣告（Function Declaration）
function greet(name) {            // ← 函式名稱 + 參數
    return `你好，${name}！`;      // ← return 回傳結果
}
console.log(greet("小明"));       // ← "你好，小明！"

// 方式 2：函式表達式（Function Expression）
const greet2 = function(name) {
    return `你好，${name}！`;
};

// 方式 3：箭頭函式（Arrow Function，ES6）
const greet3 = (name) => {
    return `你好，${name}！`;
};

// 箭頭函式簡寫（只有一行 return 時）
const greet4 = (name) => `你好，${name}！`;
// 只有一個參數時可以省略括號
const greet5 = name => `你好，${name}！`;

參數

// 預設參數（ES6）
function greet(name = "訪客") {   // ← 沒傳的話用預設值
    return `你好，${name}！`;
}
console.log(greet());             // ← "你好，訪客！"
console.log(greet("小明"));       // ← "你好，小明！"

// 剩餘參數（Rest Parameters）
function sum(...numbers) {        // ← ...numbers 收集所有參數成陣列
    let total = 0;
    for (let n of numbers) {
        total += n;
    }
    return total;
}
console.log(sum(1, 2, 3));        // ← 6
console.log(sum(1, 2, 3, 4, 5)); // ← 15

// 解構參數
function createUser({ name, age, email = "" }) {
    console.log(`${name}, ${age}歲`);
}
createUser({ name: "小明", age: 20 });

回傳值

// 單一回傳值
function add(a, b) {
    return a + b;                 // ← 回傳結果後，函式立刻結束
    console.log("這行不會執行");   // ← return 後的程式碼不會執行
}

// 回傳物件
function createUser(name, age) {
    return { name, age };         // ← ES6 簡寫：{ name: name, age: age }
}
let user = createUser("小明", 20);
console.log(user.name);          // ← "小明"

// 沒有 return → 回傳 undefined
function doSomething() {
    console.log("做了一些事");
    // 沒有 return
}
let result = doSomething();       // ← undefined

作用域（Scope）

let global = "我是全域變數";      // ← 全域：到處都能用

function outer() {
    let outerVar = "我是外層變數"; // ← 函式作用域

    function inner() {
        let innerVar = "我是內層變數";
        console.log(global);     // ✅ 可以存取全域
        console.log(outerVar);   // ✅ 可以存取外層
        console.log(innerVar);   // ✅ 可以存取自己的
    }

    inner();
    console.log(innerVar);       // ❌ Error：innerVar 在這裡不存在
}

閉包（Closure）

function createCounter() {
    let count = 0;                // ← 這個變數被「關」在閉包裡

    return {
        increment: () => ++count, // ← 可以存取外層的 count
        getCount: () => count     // ← 可以讀取 count
    };
}

const counter = createCounter();
console.log(counter.increment()); // ← 1
console.log(counter.increment()); // ← 2
console.log(counter.getCount());  // ← 2
// 外部無法直接存取 count，只能透過回傳的方法

高階函式

// 函式可以作為參數傳遞
function doOperation(a, b, operation) {
    return operation(a, b);       // ← 呼叫傳入的函式
}

const add = (a, b) => a + b;
const multiply = (a, b) => a * b;

console.log(doOperation(5, 3, add));       // ← 8
console.log(doOperation(5, 3, multiply));  // ← 15

// 函式可以作為回傳值
function multiplier(factor) {
    return (num) => num * factor;  // ← 回傳一個新函式
}
const double = multiplier(2);
const triple = multiplier(3);
console.log(double(5));           // ← 10
console.log(triple(5));           // ← 15