闭包

什么是闭包？举一个实际开发中的应用场景?

闭包是指在一个函数内部定义的函数可以访问其外部函数的变量，即使外部函数已经执行完毕并返回。闭包使得这些内部函数可以“记住”并继续访问其定义时的作用域。

闭包的一个实际应用场景是创建私有变量。通过闭包，可以在函数外部无法直接访问的情况下，维护和操作这些变量。

以下是一个实际开发中的应用场景：计数器。

function createCounter() {
    let count = 0; // 私有变量

    return {
        increment: function() {
            count++;
            return count;
        },
        decrement: function() {
            count--;
            return count;
        },
        getCount: function() {
            return count;
        }
    };
}

const counter = createCounter();

console.log(counter.increment()); // 输出: 1
console.log(counter.increment()); // 输出: 2
console.log(counter.decrement()); // 输出: 1
console.log(counter.getCount());  // 输出: 1

内存管理

闭包会导致外部函数的变量无法被垃圾回收，这是否可能引发内存泄漏？如何避免？

• 闭包会导致外部函数的变量无法被垃圾回收，因为闭包持有对这些变量的引用。这可能引发内存泄漏，尤其是在长时间运行的应用中。
• 避免方法：
  1. 及时释放引用：在不再需要闭包时，手动将引用置为null。
  2. 避免不必要的闭包：仅在需要时使用闭包，避免滥用。
  3. 使用WeakMap：在需要存储私有数据时，使用WeakMap可以避免内存泄漏。

function createClosure() {
    let largeData = new Array(1000000).fill('data');
    return function() {
        console.log(largeData.length);
    };
}

const closure = createClosure();
// 使用后释放引用
closure = null;

WeakMap如何帮助解决闭包导致的内存泄漏问题？

• WeakMap允许将对象作为键，并且不会阻止垃圾回收器回收这些对象。这样可以避免闭包导致的内存泄漏。

const privateData = new WeakMap();

function createObject() {
    const obj = {};
    privateData.set(obj, { secret: 'secret' });
    return obj;
}

const obj = createObject();
console.log(privateData.get(obj).secret); // 输出: secret

当obj不再被引用时，它会被垃圾回收器回收，privateData中的数据也会被释放

作用域链

闭包是如何通过作用域链访问外部函数变量的？能否画一个简单的示意图说明？

• 闭包通过作用域链访问外部函数的变量。每个函数都有一个作用域链，包含当前作用域和所有父作用域。闭包持有对其创建时的作用域链的引用，从而可以访问外部函数的变量。

Global Scope
  |
  | [global variables]
  |
Function A Scope
  |
  | [variables of Function A]
  |
Function B Scope (Closure)
  |
  | [variables of Function B]

模块化开发

在开发中，闭包如何与模块化（如ES6模块）结合使用？能否举个实际例子？

• 闭包可以与ES6模块结合使用来创建私有变量和方法。ES6模块本身提供了模块作用域，但闭包可以进一步封装私有数据。

// multiplier.js
export function createMultiplier(x) {
    return function(y) {
        return x * y;
    };
}

// main.js
import { createMultiplier } from './multiplier.js';

const double = createMultiplier(2);
console.log(double(5)); // 输出: 10

闭包与异步

在异步编程中（如setTimeout或Promise），闭包的行为是否有变化？能否举个例子说明？

• 在异步编程中，闭包的行为没有变化。闭包仍然可以访问创建时的作用域链中的变量。

function createAsyncClosure() {
    let count = 0;
    setTimeout(() => {
        count++;
        console.log(count); // 输出: 1
    }, 1000);
}

createAsyncClosure();

闭包的替代方案

除了闭包，还有什么其他方式可以实现私有变量？（如ES6的Symbol或WeakMap）

• 除了闭包，还可以使用ES6的Symbol或WeakMap实现私有变量。
• 使用Symbol:

const _private = Symbol('private');

class MyClass {
    constructor() {
        this[_private] = 'secret';
    }

    getPrivate() {
        return this[_private];
    }
}

const instance = new MyClass();
console.log(instance.getPrivate()); // 输出: secret

• 使用WeakMap：

const privateData = new WeakMap();

class MyClass {
    constructor() {
        privateData.set(this, { secret: 'secret' });
    }

    getPrivate() {
        return privateData.get(this).secret;
    }
}

const instance = new MyClass();
console.log(instance.getPrivate()); // 输出: secret

coding