对于obj.omethod(args)语句，执行引擎应该将其认为是一句代码（而不是我们在源代码中拆分的两句）而执行的。一个值得思考的问题是，在执行过程中，引擎获得了omethod的方法后，该方法已经绑定了obj吗？如果拿到的方法尚未绑定obj，那么是在什么时候、如何将obj作为omethod的this而绑定了呢？

术语解释

要解答这个问题，我们必须要明白其内部的原理。具体的实现可能各不相同，而一个很好的参考对象就是语言的规格文档。在这里，我参阅的是ECMAScript® Language Specification (Standard ECMA-262 5.1 Edition / June 2011)。

注意，下文所述的一些数据结构只是概念性的，是规格文档用于说明原理而使用的，它并不与具体实现相关联。也就是说，我们可以通过它们来了解运作原理而不依赖于具体实现。

有以下几个名词术语是必须要了解的：

• Reference
• Lexical Environments
• Environment Records
• Object Environment Records

Reference

文档的一节中，对Reference的定义是：

Lexical Environment可以称为“词法环境”。文档的一节中，对Lexical Environments的定义是：

可以看出，词法环境是一个说明类型（specification type），即只是规格文档的一个用于说明的抽象概念。它是用于定义 哪些标识符 对应于 哪些变量和函数。词法环境是可以嵌套的，外部词法环境定义的变量在内部词法环境可以被访问到，但如果内部词法环境定义了一个与外部词法环境同名的量就会产生屏蔽现象。

一个词法环境包括了一个环境记录（Environment Record，ER)，以及一个可能为null指向外部词法环境的引用。词法环境通常和一些ECMAScript代码结构有关，如函数声明、With语句、Try语句的Catch子句，当这些结构被执行时，就会产生一个新的词法环境。

A Lexical Environment may serve as the outer environment for multiple inner Lexical Environments. For example,if a FunctionDeclaration contains two nested FunctionDeclarations then the Lexical Environments of each of the nested functions will have as their outer Lexical Environment the Lexical Environment of the current execution of the surrounding function.

Environment Records

Environment Record是“环境记录”，写为ER。在Stack Overflow上有一篇解答很好的说明了如何理解ER。

say();    // #1------I define pi as 3.1415

global.say(); //#2------[In Node.js] I define pi as 3.1415

with(obj){

say();    //#3------I define pi as 4

}

obj.say(); //#4------I define pi as 4

:
The global environment’s Environment Record is an object environment record whose binding object is the global object.The global environment’s outer environment reference is null.

而在 with 语句块中，新的OER被创建，OER被置为 obj，所以其中的say会在obj上寻找（可以省略obj前缀），于是say()的全称是obj.say()。
函数代码中的this被也绑定为obj，或者说，对于say中的pi，执行引擎会在obj这个OER中去寻找（retrieve bingding value from binding object。）

第4个say显式地指定了obj，于是say的ER就是OER，绑定对象是obj。

The with statement adds an object environment record for a computed object to the lexical environment of the current execution context. It then executes a statement using this augmented lexical environment. Finally,it restores the original lexical environment.

既然全局环境的ER是OER，而在with中也是OER，在obj.method(...)中method的ER也是OER，那么什么时候可以用DER呢？

解决方案

现在我们来看看代码

    obj.omethod(args)
=>    Identifier.omethod(args)
=>    [MemberExpression] . omethod(args)
=>    [MemberExpression . IdentifierName](args)
=>    [MemberExpression] (args)
=>    [MemberExpression Arguments]
=>    CallExpression

// The result of evaluating Identifier 'obj' is a Reference
Reference:{
    base: someDER,ref-name: 'obj',strict: true or false,depending on concrete code
}

这里出现了GetValue(V)函数，这个函数的算法是：

1. 如果V的类型不是Reference，则直接返回 V
2. 现在V是一个Reference，令base 是 GetBase(V)的结果
3. 如果IsUnresolvableReference(V)===true，则抛出ReferenceError异常

