网上正规真人赌钱网站原文出处,原文出处
分类:前端科技

进入执行上下文

当进入执行上下文时,这时候还没有执行代码,

变量对象会包括:

  1. 函数的所有形参 (如果是函数上下文)
    • 由名称和对应值组成的一个变量对象的属性被创建
    • 没有实参,属性值设为undefined
  2. 函数声明
    • 由名称和对应值(函数对象(function-object))组成一个变量对象的属性被创建
    • 如果变量对象已经存在相同名称的属性,则完全替换这个属性
  3. 变量声明
    • 由名称和对应值(undefined)组成一个变量对象的属性被创建;
    • 如果变量名称跟已经声明的形式参数或函数相同,则变量声明不会干扰已经存在的这类属性

举个例子:

function foo(a) { var b = 2; function c() {} var d = function() {}; b = 3; } foo(1)

1
2
3
4
5
6
7
8
9
10
function foo(a) {
  var b = 2;
  function c() {}
  var d = function() {};
 
  b = 3;
 
}
 
foo(1)

在进入执行上下文后,这时候的AO是:

AO = { arguments: { 0: 1, length: 1 }, a: 1, b: undefined, c: reference to function c(){}, d: undefined }

1
2
3
4
5
6
7
8
9
10
AO = {
    arguments: {
        0: 1,
        length: 1
    },
    a: 1,
    b: undefined,
    c: reference to function c(){},
    d: undefined
}

前端基础进阶(三):变量对象详解

2017/02/21 · 基础技术 · 变量对象

原文出处: 波同学   

网上正规真人赌钱网站 1

开年之后工作热情一直不是很高,这几天一直处于消极怠工状态。早上不想起床,起床了不想上班。明明放假之前工作热情还一直很高,一直心心念念的想把小程序项目怼出来,结果休假回来之后画风完全不一样了。我感觉自己得了严重了节后综合征。还好撸了几篇文章,勉强表示这一周的时间没有完全浪费。这篇文章要给大家介绍的是变量对象。

在JavaScript中,我们肯定不可避免的需要声明变量和函数,可是JS解析器是如何找到这些变量的呢?我们还得对执行上下文有一个进一步的了解。

在上一篇文章中,我们已经知道,当调用一个函数时(激活),一个新的执行上下文就会被创建。而一个执行上下文的生命周期可以分为两个阶段。

  • 创建阶段
    在这个阶段中,执行上下文会分别创建变量对象,建立作用域链,以及确定this的指向
  • 代码执行阶段
    创建完成之后,就会开始执行代码,这个时候,会完成变量赋值,函数引用,以及执行其他代码。

网上正规真人赌钱网站 2

执行上下文生命周期

从这里我们就可以看出详细了解执行上下文极为重要,因为其中涉及到了变量对象,作用域链,this等很多人没有怎么弄明白,但是却极为重要的概念,因此它关系到我们能不能真正理解JavaScript。在后面的文章中我们会一一详细总结,这里我们先重点了解变量对象。

前言

在上篇《JavaScript深入之执行上下文栈》中讲到,当JavaScript代码执行一段可执行代码(executable code)时,会创建对应的执行上下文(execution context)。

对于每个执行上下文,都有三个重要属性:

  • 变量对象(Variable object,VO)
  • 作用域链(Scope chain)
  • this

今天重点讲讲创建变量对象的过程。

变量对象是与执行上下文相关的数据作用域,存储了在上下文中定义的变量和函数声明。

因为不同执行上下文下的变量对象稍有不同,所以我们来聊聊全局上下文下的变量对象和函数上下文下的变量对象。

变量对象(Variable Object)

变量对象的创建,依次经历了以下几个过程。

  1. 建立arguments对象。检查当前上下文中的参数,建立该对象下的属性与属性值。
  2. 检查当前上下文的函数声明,也就是使用function关键字声明的函数。在变量对象中以函数名建立一个属性,属性值为指向该函数所在内存地址的引用。如果函数名的属性已经存在,那么该属性将会被新的引用所覆盖。
  3. 检查当前上下文中的变量声明,每找到一个变量声明,就在变量对象中以变量名建立一个属性,属性值为undefined。如果该变量名的属性已经存在,为了防止同名的函数被修改为undefined,则会直接跳过,原属性值不会被修改。

网上正规真人赌钱网站 3

我知道有的人不喜欢看文字

根据这个规则,理解变量提升就变得十分简单了。在很多文章中虽然提到了变量提升,但是具体是怎么回事还真的很多人都说不出来,以后在面试中用变量对象的创建过程跟面试官解释变量提升,保证瞬间提升逼格。

在上面的规则中我们看出,function声明会比var声明优先级更高一点。为了帮助大家更好的理解变量对象,我们结合一些简单的例子来进行探讨。

JavaScript

// demo01 function test() { console.log(a); console.log(foo()); var a = 1; function foo() { return 2; } } test();

1
2
3
4
5
6
7
8
9
10
11
12
// demo01
function test() {
    console.log(a);
    console.log(foo());
 
    var a = 1;
    function foo() {
        return 2;
    }
}
 
test();

