JavaScript深入之变量对象

JavaScript深入之变量对象


距离复习 变量对象 已经过了三天,这三天里都会在一种苟喘的状态下触碰 JavaScript,知识就像那一个个充实却无味的白馒头,让人难以下肚。差点又放弃了!最后还是回来了,就算知识是白馒头我也要啃,无它,一无所有,要么饿死,要么白馒头。

学变量对象有什么用?看下面这段代码

console.log(fun2())
console.log(str)

var fun2 = 'vb'
var str = 'emmmmm'
function fun2(){
    return '函数提升'
}

try{
    console.log(fun2())
}catch(error){
    console.log('-------抛出异常-------')
    console.log(error.message)
    console.log('--------------')
}

console.log(fun2)
console.log(str)

经此,如果你的答案都正确的话,那么可以说你的基础很好,对函数提升和变量提升都有很好的理解。如果是和我没学之前看着心烦头大懵逼的样子,没关系,蠢蠢的我学了五天看着看着就顺眼了,聪明的你一天就行。
上述代码控制台展示:

函数提升
undefined
-------抛出异常-------
fun2 is not a function
--------------
vb
emmmmm

这段代码看着还是有点雾水的话,先梳理一下相关知识再讲解


学变量对象,学的是什么?

前面的文章已提到,执行上下文有三个属性,① 变量对象[Variable Object]、② 作用域链[Scope Chain]、③this[thisValue]。而执行上下文又有两个生命周期:创建阶段(变量与函数的声明及其储存阶段,值仅只读,变量初始化为 undefined)、执行阶段(代码被执行阶段,值能被读写)。

我们学的,就算变量对象在其爸爸(EC)的两个生命周期中,发生了什么,带来的什么影响。就像人那样,为人子女,年幼给父母带来快乐,年长接下家庭重担。我们的变量对象就是在这两个生命周期里,带来函数提升、变量提升这两个知识点。

扯远了,回归正题

A variable object is a scope of data related with the execution context. It’s a special object associated with the context and which stores variables and function declarations are being defined within the context.
变量对象(variable object) 是与执行上下文相关的数据作用域(scope of data) 。它是与上下文关联的特殊对象,用于存储被定义在上下文中的 变量(variables) 和 函数声明(function declarations)

上面的英文资料我只认stores,就够了。储存!储存什么?变量和函数声明。在执行上下文的创建阶段。

函数执行上下文的变量对象

函数执行上下文的创建阶段里的变量对象

和全局执行上下文不同的是,函数执行上下文的变量对象在执行阶段会变成活动对象, 在函数上下文中,创建过程里,变量对象中的属性不能访问!但是进入到执行阶段之后,变量对象转变成了活动对象,里面的属性才能被访问了,然后开始进行执行阶段的操作。

对于函数上下文来讲,活动对象与变量对象其实都是同一个对象,只是处于执行上下文的不同生命周期。不过只有处于执行上下文栈栈顶的函数执行上下文中的变量对象,才会变成活动对象。

在创建阶段这一生命周期,还没有执行代码,

变量对象会包括:

  1. 函数的所有形参

    • 由名称和对应值组成的一个变量对象的属性被创建
    • 没有实参,属性值设为 undefined
  2. 函数声明

    • 由名称和对应值(函数对象(function-object))组成一个变量对象的属性被创建
    • ㊕①如果变量对象已经存在相同名称的属性,则完全替换这个属性
  3. 变量声明

    • 由名称和对应值(undefined)组成一个变量对象的属性被创建;
    • ㊕②如果变量名称跟已经声明的形式参数或函数相同,则变量声明不会干扰已经存在的这类属性

上代码

var a = '全局变量被储存'
`var allowRead = '栈顶可以读取到'`
function b () {
    console.log('全局的b函数')
}
function bar(a, b) {
    console.log('first', a, b ,allowRead) 
    var a = '函数内的变量被储存'
    function b() {
        console.log('bar下的b函数')
    }
    console.log('second', a, b) 
}
bar('函数参数a被储存', '函数参数b被储存')
console.log('third', a, b)

控制台代码


first 函数参数a被储存 ƒ b() {
        console.log('bar下的b函数')
    } 栈顶可以读取到
second 函数内的变量被储存 ƒ b() {
        console.log('bar下的b函数')
    }
third 全局变量被储存 ƒ b () {
    console.log('全局的b函数')
}

分析创建过程中,变量对象发生了什么:

//程序跑起来,执行下文栈首先加载全局执行上下文
ECStack = [
    globalcontext:{
        VO:{
            //优先处理函数声明,值为该函数所在内存地址的引用
            b: <reference to function>,
            // 紧接着,按顺序再处理bar函数声明,因为是在全局上下文中,并不会分析bar函数的参数
            bar: <refernce to function>,
            // 其次处理变量声明,并赋值为undefined
            a: undefined
        }
    }
];

执行过程,给a赋值为10,调用bar(),进入函数执行上下文,
再分析一个上下文的创建阶段

