    window.val = 1;
    var json = {
        val:2,
        dbl:function(){
            this.val = 5;
        }
    }
    var v  = json.dbl.bind(window);              
    v.call(null);   
    console.log(window.val)

结果输出是5，在这里把this指向了window；window下的val是1，但是指行this.val=5后，val被修改成5。

function foo(){
    console.log(11,this)
    setTimeout(function(){
        console.log(this.a);
    })
}
var obj = {
     a:2
};
foo.call(obj);

执行执行语句后我们知道如果在11处打印this那一定是obj；但是在setTimeout异步函数中的this指向是window，所以打印this.a即是window.a=undefined；所以我们只能通过修改this指向或是箭头函数使setTimeout中的this指向obj

window.val = 1;
var json = {
	val:10,
	dbl:function(){
		this.val *= 2;
	}
};
json.dbl();
var dbl = json.dbl;
dbl();
json.dbl.call(window);

console.log(window.val + json.val);

第一步this指向是json结果是20；接下来做一个赋值，并未调用，真正调用时在全局下的dbl(),this指向依旧是window，结果是2，继续执行this依然指向window，变为4，最后输出结果24。

        var val = 1;
        var json = {
            val: 10,
            dbl: function(){
                console.log(91,this)
                val*=2;
                console.log(92,json.val)
            }
        };
        json.dbl();

        console.log(json.val)   
        console.log(val)    
        console.log(json.val + val);

注意第一个输出是10，而不是20；区别this.val*=2,json.val*=2;这里的val一直是全局的var val = 1;所以结果是2

    var test = (function(i){
        return function(){
            console.log(i*2)
        }
    }(2))
    test(5);

明显闭包问题结果是4

var a = 100;
function test (){
	console.log(a);
	var a = 10;
	console.log(a)
}
test()

var a = 100;
function test(){
	alert(a);
	let a = 10;
	alert(a);
}
test();

undefined 10

报错（let是不允许变量提升的）

function C1(name) {
	if(name)this.name = name;
}

function C2(name) {
	this.name = name;
}
function C3(name) {
	this.name = name || 'John';
}
C1.prototype.name = 'Tom';
C2.prototype.name = 'Tom';
C3.prototype.name = 'Tom';

console.log(new C1(),new C2(),new C3())
console.log((new C1().name)+ (new C2().name)+ (new C3().name));

var name = "a";
function inner(){
    console.log(name);
    console.log(this.name);
}

function outter(){
    var name = "b";
    inner();
}
outter();

结果输出是a，a；

修改一下：

var name = "a";
function outter(){
    var name = "b";
    function inner(){
        console.log(name,this);
        console.log(this.name);
    }
    inner();
}
outter();

结果为：b,a 闭包中的this的指向是window

function outter(){
    var a = 1;
    function inner(){
        console.log(a);
    }
    return inner;
}
//进行函数调用
var inner = outter();
inner();

依然是考察闭包内部可以访问外部变量，反之则不可以

10.总结分析例证：

    var d = 1;
    function a(){
        function b(){
            d = 3;
            console.log(this,d);
        //     function c(){

        //     }
        //     c()
        }
        b()
    }
    a();

闭包中的this一定是指向window的

    var d = 1;
    function a(){
        d=2;
        var d=4;
        console.log(this,d,this.d);
        function b(){
        }
        b()
    }
    a();

执行过程： a定义=> a执行=>全局d声明提升赋值=> 函数b定义=>函数b执行=> 内部变量d声明提升=>内部变量d赋值为2=>内部变量d修改为4 但是this指向始终是window所以结果是1