在上例中,我们直接从test()的执行上下文开始理解。全局作用域中运行test()时,test()的执行上下文开始创建。为了便于理解,我们用如下的形式来表示

JavaScript

创建过程 testEC = { // 变量对象 VO: {}, scopeChain: {}, this: {} } // 因为本文暂时不详细解释作用域链和this,所以把变量对象专门提出来说明 // VO 为 Variable Object的缩写,即变量对象 VO = { arguments: {...}, //注:在浏览器的展示中,函数的参数可能并不是放在arguments对象中,这里为了方便理解,我做了这样的处理 foo: <foo reference> // 表示foo的地址引用 a: undefined }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
创建过程
testEC = {
    // 变量对象
    VO: {},
    scopeChain: {},
    this: {}
}
 
// 因为本文暂时不详细解释作用域链和this,所以把变量对象专门提出来说明
 
// VO 为 Variable Object的缩写,即变量对象
VO = {
    arguments: {...},  //注:在浏览器的展示中,函数的参数可能并不是放在arguments对象中,这里为了方便理解,我做了这样的处理
    foo: <foo reference>  // 表示foo的地址引用
    a: undefined
}

未进入执行阶段之前,变量对象中的属性都不能访问!但是进入执行阶段之后,变量对象转变为了活动对象,里面的属性都能被访问了,然后开始进行执行阶段的操作。

这样,如果再面试的时候被问到变量对象和活动对象有什么区别,就又可以自如的应答了,他们其实都是同一个对象,只是处于执行上下文的不同生命周期。

JavaScript

// 执行阶段 VO -> AO // Active Object AO = { arguments: {...}, foo: <foo reference>, a: 1 }

1
2
3
4
5
6
7
// 执行阶段
VO ->  AO   // Active Object
AO = {
    arguments: {...},
    foo: <foo reference>,
    a: 1
}

因此,上面的例子demo1,执行顺序就变成了这样

JavaScript

function test() { function foo() { return 2; } var a; console.log(a); console.log(foo()); a = 1; } test();

1
2
3
4
5
6
7
8
9
10
11
function test() {
    function foo() {
        return 2;
    }
    var a;
    console.log(a);
    console.log(foo());
    a = 1;
}
 
test();

再来一个例子,巩固一下我们的理解。

JavaScript

// demo2 function test() { console.log(foo); console.log(bar); var foo = 'Hello'; console.log(foo); var bar = function () { return 'world'; } function foo() { return 'hello'; } } test();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// demo2
function test() {
    console.log(foo);
    console.log(bar);
 
    var foo = 'Hello';
    console.log(foo);
    var bar = function () {
        return 'world';
    }
 
    function foo() {
        return 'hello';
    }
}
 
test();

JavaScript

// 创建阶段 VO = { arguments: {...}, foo: <foo reference>, bar: undefined } // 这里有一个需要注意的地方,因为var声明的变量当遇到同名的属性时,会跳过而不会覆盖

1
2
3
4
5
6
7
// 创建阶段
VO = {
    arguments: {...},
    foo: <foo reference>,
    bar: undefined
}
// 这里有一个需要注意的地方,因为var声明的变量当遇到同名的属性时,会跳过而不会覆盖

JavaScript

// 执行阶段 VO -> AO VO = { arguments: {...}, foo: 'Hello', bar: <bar reference> }

1
2
3
4
5
6
7
// 执行阶段
VO -> AO
VO = {
    arguments: {...},
    foo: 'Hello',
    bar: <bar reference>
}

需要结合上面的知识,仔细对比这个例子中变量对象从创建阶段到执行阶段的变化,如果你已经理解了,说明变量对象相关的东西都已经难不倒你了。

全局上下文

我们先了解一个概念,叫全局对象。在W3C school中也有介绍:

全局对象是预定义的对象,作为 JavaScript 的全局函数和全局属性的占位符。通过使用全局对象,可以访问所有其他所有预定义的对象、函数和属性。

在顶层 JavaScript 代码中,可以用关键字 this 引用全局对象。因为全局对象是作用域链的头,这意味着所有非限定性的变量和函数名都会作为该对象的属性来查询。

例如,当JavaScript 代码引用 parseInt() 函数时,它引用的是全局对象的 parseInt 属性。全局对象是作用域链的头,还意味着在顶层 JavaScript 代码中声明的所有变量都将成为全局对象的属性。

如果看的不是很懂的话,容我再来介绍下全局对象:

1.可以通过this引用,在客户端JavaScript中,全局对象就是Window对象。

console.log(this);

1
console.log(this);

2.全局对象是由Object构造函数实例化的一个对象。

console.log(this instanceof Object);

1
console.log(this instanceof Object);

3.预定义了一堆,嗯,一大堆函数和属性。

// 都能生效 console.log(Math.random()); console.log(this.Math.random());

1
2
3
// 都能生效
console.log(Math.random());
console.log(this.Math.random());

4.作为全局变量的宿主。

var a = 1; console.log(this.a);

1
2
var a = 1;
console.log(this.a);

5.客户端JavaScript中,全局对象有window属性指向自身。

var a = 1; console.log(window.a); this.window.b = 2; console.log(this.b)

1
2
3
4
5
var a = 1;
console.log(window.a);
 
this.window.b = 2;
console.log(this.b)

花了一个大篇幅介绍全局对象,其实就想说:

全局上下文中的变量对象就是全局对象呐!

全局上下文的变量对象

以浏览器中为例,全局对象为window。
全局上下文有一个特殊的地方,它的变量对象,就是window对象。而这个特殊,在this指向上也同样适用,this也是指向window。

JavaScript

// 以浏览器中为例,全局对象为window // 全局上下文 windowEC = { VO: window, scopeChain: {}, this: window }

1
2
3
4
5
6
7
// 以浏览器中为例,全局对象为window
// 全局上下文
windowEC = {
    VO: window,
    scopeChain: {},
    this: window
}

除此之外,全局上下文的生命周期,与程序的生命周期一致,只要程序运行不结束,比如关掉浏览器窗口,全局上下文就会一直存在。其他所有的上下文环境,都能直接访问全局上下文的属性。

前端基础进阶系列目录

前端基础进阶系列我会持续更新,欢迎大家关注我公众号isreact,新的文章更新了我会在公众号里第一时间通知大家。也欢迎大家来简书关注我。

1 赞 3 收藏 评论

网上正规真人赌钱网站 4

JavaScript 深入之变量对象

2017/05/13 · JavaScript · 变量对象

原文出处: 冴羽   

执行过程

执行上下文的代码会分成两个阶段进行处理:分析和执行,我们也可以叫做:

  1. 进入执行上下文
  2. 代码执行

思考题

最后让我们看几个例子:

1.第一题

function foo() { console.log(a); a = 1; } foo(); function bar() { a = 1; console.log(a); } bar();

1
2
3
4
5
6
7
8
9
10
11
12
function foo() {
    console.log(a);
    a = 1;
}
 
foo();
 
function bar() {
    a = 1;
    console.log(a);
}
bar();

第一段会报错:Uncaught ReferenceError: a is not defined

第二段会打印1。

这是因为函数中的”a”并没有通过var关键字声明,所有不会被存放在AO中。

第一段执行console的时候,AO的值是:

AO = { arguments: { length: 0 } }

1
2
3
4
5
AO = {
    arguments: {
        length: 0
    }
}

没有a的值,然后就会到全局去找,全局也没有,所以会报错。

当第二段执行console的时候,全局对象已经被赋予了a属性,这时候就可以从全局找到a值,所以会打印1。

2.第二题

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

1
2
3
4
5
6
7
console.log(foo);
 
function foo(){
    console.log("foo");
}
 
var foo = 1;

会打印函数,而不是undefined。

这是因为在进入执行上下文时,首先会处理函数声明,其次会处理变量声明,如果如果变量名称跟已经声明的形式参数或函数相同,则变量声明不会干扰已经存在的这类属性。

函数上下文

在函数上下文中,我们用活动对象(activation object, AO)来表示变量对象。

活动对象是在进入函数上下文时刻被创建的,它通过函数的arguments属性初始化。arguments属性值是Arguments对象。

深入系列

JavaScript深入系列预计写十五篇左右,旨在帮大家捋顺JavaScript底层知识,重点讲解如原型、作用域、执行上下文、变量对象、this、闭包、按值传递、call、apply、bind、new、继承等难点概念,与罗列它们的用法不同,这个系列更注重通过写demo,捋过程、模拟实现,结合ES规范等方法来讲解。

所有文章和demo都可以在github上找到。如果有错误或者不严谨的地方,请务必给予指正,十分感谢。如果喜欢或者有所启发,欢迎star,对作者也是一种鼓励。

本系列:

  1. JavaScirpt 深入之从原型到原型链
  2. JavaScript 深入之词法作用域和动态作用域
  3. JavaScript 深入之执行上下文栈

    1 赞 收藏 评论

网上正规真人赌钱网站 5

代码执行

在代码执行阶段,会顺序执行代码,根据代码,修改变量对象的值

还是上面的例子,当代码执行完后,这时候的AO是:

AO = { arguments: { 0: 1, length: 1 }, a: 1, b: 3, c: reference to function c(){}, d: reference to FunctionExpression "d" }

1
2
3
4
5
6
7
8
9
10
AO = {
    arguments: {
        0: 1,
        length: 1
    },
    a: 1,
    b: 3,
    c: reference to function c(){},
    d: reference to FunctionExpression "d"
}

到这里变量对象的创建过程就介绍完了,让我们粗略的总结我们上述所说:

  1. 全局上下文的变量对象初始化是全局对象
  2. 函数上下文的变量对象初始化只包括Arguments对象
  3. 在进入执行上下文时会给变量对象添加形参、函数声明、变量声明等初始的属性值
  4. 在代码执行阶段,会再次修改变量对象的属性值

本文由网上正规真人赌钱网站发布于前端科技,转载请注明出处:网上正规真人赌钱网站原文出处,原文出处

上一篇:那么些图片方面包车型客车施用能够很好的支援 下一篇:比如
猜你喜欢
热门排行
精彩图文