4. 如果IsPropertyReference(V)（即V的base不是ER也不是undefined），则

   • 如果HasPrimitiveBase(V)===false，即V的base不是一个基础类型（String、Number、Boolean）的对象，那么令get是base的[[Get]]内部方法，否则get按照下文构造（这里‘下文’参见文档原文，这里不再列出）
   • 返回 base.[[Get]]( GetReferencedName(V) )
5. 否则，base一定是一个ER，返回base.GetBindingValue( GetReferencedName(V),GetReferencedName(V))

简单来说，如果GetValue的参数V是一个Reference，那么就从base中获得名为 V的ReferencedName 的绑定量。

现在回到例子中来，对于obj["omethod"]：

1. baseReference 是 对obj的计算结果（obj-> Identifier -> PrimaryExpression -> MemberExpression），通过上一节我们知道，它的结果是Reference:{ base: someDER,strict: ...}
2. baseValue是GetValue(baseReference)的结果，通过上面的算法（其中base：someDER是一个ER），我们知道baseValue 就是 obj对象本身
3. propertyNameReference是对Expression的计算结果，Expression在这里是简单的字符序列omethod，因此propertyNameReference就是omethod（在文档中搜索“PropertyName : IdentifierName”即可找到说明）（如果是类似于obj[bar.foo().getPropName()]之类的复杂表达式，那么propertyNameReference可能就不是简单字符序列了）
4. propertyNameValue是对GetValue(propertyNameReference)的计算结果，由于propertyNameReference是字符序列不是Reference，所以一开始就返回，propertyNameValue是'omethod'
5. 调用CheckObjectCoercible(baseValue)通过
6. 令propertyNameString 是ToString(propertyNameValue)，得到的还是'omethod'
7. 如果是严格模式，令strict为true，否则为false
8. 返回 Reference { base:obj,referenced-name: 'omethod',strict:strict }

函数调用的算法：Function Calls

函数调用的算法：

对于产生式 CallExpression : MemberExpression Arguments 的操作如下：

1. 令 ref 为对MemberExpression 的计算结果。
2. 令func=GetValue(ref)
3. 令argList为Arguments的计算结果，它就是函数调用的参数列表。
4. 若Type(func)是Object，抛出TypeError异常
5. 若IsCallable(func)是false，则抛出TypeError异常

6. 如果Type(ref)是Reference，则：

   • 如果IsPropertyReference(ref)是true，则令thisValue为GetBase(ref)
   • 否则 ref 的base就是一个Environment Record，则令thisValue是GetBase(ref).ImplicitThisValue
7. Else,Type(ref)不是Reference，则令thisValue是undefined
8. 返回func.[[Call]](thisValue,argList)

对于obj.omethod(args)而言，obj.omethod已经规约为MemberExpression，(args)被规约为Arguments：

1. 令 ref 为对obj.method 的计算结果。通过上一节可知，ref为Reference { base:obj,strict:strict }
2. 令func=GetValue(ref)。所以func得到的是obj上名为的omethod的属性，它是一个方法（it's callable）。
3. 令argList为Arguments的计算结果，在这里是args
4. Type(ref)是Reference，由于base是一个object（注意这里base是obj，它是Object类型，而不是ER！），从而IsPropertyReference(ref)是true，则令thisValue是GetBase(ref)，也就是obj。
5. 返回func.[[Call]](obj,args)

总结

从上面可以看出，对于在函数作用域中的obj.omethod(args)而言，经过如下几步：

1. obj被包装为一个Reference：ref-1，它的base是函数作用域链中的某个DER，Type(ref-1.base)==ER
2. obj.omethod被包装为一个Reference：ref-2，它的base是obj对象，Type(ref-2.base)==Object
3. 从ref-2中提取方法，传入参数列表，并将ref-2的base作为this，调用该方法