// 函数声明（会被提升）
function add(a, b) {
    return a + b;
}

// 函数表达式
var multiply = function(a, b) {
    return a * b;
};

// 命名函数表达式（用于递归和调试）
var factorial = function fact(n) {
    return n <= 1 ? 1 : n * fact(n - 1);
};

// 立即执行函数表达式（IIFE）
var result = (function() {
    var secret = 42;
    return secret * 2;
})();

// 函数可以赋值给变量
var greet = function(name) { return "Hello, " + name; };

// 函数可以作为参数
function apply(fn, x) { return fn(x); }
apply(Math.abs, -5);  // 5

// 函数可以作为返回值
function makeAdder(x) {
    return function(y) { return x + y; };
}
var add5 = makeAdder(5);
add5(3);  // 8

// 函数可以拥有属性
function counter() {
    counter.count = (counter.count || 0) + 1;
    return counter.count;
}
counter();  // 1
counter();  // 2
counter.count;  // 2

// 闭包的基本形式
function outer() {
    var x = 10;
    function inner() {
        console.log(x);  // inner 可以访问 outer 的变量
    }
    return inner;
}

var fn = outer();
fn();  // 10（即使 outer 已经返回，x 仍然存在）

// 闭包实现计数器
function createCounter(initial) {
    var count = initial || 0;
    return {
        increment: function() { return ++count; },
        decrement: function() { return --count; },
        getCount: function() { return count; }
    };
}

var c = createCounter(10);
c.increment();  // 11
c.increment();  // 12
c.decrement();  // 11
c.getCount();   // 11
// count 变量对外部不可见

// 闭包实现私有方法
function Container(spec) {
    var privateValue = spec.value;
    
    function privateMethod() {
        return "private: " + privateValue;
    }
    
    return {
        getPublicValue: function() { return privateValue; },
        setPublicValue: function(v) { privateValue = v; },
        callPrivate: function() { return privateMethod(); }
    };
}

var container = Container({value: 42});
container.getPublicValue();  // 42
container.callPrivate();     // "private: 42"
// container.privateMethod();  // TypeError

// 1. 默认绑定（全局或 undefined）
function foo() {
    console.log(this);  // 非严格模式：window；严格模式：undefined
}
foo();

// 2. 隐式绑定（对象方法调用）
var obj = {
    name: "Alice",
    greet: function() {
        console.log("Hello, " + this.name);
    }
};
obj.greet();  // "Hello, Alice"

// 3. 显式绑定（call/apply/bind）
var greetFn = obj.greet;
greetFn.call({name: "Bob"});    // "Hello, Bob"
greetFn.apply({name: "Charlie"});  // "Hello, Charlie"

var boundGreet = greetFn.bind({name: "Dave"});
boundGreet();  // "Hello, Dave"

// 4. new 绑定
function Person(name) {
    this.name = name;  // this 指向新创建的对象
}
var p = new Person("Eve");
p.name;  // "Eve"

// 箭头函数没有自己的 this
var obj2 = {
    name: "Alice",
    greet: function() {
        // 箭头函数继承外层的 this
        setTimeout(() => {
            console.log("Hello, " + this.name);
        }, 100);
    }
};

// 模块模式（使用 IIFE）
var MathUtils = (function() {
    // 私有变量和方法
    var PI = 3.14159265358979;
    
    function validateNumber(n) {
        if (typeof n !== "number") {
            throw new TypeError("Expected a number");
        }
    }
    
    // 公共 API
    return {
        circleArea: function(radius) {
            validateNumber(radius);
            return PI * radius * radius;
        },
        circleCircumference: function(radius) {
            validateNumber(radius);
            return 2 * PI * radius;
        },
        degreesToRadians: function(degrees) {
            validateNumber(degrees);
            return degrees * PI / 180;
        }
    };
})();

MathUtils.circleArea(5);  // 78.53981633974483
// MathUtils.PI;  // undefined（私有）

// 回调函数
function fetchData(url, callback) {
    // 模拟异步操作
    setTimeout(function() {
        var data = {url: url, content: "Hello"};
        callback(null, data);
    }, 1000);
}

fetchData("/api/data", function(error, data) {
    if (error) {
        console.error(error);
    } else {
        console.log(data);
    }
});

// 高阶函数
function map(array, fn) {
    var result = [];
    for (var i = 0; i < array.length; i++) {
        result.push(fn(array[i], i, array));
    }
    return result;
}

function filter(array, predicate) {
    var result = [];
    for (var i = 0; i < array.length; i++) {
        if (predicate(array[i], i, array)) {
            result.push(array[i]);
        }
    }
    return result;
}

function reduce(array, fn, initial) {
    var acc = initial;
    for (var i = 0; i < array.length; i++) {
        acc = fn(acc, array[i], i, array);
    }
    return acc;
}

// 使用
var numbers = [1, 2, 3, 4, 5];
map(numbers, function(n) { return n * 2; });      // [2, 4, 6, 8, 10]
filter(numbers, function(n) { return n > 3; });    // [4, 5]
reduce(numbers, function(sum, n) { return sum + n; }, 0);  // 15

// 柯里化
function curry(fn) {
    var arity = fn.length;
    return function curried() {
        var args = Array.prototype.slice.call(arguments);
        if (args.length >= arity) {
            return fn.apply(this, args);
        }
        return function() {
            var moreArgs = Array.prototype.slice.call(arguments);
            return curried.apply(this, args.concat(moreArgs));
        };
    };
}

var add = curry(function(a, b, c) { return a + b + c; });
add(1)(2)(3);     // 6
add(1, 2)(3);     // 6
add(1)(2, 3);     // 6

// 组合
function compose() {
    var fns = Array.prototype.slice.call(arguments);
    return function(x) {
        return fns.reduceRight(function(acc, fn) {
            return fn(acc);
        }, x);
    };
}

var double = function(x) { return x * 2; };
var square = function(x) { return x * x; };
var addOne = function(x) { return x + 1; };

var transform = compose(addOne, square, double);
transform(3);  // 37 ((3*2)^2 + 1)

function memoize(fn) {
    var cache = {};
    return function() {
        var key = JSON.stringify(arguments);
        if (cache[key] === undefined) {
            cache[key] = fn.apply(this, arguments);
        }
        return cache[key];
    };
}

// 使用记忆化优化递归
var fibonacci = memoize(function(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
});

fibonacci(50);  // 瞬间完成（不使用记忆化会非常慢）