不知道的 JavaScript 之作用域、词法作用域、闭包

1. 编译

JS 任何代码在执行前都要编译，编译通常发生在执行前几微秒，尽管一般将 js 归为“解释执行”的语言，但实际上它是一门编译语言。
变量的赋值操作：

编译器在当前作用域中声明一个变量（如果之前没有声明过）；
运行时引擎会在作用域中查找这个变量，如果能找到就对它赋值。

2. 作用域

作用域是根据名称查找变量的一套规则，如果查找的目的是对变量进行赋值，会用 LHS 查询，如果目的是取变量的值，会使用 RHS 查询。

欺骗作用域

如果词法作用域完全由写代码时函数所声明的位置来定义，那么怎样才能在运行时来“修改”（欺骗）词法作用域呢？
欺骗词法会导致性能下降，

eval → eval 如果接受了含有一个或多个声明的代码，会修改其所在的词法作用域。
with → with 声明根据传递给它的对象凭空创造了一个全新的词法作用域。
with 可以将一个没有或有多个属性的对象处理为一个完全隔离的词法作用域，因此这个对象的属性也会被处理为定义在这个作用域中的词法标识符。

JS 引擎在编译阶段会进行数项的性能优化，其中有些优化依赖于能够根据代码的词法进行静态分析，并预先确定所有变量和函数的定义位置，才能在执行过程中快速找到标识符。副作用：JS 引擎无法在编译时对作用域查找进行优化，引擎只能谨慎地认为这样的优化是无效的，不优化会导致代码变慢。

3. 块作用域

with：从对象中创建出的作用域仅在 with 声明中而非外部作用域中有效。
try/catch：catch 分局会创建一个块作用域，其中声明的变量仅在 catch 内部有效。

4. 函数优先提升

5. 闭包

当函数可以记住并访问所在的词法作用域时，就产生了闭包，即使函数是在当前词法作用域之外执行的。
只要使用了回调函数，实际上就是在使用闭包。

6. 现代的模块机制：将模块定义封装为友好的 API

const MyModules = (function Manager() {
    const modules = {};

    function define(name, deps, impl) {
        for (let i = 0; i < deps.length; i++) {
            deps[i] = modules[deps[i]];
        }
        modules[name] = impl.apply(impl, deps);
    }

    function get(name) {
        return modules[name];
    }

    return {
        define,
        get
    };
})();

MyModules.define('bar', [], function() {
    function hello(who) {
        return "Let me introduce: " + who;
    }

    return { hello };
});

MyModules.define('foo', ['bar'], function(bar) {
    const hungry = 'hippo';

    function awesome() {
        console.log(bar.hello(hungry).toUpperCase());
    }

    return { awesome };
});

let bar = MyModules.get('bar');
let foo = MyModules.get('foo');

console.log(bar.hello('hippo'));  // Let me introduce: hippo
foo.awesome(); // LET ME INTRODUCE: HIPPO

这里的 MyModules 是自执行函数（IIFE），调用 define 方法时，将模块的实现匿名函数 impl 方法赋值给 modules[name] → modules[name] = impl.apply(impl, deps)。

  for (let i = 0; i < deps.length; i++) {
            deps[i] = modules[deps[i]];
  }

当有依赖时，比如 'foo’ 模块依赖 'bar' 模块的 'foo' 模块的实现，deps[i] = modules[deps[i]]

/* 这里匿名函数里的 bar  已经是 bar 模块的实现(impl)了*/
MyModules.define('foo', ['bar'], function(bar) {
    const hungry = 'hippo';

    function awesome() {
        console.log(bar.hello(hungry).toUpperCase());
    }

    return { awesome };
});

得益于闭包的机制，modules 对象可以被外部访问：

 function get(name) {
        return modules[name];
 }

因为有外部的引用 let bar = MyModules.get('bar')，所以当 foo 要依赖 bar 时， modules['bar'] 存在，没有被垃圾回收。