JS 执行上下文

执行上下文

执行上下文（上）https://www.cnblogs.com/wangfupeng1988/p/3986420.html

执行上下文（下）https://www.cnblogs.com/wangfupeng1988/p/3987563.html

console.log(a) //underfined
    var a=100

    fn('zhangsan') // zhangsan 20
    function fn(name) {
        age =20
        console.log(name, age)
        var age
    }

this

this 要在执行时才能确认值，定义时无法确认

// this要在执行时才能确认值，定义时无法确认
    var a ={
        name:'A',
        fn:function () {
            console.log(this.name)
        }
    }
    a.fn() // this === a  输出A
    a.fn.call({name:'B'}) // this === {name : 'B'} 输出B
    var fn1=a.fn
    fn1() // this === window  输出空

作为构造函数执行

    // 作为构造函数执行
    function Foo(name) {
        this.name=name;
        return this
    }
    var f=new Foo('zhangsan')
    f //执行的就是构造函数内部变量

作为对象属性执行

    // 作为对象属性执行
    var obj={
        name:'A',
        printName:()=>{
            console.log(this.name)
        }
    }
    obj.printName  // 执行就是对象

作为普通函数执行

    // 作为普通函数执行
    function fnn() {
        console.log(this) // this === windows
    }
    fnn() // 执行就是window对象

call apply bind

    // call apply bind
    function ff(name,age) {
        alert(name)
        console.log(this)
    }
    ff.call({x:100},'zhangsan',20)
    //第一个参数就是this 第二个参数就是上面的第一个参数 后面依旧如此

    // bind 函数声明不能用bind 必须使用函数表达式
    var ff1=function ff1(name, age) {
        alert(name)
        console.log(this)
    }.bind({y:200})

作用域

1.没有块级作用域
2.只有函数和全局作用域

// 无块级作用域
    if (true){
        var name = 'zhangsan'
    }
    console.log(name)  // zhangsan
    // 函数和全局作用域
    var a =100
    function fnnn() {
        var a=200
        console.log('fn',a)
    }
    console.log('global',a) // global 100
    fnnn() // fn 200

作用域链

// 作用域链
    var a=100
    function fnnnn() {
        var b =200

        // 当前作用域没有定域的变量，即“自由变量”
        // 去当前父级作用域寻找 声明定义的a
        console.log(a)
        console.log(b)
    }
    fnnnn()

闭包

1.函数作为返回值
2.函数作为参数传递

// 函数作为返回值
function F1() {
        var a =100

        return function () {
            console.log(a) // 自由变量，父作用域寻找
        }
    }

    var ff1=F1()
    var a =200 //全局作用域

    ff1()

    // 函数作为参数传递
    function F1() {
        var a =100

        return function () {
            console.log(a) // 自由变量，父作用域寻找
        }
    }

    var ff1=F1()
    function F2(fn) {
        var a =200
        fn()
    }
    F2(f1);



(function () {
        var bb={}
        window.bb=this.bb
    })()

    bb // 输出 undefined
    bb={age:20}
    bb.age // 输出 20