第一次翻译，愿望列位多多见谅，有毛病处还望指出，迎接提出发起。

Chapter 1.Execution Contexts

1. Introduction （引见）

2. Definitions （定义）

3. Types of excutable code （可实行代码的范例）

   1. Global code（全局代码）

   2. Funcion code（函数代码）

   3. Eval code（eval代码）

4. Conclusion（结论）

5. Additional literature （文献参考）

Introduction

In this note we will metion execution contexts of ECMAScript and types of executable code related with them.

译：在这篇笔记中，我们将议论实行环境和相干的可实行代码范例。

Definitions

Every time when control is transferred to ECMAScript executable code, control is entered an execution context.

译：当控制流行将实行代码时，老是先进入实行上下文

Execution context( abbreviated from – EC) is the abstract concept used by ECMA-262 specification for typification and differentation of an executable code.

译：实行上下文（缩写为EC）是ECMA-262运用的抽象概念，一般用来示意可实行代码的范例和区分。

The standard does not define accurate structure and kind of EC from the technical implementation viewpoint; it is a question of the ECMAScript-engines implementing the standard.

译：官方范例没有定义EC的确实组织和手艺完成，根据范例来完成依旧ECMAScript引擎的题目

Logically, set of active execution contexts forms a stack. The bottom of this stack is always a global context, the top – a current (active) execution context. The stack is modified (pushed/popped) during the entering and exiting various kinds of EC.

译：从逻辑上来看，很多激活的实行上下文会构成一个客栈组织。客栈组织的底部是全局实行上下文，顶部是当前实行上下文。差别的实行上下文切换时客栈会发作转变

Types of executable code

With abstract concept of an execution context, the concept of type of an executable code is related. Speaking about code type, it is possible in the certain moments to mean an execution context.

译：论及代码范例时，在某些时刻能够也意味着实行上下文。可实行上下文的抽象概念和其范例是分不开的

For examples, we define the stack of execution contexts as an array:

译：比方，我们将实行上下文的客栈定义为数组

ECStack = [];

The stack is pushed every time on entering a function (even if the function is called recursively or as the constructor), and also at built-in eval function work.

译：控制流每次进入函数（纵然该函数是递归挪用或作为组织器）时，入栈就会发作，一样内嵌在该函数中的eval函数也会激发入栈行动。

Global code

This type of code is processed at level Program: i.e. the loaded external .js -file or the local inline-code (inside the <script></script> tags). The global code does not include any parts of a code which are in bodies of functions.

译：这类范例的代码是以顺序级别处置惩罚的：比如说分外的js文件或许部分的内连代码（在<script>标签中的)。全局代码不包含任何函数体内的代码

At initialization(program start), ECStack looks like:

ECStack = [
   globalContext  
];

Function code

On entering the function code (all kinds of functions), ECStack is pushed with new elements. It is necessary to notice that the code of concrete function does not include codes of the inner functions.

译：一旦进入函数代码，ECStack就会到场新元素。该函数代码并不包含其内部函数的代码。

For example, let’s take the function which calls itself recursively once:

(function foo(flag) {    
    if (flag) {
        return;
    }
    foo(true);
})(false);

Then, ECStack is modified as follows:

//first activation of foo
ECStack = [
   <foo>    functionContext
   globalContext
];
//recursive activation of foo
ECStack = [
   <foo> functionContext - recursively
   <foo> functionContext
   globalContext
];

Every return from a function exits the current execution context and ECStack poped accordingly – consecutively and upside-down － quite natural implementation of a stack. After the work of this code is finished, ECStack again contains only globalContext－ until the program end.

译：函数的每次返回都代表了当前实行上下文的完毕，ECStack会有序的推出该函数。函数体中代码实行完后，ECStack只剩全局上下文直到顺序完毕

A thrown but not caught exception may also exit one or more execution contexts:

(function foo() {
   (function bar() {
       throw 'Exit from bar and foo contexts';
   })();
})();

Eval code

Things are more interesting with eval code. In this case, there is a concept of a calling context, i.e. a context from which eval function is called.

译：eval代码更有意义。在该情况下，有个挪用上下文的新概念，其本质是上下文，只不过是当eval函数被挪用时的上下文

The actions made by eval, such as variable or function definition, influence exactly the calling context:

//influence global context
eval('var x = 10');

(function foo() {
   // and here, variable "y" is
   // created in the local context
   // of "foo" function
   eval('var y = 20');
})();

alert(x);  // 10
alert(y);  // "y" is no defined

Note, in the strict-mode of ES5,eval already does not influence the calling context, but instead evaluates the code in the local sandbox.

For the example above we hav the following ECStack modifications:

ECStack = [
   globalContext
];

// eval("var x = 10");
ECStack.push({
   context: evalContext,
   callingContext: globalContext
});

//eval extied context
ECStack.pop();

//foo function call
ECStack.push(<foo> functionContext);

//eval("var y = 20");
ECStack.push({
   context:evalContext,
   callingContext: <foo> functionContext
});

//return from eval
ECStack.pop();

//return from foo
ECStack.pop();

I.e. quite casual and logical call-stack.

译

In old SpiderMonkey implementations(Firefox), up to version 1.7, it was possible to pass a calling context as a second argument for eval function. Thus, if the context still exists, it is possible to influence private variables:

function foo() {
   var x = 1;
   return function() {alert(x);};
};
var bar = foo();
bar(); // 1
eval("x = 2", bar); //pass context, influence internal var "x"
bar(); // 2    

However, due to security reasons in modern engines it was fixed and is not significant anymore.

Conclusion

This theoretical minimum is required the further analysis of details related with execution contexts, such as variable object or scope chain, which descriptions can be found in the appropriate chapters.

译：这片理论最低要求是控制实行环境的细节剖析，比如说变量对象或作用域，有关细节形貌能够在相干章节中查阅到。

Additional literature

Corresponding section ECMA-262-3 specification － 10. Execution Contexts.

译：该内容截选自ECMA-262-3申明第十章实行上下文。