ECStack = [
    globalcontext:{
        VO:{
            //优先处理函数声明,值为该函数所在内存地址的引用
            b: <reference to function>,
            // 紧接着,按顺序再处理bar函数声明,因为是在全局上下文中,并不会分析bar函数的参数
            bar: <refernce to function>,
            // 其次处理变量声明,并赋值为undefined
            a: 10
        }
    },
    
    <bar>funtionContext :{
        VO:{
            // 优先分析函数的参数 
            arguments: {
                0: '函数参数a被储存', 
                1: '函数参数b被储存', 
                length: 2,
                callee: bar
            },
            a: '函数参数a被储存', 
            //分析bar函数中的函数声明b,并且赋值为b函数所在内存地址的引用, 它发现VO中已经有b:3了,就会覆盖掉它。因此上面一行中的b:3实际上不存在了。
            // b: 3,
            b:<refernce to function b() {}>,
            //接着分析bar函数中的变量声明a,并且赋值为undefined, 但是发现VO中已经有a:2了,因此下面一行中的a:undefined也是会不存在的。
            //a:undefined
        }
    
    }
];

之后进入执行阶段,函数执行上下文的变量对象变为活动对象,从而可以访问它的值

// 执行阶段:
// 第三步:首先,执行了bar('函数参数a被存储', '函数参数b被储存')函数,紧接着,在bar函数里执行了console.log('first', a, b ,allowRead)。全局上下文中依然还是VO,但是函数上下文中VO就变成了AO.
ECStack = [
    globalContext: {//栈底永远有全局上下文,这样其它作用域,或者说栈顶在没有声明属性的情况下都可以向上寻找访问到全局上下文的属性,这属于作用域链的知识,下次再详谈。
        VO: {
            b: <reference to function b() {}>, 
            bar: <refernce to function bar() {}>,
            a: 10,
        }
    },
    <bar>functionContext: {
        AO: {//执行阶段重点,VO变AO,即代码执行,赋值操作函数执行生效
            arguments: {
                0: 函数参数a被储存,
                1: 函数参数b被储存,
                length: 2,
                callee: bar
            },
            a: 函数内的变量被储存,
            b: <refernce to function b() {}>
        }
    }
]

// 因此会输出结果: first, 函数内的变量被储存, function b() {console.log('bar下的b函数')} 栈顶可以读取到;

// 第四步:执行console.log('second', a, b)的时候, 发现里面的变量a被重新赋值为'函数内的变量被储存'了。
ECStack = [
    globalContext: {
        VO: {
            b: <reference to function b() {}>, 
            bar: <refernce to function bar() {}>,
            a: 10,
        }
    },
    <bar>functionContext: {
        AO: {
            arguments: {
                0: 函数参数a被储存,
                1: 函数参数b被储存,
                length: 2,
                callee: bar
            },
            a: 函数内的变量被储存,
            b: <refernce to function b() {}>
        }
    }
]
// 因此会输出结果: second, 函数内的变量被储存, function b() {console.log('bar下的b函数')};

// 第五步,执行到console.log('3', a, b)的时候,ECStack发现bar函数已经执行完了,就把bar从ECStack给弹出去了。此时的执行上下文栈是这样的。

ECStack = [
    globalContext: {
        VO: {
            b: <reference to function b() {}>, 
            bar: <refernce to function bar() {}>,
            a: 10,
        }
    }
]

// 因此会输出结果: third, 全局变量被储存, function b() {console.log('全局的b函数')}


小结,通过学习变量对象我们可以得到以下知识点:

  • 在变量对象的创建过程中,会优先处理函数参数
  • 如果变量对象的属性名已经存在了,函数声明会完全替换这个属性,变量声明不会干扰已经存在的这类属性
  • 在代码执行阶段,会再次修改变量对象的属性值

理解了这些,我们再回到开篇那题

console.log(fun2())//➊
console.log(str)//➋

var fun2 = 'vb'//➌
var str = 'emmmmm'//➍
function fun2(){
    return '函数提升'
}

➎
try{
    console.log(fun2())//Ⓐ
}catch(error){
    console.log('-------抛出异常-------')
    console.log(error.message)
    console.log('--------------')
}

console.log(fun2)➏
console.log(str)➐

------------------分析如下--------------------------
创建过程:
ECstack=[
    globalcontext:{
        VO:{
            fun2:<reference to function fun2() {}>,
            str: undefined
        }
    }
]

执行过程
ECstack=[
    globalcontext:{
        VO:{
            //fun2:<reference to function fun2() {}>, //➊,所以打印出函数
            //str: undefined  //➋,所以打印出undefined
            fun2:'vb',//➌值被修改,所以➏打印出vb
            str: emmmmm//➍值被改写,所以➐打印emmmmm
        }
    }
]

异常处理语句➎-Ⓐ,由于➌改写了fun2的值,fun2不再是函数,因此会执行错误。之后抛出异常

最后再来几个十分简单的题:

foo()
var foo = function() {
            console.log(1)
          } 
          
function foo() {
    console.log(2)
}

分析:
执行foo()之前,变量对象存在相同的属性名,function优先,控制台打印‘2’
foo()
function foo() {
    console.log(2)
}

var foo = function() {
            console.log(1)
          }
          
分析:
执行foo()之前,之前全局执行EC的变量对象存在相同的属性名,function优先,控制台打印‘2’
foo()
var foo = function() {
            console.log(1)
          }
          
function foo() {
            console.log(2)
         } 
foo()

分析:
第一次执行foo(),之前全局执行EC的变量对象存在相同的属性名,function优先,控制台打印‘2’,
第二次执行foo(),变量foo引用新的对象,打印1

到了这里,可能是个人状态不好(连续吃了一周的馒头加水作为主食,胃疼)或是才疏学浅,实在不能更好更细致的深挖变量对象。等找到工作有饭吃再补坑。先快速进入下一章吧!

评论

暂无评论