作用域与作用域链，原型及原型对象

作用域

作用域是在定义的时候就创建了， 而不是运行的时候。看看下面这个例子：

let a=1
function aa(){
    console.log(a)    //输出1
}
function bb(){
    let a=2
    aa()
}

是不是非常违背常理啊，你看嘛，aa在bb里面调用的，aa函数里面没有a变量，那么就应该去调用它的作 用域里找，刚好找到a等于2。
思路是完美的，可是js的作者采用的静态作用域，不管你们怎么运行，你们 定义的时候作用域已经生成了。
那么什么是作用域？
变量和函数能被有效访问的区域或者集合。作用域决定了代码块之间的资源可访问性.
作用域又分为全局作用域和函数作用域，块级作用域。 全局作用域任何地方都可以访问到，如window,Math等全局对象。
函数作用域就是函数内部的变量和方法，函数外部是无法访问到的。 块级作用域指变量声明的代码段外是不可访问的，如let,const.

作用域链

作用域链表示一个作用域可以访问到变量的一个集合。函数作为一个对象有一个[[scope]]属性，就是表示这个集合的。再来理解几个概念词：
AO:活动变量(Active object，AO)
VO:变量对象(Variable object，VO)
执行上下文：代码运行的环境，分为全局上下文和函数上下文。

举例子来说明一下：（借用的例子）
function a() {
        function b() {
            var b = 234;
        }
        var a = 123;
        b();
    }
    var gloab = 100;
    a();
console.log(a)

第一步： a 函数定义

我们可以从上图中看到，a 函数在被定义时，a函数对象的属性[[scope]]作用域指向他的作用域链scope chain，
此时它的作用域链的第一项指向了GO(Global Object)全局对象，我们看到全局对象上此时有5个属性，分别是this、window、document、a、glob。
第二步： a 函数执行

当a函数被执行时，此时a函数对象的作用域[[scope]]的作用域链scope chain的第一项指向了AO(Activation Object)活动对象，AO对象里有4个属性，
分别是this、arguments、a、b。第二项指向了GO(Global Object)，GO对象里依然有5个属性，分别是this、window、document、a、golb。
第三步： b 函数定义

当b函数被定义时，此时b函数对象的作用域[[scope]]的作用域链scope chain的第一项指向了AO(Activation Object)活动对象，AO对象里有4个属性，
分别是this、arguments、a、b。第二项指向了GO(Global Object)，GO对象里依然有5个属性，分别是this、window、document、a、golb。
第四步： b 函数执行

当b函数被执行时，此时b函数对象的作用域[[scope]]的作用域链scope chain的第一项指向了AO(Activation Object)活动对象，AO对象里有3个属性，
分别是this、arguments、b。第一项指向了AO(Activation Object)活动对象，AO对象里有4个属性，分别是this、arguments、a、b。
第二项指向了GO(Global Object)，GO对象里依然有5个属性，分别是this、window、document、a、golb。
** 以上就是上面代码执行完之后的结果。**

闭包

闭包的官方定义：闭包是指那些能够访问自由变量的函数。
我：一个作用域可以访问另一个作用域的变量，就产生闭包。
闭包=函数+函数能够访问的自由变量。
什么是自由变量？
自由变量是指在函数中使用的，但既不是函数参数也不是函数的局部变量的变量。

var a = 1;

function foo() {
    console.log(a);
}

foo()

foo 函数可以访问变量 a，但是 a 既不是 foo 函数的局部变量，也不是 foo 函数的参数，所以 a 就是自由变量。

var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
var foo = checkscope();
foo();
输出 "local scope"

因为变量查找的规则是通过作用域链的，作用域链是在函数定义的时候就已经确定了， 所以我们来看看定义f函数时候的[[scope]]属性：

[
    AO:{
        scope:"local scope",
        f:function
    },
    global:{
     scope :"local scope",
     checkscope:function
    }
]

f执行时候的[[scope]]属性：

[
    AO:{
        arguments:[],
        this:window
    },
    AO:{
        scope:"local scope",
        f:function
    },
    global:{
     scope :"local scope",
     checkscope:function
    }
]
根据先后顺序scope变量输出为"local scope"

经典面试题：

var data = [];

for (var i = 0; i < 3; i++) {
  data[i] = function () {
    console.log(i);
  };
}
data[0]();
data[1]();
data[2]();
//答案是都是 3，让我们分析一下原因：
//当执行到 data[0] 函数之前，此时全局上下文的 VO 为：
globalContext = {
    VO: {
        data: [...],
        i: 3
    }
}
//当执行 data[0] 函数的时候，data[0] 函数的作用域链为：
data[0]Context = {
    Scope: [AO, globalContext.VO]
}
//data[0]Context 的 AO 并没有 i 值，所以会从 globalContext.VO 中查找，i 为 3，所以打印的结果就是 3

原型及原型对象

javascript万物皆对象，每个对象都有一个__proto__属性，指向了创造它的构造函数的原型对象。
每个函数都有一个原型对象，prototype,当使用new 创造对象时继承这个对象。

function A(){}
var a=new A()
a.__proto__===A.prototype

下面就有问题了，谁创造了A这个构造函数呢,还有谁创造了A.prototype这个对象呢？
这时候我们就要知道js两个顶级函数，Function,Object
所有函数都是由Function创建的
A.__proto__===Function.prototype
刚说了所有函数都是由Function创建的，也包括自己。也就是说Function创造了自己：
Function.__proto__===Function.prototype
Object刚讲的是顶级函数，所以也是函数：
Object.__proto__===Function.prototype
所有的对象都是由Object构造函数创建的：
A.prototype.__proto__===Object.prototype
那么Object.prototype也是对象啊，是由谁创建的呢，记住万物皆空,何尝不是人生，到头来什么都会没有。
Object.prototype.__proto__===null

原型链

1.在访问对象的某个成员的时候会先在对象中找是否存在

2.如果当前对象中没有就在构造函数的原型对象中找

3.如果原型对象中没有找到就到原型对象的原型上找

4.直到Object的原型对象的原型是null为止