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

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

// 箭头函数
const subtract = (a, b) => a - b;
const square = x => x * x;

// 默认参数
function greet(name = "Guest") {
  console.log(`Hello, ${name}!`);
}

// 剩余参数
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4));  // 10

// 闭包：函数记住并访问其词法作用域
function counter() {
  let count = 0;
  return {
    increment: () => ++count,
    decrement: () => --count,
    getCount: () => count
  };
}

const c = counter();
c.increment();
c.increment();
console.log(c.getCount());  // 2

// 闭包实现私有变量
function createBankAccount(initialBalance) {
  let balance = initialBalance;
  
  return {
    deposit(amount) {
      balance += amount;
      return balance;
    },
    withdraw(amount) {
      if (amount > balance) throw new Error("Insufficient funds");
      balance -= amount;
      return balance;
    },
    getBalance() {
      return balance;
    }
  };
}

const account = createBankAccount(1000);
account.deposit(500);
console.log(account.getBalance());  // 1500

// 闭包在循环中的应用
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);  // 0, 1, 2（let有块级作用域）
}

// 使用IIFE创建模块
const module = (function() {
  let privateVar = 0;
  
  return {
    increment() { privateVar++; },
    getValue() { return privateVar; }
  };
})();

// 全局上下文
console.log(this);  // 浏览器中是window

// 对象方法
let obj = {
  name: "Alice",
  greet() {
    console.log(`Hello, ${this.name}`);
  },
  greetArrow: () => {
    console.log(`Hello, ${this.name}`);  // this指向外层
  }
};
obj.greet();       // "Hello, Alice"
obj.greetArrow();  // "Hello, undefined"

// call, apply, bind
function introduce(greeting) {
  console.log(`${greeting}, I'm ${this.name}`);
}

let person = {name: "Bob"};
introduce.call(person, "Hi");       // "Hi, I'm Bob"
introduce.apply(person, ["Hey"]);   // "Hey, I'm Bob"

let boundIntroduce = introduce.bind(person);
boundIntroduce("Hello");  // "Hello, I'm Bob"

// 在事件处理中
class Button {
  constructor(element) {
    this.clickCount = 0;
    element.addEventListener('click', () => {
      this.clickCount++;  // 箭头函数保持this
    });
  }
}

// 接受函数作为参数
function applyOperation(a, b, operation) {
  return operation(a, b);
}
console.log(applyOperation(5, 3, (a, b) => a + b));  // 8

// 返回函数
function multiplier(factor) {
  return function(x) {
    return x * factor;
  };
}
const triple = multiplier(3);
console.log(triple(5));  // 15

// 函数组合
const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

const transform = pipe(addOne, double, square);
console.log(transform(3));  // (3+1)*2=8, 8*8=64

// 柯里化
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    }
    return function(...args2) {
      return curried.apply(this, [...args, ...args2]);
    };
  };
}

const curriedAdd = curry((a, b, c) => a + b + c);
console.log(curriedAdd(1)(2)(3));  // 6
console.log(curriedAdd(1, 2)(3));  // 6

const data = [
  {name: "Alice", department: "Engineering", salary: 90000},
  {name: "Bob", department: "Marketing", salary: 75000},
  {name: "Charlie", department: "Engineering", salary: 95000},
  {name: "David", department: "Marketing", salary: 80000},
  {name: "Eve", department: "Engineering", salary: 85000}
];

// 函数式数据处理管道
const result = data
  .filter(emp => emp.department === "Engineering")
  .map(emp => ({...emp, bonus: emp.salary * 0.1}))
  .sort((a, b) => b.salary - a.salary);

console.log(result);

// 分组函数
function groupBy(arr, keyFn) {
  return arr.reduce((acc, item) => {
    const key = keyFn(item);
    (acc[key] = acc[key] || []).push(item);
    return acc;
  }, {});
}

const byDept = groupBy(data, emp => emp.department);
console.log(byDept);