函数进阶

函数声明方式

1. 函数声明

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

2. 函数表达式

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

3. 箭头函数

const add = (a, b) => a + b;
const greet = name => `Hello, ${name}!`;
const getObject = () => ({ name: 'John' });

函数参数

1. 默认参数

function greet(name = 'Guest') {
    return `Hello, ${name}!`;
}

const multiply = (a, b = 1) => a * b;

2. 剩余参数

function sum(...numbers) {
    return numbers.reduce((total, num) => total + num, 0);
}

const log = (message, ...args) => {
    console.log(message, ...args);
};

3. 解构参数

function printUser({ name, age, city = 'Unknown' }) {
    console.log(`${name} is ${age} years old and lives in ${city}`);
}

const user = { name: 'John', age: 30 };
printUser(user);

函数作用域

1. 词法作用域

const name = 'Global';
function outer() {
    const name = 'Outer';
    function inner() {
        const name = 'Inner';
        console.log(name); // 'Inner'
    }
    inner();
    console.log(name); // 'Outer'
}
outer();
console.log(name); // 'Global'

2. 闭包

function createCounter() {
    let count = 0;
    return {
        increment() { count++; },
        decrement() { count--; },
        getCount() { return count; }
    };
}

const counter = createCounter();
counter.increment();
console.log(counter.getCount()); // 1

函数调用方式

1. 方法调用

const person = {
    name: 'John',
    greet() {
        console.log(`Hello, ${this.name}!`);
    }
};
person.greet();

2. 构造函数调用

function Person(name) {
    this.name = name;
}
const person = new Person('John');

3. 间接调用

function greet() {
    console.log(`Hello, ${this.name}!`);
}
const person = { name: 'John' };
greet.call(person);
greet.apply(person);
const boundGreet = greet.bind(person);
boundGreet();

高阶函数

1. 函数作为参数

function filter(array, predicate) {
    return array.filter(predicate);
}

const numbers = [1, 2, 3, 4, 5];
const evenNumbers = filter(numbers, num => num % 2 === 0);

2. 函数作为返回值

function multiply(x) {
    return function(y) {
        return x * y;
    };
}

const multiplyByTwo = multiply(2);
console.log(multiplyByTwo(3)); // 6

异步函数

1. Promise

function fetchData() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Data fetched');
        }, 1000);
    });
}

fetchData()
    .then(data => console.log(data))
    .catch(error => console.error(error));

2. async/await

async function fetchData() {
    try {
        const response = await fetch('https://api.example.com/data');
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error:', error);
    }
}

函数式编程

1. 纯函数

// 纯函数
function add(a, b) {
    return a + b;
}

// 非纯函数
let total = 0;
function addToTotal(num) {
    total += num;
    return total;
}

2. 函数组合

const compose = (...fns) => 
    fns.reduce((f, g) => (...args) => f(g(...args)));

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

const calculate = compose(square, multiplyByTwo, addOne);
console.log(calculate(3)); // 64

最佳实践

1. 使用箭头函数保持简洁
2. 优先使用 const 声明函数
3. 使用默认参数代替条件判断
4. 使用解构参数提高可读性
5. 避免使用 arguments 对象
6. 使用 async/await 处理异步
7. 使用纯函数避免副作用
8. 合理使用闭包避免内存泄漏