JavaScript 中的规格函数 `GetMethod` 与 `Call`：属性查找、符号验证与执行上下文的绑定 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JavaScript 内部机制解析：`GetMethod` 与 `Call` 在属性查找、符号验证及执行上下文绑定中的核心作用

在JavaScript的运行时环境中，每一个操作的背后都隐藏着一套复杂而精密的内部机制。我们日常使用的属性访问、方法调用等看似简单的语法糖，实际上是由ECMAS262规范中定义的一系列内部方法和操作来驱动的。本文将深入探讨两个核心的内部操作：GetMethod 和 Call，它们是理解JavaScript对象模型、方法查找、this绑定和函数执行的关键。我们将从它们的定义、工作原理、协同作用，以及它们如何处理属性查找、符号验证和执行上下文绑定等方面进行详细阐述。

一、 JavaScript 对象模型与内部方法概述

在JavaScript中，一切皆对象（或可以被封装成对象）。每个对象都有一组内部方法（Internal Methods）和内部槽（Internal Slots），这些是规范层面的概念，通常不能直接从JavaScript代码中访问，但它们定义了对象的底层行为。

内部方法 (Internal Methods) 是对象实现其基本操作的抽象接口。它们通常以双层方括号 [[MethodName]] 的形式表示，例如 [[Get]]、[[Set]]、[[Call]]、[[Construct]] 等。这些方法定义了如何获取属性、设置属性、调用函数、创建实例等。

内部槽 (Internal Slots) 是存储对象内部状态的属性，例如 [[Prototype]]（指向原型）、[[Extensible]]（是否可扩展）等。

我们今天要讨论的 GetMethod 和 Call，虽然不是ECMAScript规范中直接的 [[GetMethod]] 或 [[Call]] 这样的内部方法名称，但它们是规范中定义的抽象操作，用于描述实际的内部行为。理解它们，能帮助我们更深入地理解JavaScript代码的执行流程。

二、 `GetMethod` 抽象操作：查找可调用的方法

GetMethod 是一个至关重要的抽象操作，其核心目的是从一个对象上查找并返回一个可调用的方法。它不仅仅是简单地获取一个属性的值，更重要的是，它要确保这个值是一个可以被执行的函数。

1. `GetMethod` 的定义与目的

在ECMAScript规范中，GetMethod(V, P) 抽象操作定义如下：
给定一个值 V（通常是一个对象，被称为“接收者”或“receiver”）和一个属性键 P（Property Key，可以是字符串或Symbol），GetMethod 的目标是：

获取属性值： 使用 [[Get]] 内部方法从 V 上查找属性 P 的值。这个查找过程会遵循原型链。
验证可调用性： 检查获取到的属性值是否是一个可调用的对象（即一个函数）。
返回结果： 如果该值是可调用的，则返回该值；否则，返回 undefined。

这个操作通常是方法调用（如 obj.method()）的第一步。它确保了在尝试执行方法之前，我们确实找到了一个可以执行的函数。

2. 属性查找机制 (`[[Get]]`)

GetMethod 的第一步是依赖于 [[Get]] 内部方法来获取属性值。[[Get]] 的查找过程遵循标准的JavaScript属性查找规则：

自有属性优先： 首先在对象 V 的自有属性中查找属性 P。如果找到，则返回其值。
原型链遍历： 如果在自有属性中未找到，则沿着 V 的原型链向上查找。V 的原型由其 [[Prototype]] 内部槽指向。这个过程会递归地在每一个原型对象上查找属性 P，直到找到该属性或者到达原型链的末端（即 null）。
属性描述符： 在查找过程中，[[Get]] 还会考虑属性的描述符。例如，如果一个属性是数据属性，它会返回其 [[Value]]；如果是一个访问器属性（getter/setter），它会调用其 [[Get]] 函数并返回结果。

示例：属性查找

const proto = {
    x: 10,
    greet() {
        console.log("Hello from proto!");
    }
};

const obj = Object.create(proto);
obj.y = 20;
obj.sayHi = function() {
    console.log("Hi from obj!");
};

// 1. 自有属性
console.log(obj.y);        // 20
console.log(obj.sayHi);    // [Function: sayHi]

// 2. 原型链查找
console.log(obj.x);        // 10
console.log(obj.greet);    // [Function: greet]

// 3. 属性不存在
console.log(obj.z);        // undefined

3. 符号验证 (`IsCallable`)

在获取到属性值之后，GetMethod 的关键在于验证这个值是否是“可调用的”（Callable）。这由 IsCallable(argument) 抽象操作完成。

可调用的对象包括：

函数对象： 所有通过 function 关键字、箭头函数语法、Function 构造函数或类声明创建的函数。
内置函数： 如 Array.prototype.push, Object.keys 等。
绑定函数： 通过 Function.prototype.bind() 创建的函数。
类构造函数： 类本身也是可调用的，但它们通常通过 new 关键字 [[Construct]] 而非直接 [[Call]]。

不可调用的值包括：

基本类型值： string, number, boolean, symbol, bigint, null, undefined。
普通对象： {}、[] 等。
Proxy 对象：如果其 [[ProxyHandler]] 没有定义 apply trap，或者 target 不是可调用对象。

如果 GetMethod 发现获取到的属性值不是一个可调用的对象，它就会返回 undefined。后续的 Invoke 操作（我们将在后面讨论）在接收到 undefined 时，通常会抛出一个 TypeError，提示该属性不是一个函数。

示例：符号验证

const obj = {
    method1: function() { console.log("Method 1"); },
    method2: () => console.log("Method 2"),
    value: 123,
    text: "hello",
    objProp: { a: 1 },
    nullProp: null,
    undefinedProp: undefined
};

// 假设 GetMethod 内部工作机制
function simulateGetMethod(receiver, key) {
    const value = receiver[key]; // 模拟 [[Get]]
    if (typeof value === 'function' || (typeof value === 'object' && value !== null && typeof value.apply === 'function')) {
        // 简化 IsCallable 检查，实际更复杂
        return value;
    }
    return undefined;
}

console.log(simulateGetMethod(obj, 'method1'));        // [Function: method1]
console.log(simulateGetMethod(obj, 'method2'));        // [Function: method2]
console.log(simulateGetMethod(obj, 'value'));          // undefined (不是函数)
console.log(simulateGetMethod(obj, 'text'));           // undefined (不是函数)
console.log(simulateGetMethod(obj, 'objProp'));        // undefined (不是函数)
console.log(simulateGetMethod(obj, 'nullProp'));       // undefined (null 不是函数)
console.log(simulateGetMethod(obj, 'undefinedProp'));  // undefined (undefined 不是函数)
console.log(simulateGetMethod(obj, 'nonExistent'));    // undefined (属性不存在，所以值是 undefined，也不是函数)

// 实际运行时调用非函数属性会报错
try {
    obj.value();
} catch (e) {
    console.error(`Error calling obj.value(): ${e.message}`); // obj.value is not a function
}

4. `GetMethod` 与 `Proxy`

Proxy 对象允许我们拦截并自定义对目标对象的操作。GetMethod 操作中涉及的 [[Get]] 内部方法在遇到 Proxy 时，会触发 get 陷阱（trap）。如果 Proxy 拦截了 get 操作，那么 GetMethod 将会使用 get 陷阱返回的值进行后续的可调用性验证。

const target = {
    myMethod: function() { console.log("Original method"); },
    myValue: 123
};

const handler = {
    get(target, prop, receiver) {
        if (prop === 'myMethod') {
            console.log(`Intercepting get for ${String(prop)}`);
            // 返回一个不同的函数
            return function() { console.log("Proxied method"); };
        }
        if (prop === 'myValue') {
            console.log(`Intercepting get for ${String(prop)}`);
            // 返回一个非函数值
            return "This is not a function";
        }
        return Reflect.get(target, prop, receiver); // 默认行为
    }
};

const proxy = new Proxy(target, handler);

// 1. 通过 GetMethod 找到并调用被代理的函数
proxy.myMethod(); // Output: "Intercepting get for myMethod", "Proxied method"

// 2. GetMethod 找到非函数值，后续调用会失败
try {
    proxy.myValue();
} catch (e) {
    console.error(`Error calling proxy.myValue(): ${e.message}`); // Output: "Intercepting get for myValue", "proxy.myValue is not a function"
}

// 3. 未拦截的属性，走默认行为
proxy.anotherProp = function() { console.log("Another prop"); };
proxy.anotherProp(); // Output: "Another prop"

通过 Proxy，我们可以灵活地控制 GetMethod 返回什么，从而影响后续的函数调用行为。

`GetMethod` 总结表格

阶段	描述	依赖的内部操作/检查	示例
属性查找	从接收者对象 `V` 及其原型链上查找属性 `P` 的值。	`[[Get]]`	`obj.method`、`obj.prop`
值获取	返回查找到的属性值。如果属性不存在，则返回 `undefined`。如果属性是访问器，则调用其 `getter`。	`[[Get]]`	`obj.x` 返回 `10`，`obj.getterProp` 返回 `getter` 的结果。
可调用性验证	检查获取到的值是否为可调用的对象（函数、内置函数、绑定函数等）。	`IsCallable(value)`	`typeof value === 'function'` (简化版)
结果返回	如果值是可调用的，则返回该值；否则，返回 `undefined`。	N/A	成功返回 `[Function: myMethod]`，失败返回 `undefined`。
异常处理	`GetMethod` 本身不抛出异常，如果返回 `undefined`，通常由其调用者（如 `Invoke`）在尝试执行时抛出 `TypeError`。	`TypeError` (由调用者处理)	`obj.nonCallableValue()` 会导致 `TypeError: obj.nonCallableValue is not a function`，这是 `Invoke` 抛出的。

三、 `Call` 抽象操作：执行函数与绑定执行上下文

Call 是另一个核心抽象操作，它负责执行一个函数对象。它不仅执行函数的代码，还负责设置函数执行时的环境，特别是 this 值的绑定。

1. `Call` 的定义与目的

在ECMAScript规范中，Call(F, V, argumentsList) 抽象操作定义如下：
给定一个函数对象 F，一个作为 this 值的 V（被称为“thisValue”或“receiver”），以及一个参数列表 argumentsList，Call 的目标是：

验证函数： 确保 F 是一个可调用的函数对象。如果不是，则抛出 TypeError。
建立执行上下文： 为函数 F 的执行创建一个新的执行上下文。
绑定 this： 根据 V 和函数的类型（普通函数、箭头函数、严格模式/非严格模式）确定并绑定 this 值。
绑定参数： 将 argumentsList 中的值映射到函数的形参。
执行函数体： 运行函数 F 的代码。
返回结果： 返回函数执行的结果。

Call 是所有函数调用的基石，无论是 func()、obj.method() 还是 func.call(thisArg, ...args)，最终都会归结到这个内部操作。

2. `this` 值的绑定

this 值的绑定是 Call 操作中最复杂也是最重要的部分之一。this 的值在函数被调用时确定，而非在函数定义时。其规则如下：

默认绑定 (Default Binding)：
- 当函数作为独立函数被调用时（例如 func()），this 默认绑定到全局对象 (window 在浏览器，global 在Node.js) 如果是非严格模式。
- 在严格模式下 ('use strict')，this 会被绑定到 undefined。
```
function showThis() {
    console.log(this);
}

showThis(); // 在浏览器中通常是 window，在Node.js中是 global (非严格模式)

(function() {
    "use strict";
    showThis(); // undefined (严格模式下)
})();
```

隐式绑定 (Implicit Binding)：

当函数作为对象的方法被调用时（例如 obj.method()），this 会绑定到调用该方法的对象 obj。
这个对象就是我们前面 GetMethod 传入的“接收者” V。

const myObject = {
    name: "MyObject",
    greet: function() {
        console.log(`Hello, I am ${this.name}`);
    }
};

myObject.greet(); // Hello, I am MyObject (this 绑定到 myObject)

const anotherObject = {
    name: "AnotherObject",
    say: myObject.greet
};

anotherObject.say(); // Hello, I am AnotherObject (this 绑定到 anotherObject)

显式绑定 (Explicit Binding)：

使用 Function.prototype.call(), Function.prototype.apply(), Function.prototype.bind() 方法可以明确指定 this 的值。
call() 和 apply() 立即执行函数，并将其第一个参数作为 this 值。
bind() 创建一个新函数，该新函数的 this 值被永久绑定到 bind() 的第一个参数。

function introduce(age, city) {
    console.log(`My name is ${this.name}, I am ${age} years old and from ${city}.`);
}

const person = { name: "Alice" };

introduce.call(person, 30, "New York");    // My name is Alice, I am 30 years old and from New York.
introduce.apply(person, [25, "London"]);   // My name is Alice, I am 25 years old and from London.

const boundIntroduce = introduce.bind(person, 35);
boundIntroduce("Paris");                   // My name is Alice, I am 35 years old and from Paris.

new 绑定 (New Binding)：
- 当函数作为构造函数与 new 关键字一起使用时（例如 new MyClass()），this 会绑定到新创建的对象实例。
```
function Person(name) {
    this.name = name;
}

const p1 = new Person("Bob");
console.log(p1.name); // Bob (this 绑定到新创建的 p1 对象)
```

箭头函数 (Lexical this):

箭头函数没有自己的 this 绑定。它们的 this 值是在定义时从其外层（词法）作用域继承的。
这意味着 call(), apply(), bind() 无法改变箭头函数的 this。

const obj = {
    name: "Outer",
    arrowGreet: () => {
        console.log(`Hello from arrow, this is:`, this);
    },
    methodGreet: function() {
        console.log(`Hello from method, this is:`, this);
    }
};

obj.arrowGreet(); // this 绑定到定义时外层作用域的 this (通常是全局对象)
obj.methodGreet(); // this 绑定到 obj

const anotherObj = { name: "Another" };
obj.arrowGreet.call(anotherObj); // 仍然是全局对象，不会改变
obj.methodGreet.call(anotherObj); // this 绑定到 anotherObj

this 值的规范化 (ThisValue Optimization):
在 Call 操作内部，传入的 thisValue 会经过一个规范化过程：

如果 thisValue 是 null 或 undefined：
- 在非严格模式下，thisValue 会被替换为全局对象。
- 在严格模式下，thisValue 保持不变（即 null 或 undefined）。
如果 thisValue 是一个基本类型值（如 string, number, boolean, symbol, bigint）：
- 它会被自动装箱（boxed）成对应的包装对象（String、Number、Boolean、Symbol、BigInt 对象）。
如果 thisValue 已经是对象，则直接使用。

3. 执行上下文的绑定

当 Call 操作被触发时，JavaScript引擎会创建一个新的执行上下文（Execution Context）。执行上下文是JavaScript代码执行环境的抽象概念，它包含了函数执行所需的所有信息：

词法环境 (LexicalEnvironment)：
- 存储函数内部声明的变量、函数和参数。
- 它维护着一个对外部词法环境的引用，形成了作用域链。函数可以通过作用域链访问到其外部作用域的变量。
变量环境 (VariableEnvironment)：
- 在ES6之前与词法环境相同。在ES6中，let 和 const 声明的变量存储在词法环境的声明记录中，而 var 和函数声明存储在变量环境的声明记录中。
this 绑定 (This Binding)：
- 前面讨论的 this 值就被绑定到这个执行上下文。

当 Call 操作执行一个函数时，一个新的函数执行上下文被推入调用栈（Call Stack）。这个上下文的创建包括：

确定 this 值。
创建新的词法环境和变量环境： 包含了函数的参数、内部声明的变量和函数。
连接作用域链： 新的词法环境的外部环境引用指向了函数定义时所在的词法环境。

一旦函数执行完毕，其执行上下文就会从调用栈中弹出。

示例：执行上下文与 this 绑定

function outer() {
    const outerVar = "I am outer";
    console.log("Outer 'this':", this); // 默认绑定或隐式绑定

    function inner() {
        const innerVar = "I am inner";
        console.log("Inner 'this':", this); // 默认绑定
        console.log("Accessing outerVar:", outerVar); // 通过作用域链访问
    }

    inner(); // 内部函数调用，其 this 再次取决于调用方式
}

const obj = {
    name: "MyObject",
    method: outer
};

outer();       // 默认绑定，outer 的 this 是全局对象
obj.method();  // 隐式绑定，outer 的 this 是 obj，inner 的 this 仍是全局对象

4. `Call` 与 `Proxy`

Proxy 对象也可以拦截 Call 操作。当一个 Proxy 对象被当作函数调用时，会触发其 apply 陷阱。

const targetFunction = function(a, b) {
    console.log(`Target function executed. this:`, this, `args:`, a, b);
    return a + b;
};

const handler = {
    apply(target, thisArg, argumentsList) {
        console.log(`Intercepting apply!`);
        console.log(`Target:`, target);
        console.log(`thisArg:`, thisArg);
        console.log(`Arguments:`, argumentsList);
        // 可以修改 thisArg 或 argumentsList，也可以调用原始函数
        return Reflect.apply(target, thisArg, argumentsList);
        // 或者返回完全不同的结果
        // return "Proxy intercepted and returned a string";
    }
};

const proxyFunction = new Proxy(targetFunction, handler);

const context = { id: 1 };
const result = proxyFunction.call(context, 10, 20);
// Output:
// Intercepting apply!
// Target: [Function: targetFunction]
// thisArg: { id: 1 }
// Arguments: [ 10, 20 ]
// Target function executed. this: { id: 1 } args: 10 20
console.log(`Result:`, result); // Result: 30

apply 陷阱允许我们完全控制函数的执行，包括 this 值的绑定和参数的传递。

`Call` 总结表格

阶段	描述	依赖的内部操作/检查	示例
函数验证	确保 `F` 是一个可调用的对象。如果不是，则立即抛出 `TypeError`。	`IsCallable(F)`	`(123)()` 会抛出 `TypeError: 123 is not a function`。
`this` 绑定	根据 `V` (thisValue) 和函数的调用方式（默认、隐式、显式、`new`、箭头函数）确定并规范化 `this` 的最终值。	`ThisBinding(F, V)`	`func()` (全局对象/`undefined`)，`obj.method()` ( `obj` )，`func.call(arg)` ( `arg` )，`new Func()` (新对象)。
参数绑定	将 `argumentsList` 中的值映射到函数 `F` 的形参。	N/A	`func(a, b)` 中 `a` 和 `b` 被赋予 `argumentsList` 中的相应值。
执行上下文	创建一个新的函数执行上下文，包括词法环境、变量环境和 `this` 绑定，并将其推入调用栈。	`NewFunctionEnvironment`	`outer()` 调用时创建 `outer` 的执行上下文，其中 `this` 和 `outerVar` 被绑定；`inner()` 调用时创建 `inner` 的执行上下文，其 `this` 绑定并可访问 `outerVar`。
函数体执行	运行函数 `F` 内部的代码逻辑。	N/A	`console.log("Hello"); return 1;` 等代码被执行。
结果返回	返回函数执行的最终结果。如果函数没有明确的 `return` 语句，则返回 `undefined`。	N/A	`function add(a,b){ return a+b; } add(1,2)` 返回 `3`。 `function noReturn(){}` 返回 `undefined`。

四、 `GetMethod` 与 `Call` 的协同作用：`Invoke` 抽象操作

在实际的JavaScript代码中，例如 obj.method(arg1, arg2) 这样的方法调用，并不是直接调用 Call。它涉及到 GetMethod 和 Call 的协同工作，通常由一个更高级别的抽象操作 Invoke 来协调。

Invoke(V, P, argumentsList) 抽象操作定义了如何在一个对象 V 上调用其属性 P 所指向的方法，并传入 argumentsList。其大致流程如下：

获取方法： 调用 method = GetMethod(V, P)。
- 这一步会查找 V 上的属性 P，并验证其是否可调用。
验证方法存在： 如果 method 为 undefined，这意味着 P 属性不存在或不是一个可调用的函数。此时，Invoke 会抛出一个 TypeError。
执行方法： 如果 method 存在且可调用，则调用 Call(method, V, argumentsList)。
- 这里 V 被作为 this 值传递给 Call 操作，确保了方法内部 this 绑定到原始的接收者对象 obj。

流程图 (概念性)：

obj.method(arg1, arg2)
        ↓
    Invoke(obj, "method", [arg1, arg2])
        ↓
    1. method = GetMethod(obj, "method")
        ↓
        a. [[Get]](obj, "method") -> function_object
        b. IsCallable(function_object) -> true
        c. Returns function_object
        ↓
    2. Is method === undefined? (No)
        ↓
    3. Call(method, obj, [arg1, arg2])
        ↓
        a. IsCallable(method)? (Yes)
        b. Determine this value: obj
        c. Establish execution context (this, arguments)
        d. Execute function_object body
        e. Return result
        ↓
Return result of function_object execution

示例：实际方法调用

const calculator = {
    value: 10,
    add(num) {
        // 在这里，this 绑定到 calculator
        return this.value + num;
    },
    subtract: (num) => {
        // 箭头函数，this 绑定到定义时的词法作用域（通常是全局对象或 undefined）
        return this.value - num; // this.value 将是 undefined 或全局对象的 value
    },
    multiply: 50 // 非函数属性
};

// 1. 调用 add 方法 (正常流程)
console.log(calculator.add(5)); // GetMethod 找到 add，Call 绑定 this 为 calculator，结果 15

// 2. 调用 subtract 方法 (this 绑定差异)
// 假设在全局作用域下执行此代码，全局 value 为 undefined
console.log(calculator.subtract(5)); // GetMethod 找到 subtract，Call 绑定 this 为全局对象，结果 NaN (undefined - 5)

// 3. 调用非函数属性 (Invoke 抛出 TypeError)
try {
    calculator.multiply(2);
} catch (e) {
    console.error(`Error calling calculator.multiply(): ${e.message}`); // TypeError: calculator.multiply is not a function
}

这个例子清晰地展示了 GetMethod 如何查找并验证函数，以及 Call 如何绑定 this。当 GetMethod 成功返回一个函数后，Invoke 会将原始的接收者对象（calculator）作为 this 值传递给 Call，确保了 add 方法中的 this.value 能正确访问 calculator.value。而 subtract 作为箭头函数，其 this 在定义时就已经确定，不受 Invoke 传递 this 值的影响。

高级应用与 `Reflect` API

Reflect API 提供了一组静态方法，用于以更命令式、更可控的方式执行JavaScript对象的内部方法。其中 Reflect.get 和 Reflect.apply 与 GetMethod 和 Call 密切相关。

Reflect.get(target, propertyKey, receiver): 对应 [[Get]] 内部方法。它仅获取属性值，不进行可调用性验证。receiver 参数用于在 getter 属性或 Proxy 陷阱中正确绑定 this。
Reflect.apply(target, thisArgument, argumentsList): 对应 [[Call]] 内部方法。它直接执行一个函数，并明确指定 this 值和参数列表。

const obj = {
    name: "ReflectObj",
    greet: function() {
        console.log(`Hello, I am ${this.name}`);
    }
};

// 使用 Reflect.get 模拟 GetMethod 的第一步
const method = Reflect.get(obj, 'greet', obj); // 获取 greet 函数，receiver 为 obj

// 验证可调用性 (手动)
if (typeof method === 'function') {
    console.log("Method is callable.");
    // 使用 Reflect.apply 模拟 Call
    Reflect.apply(method, obj, []); // 执行方法，this 绑定到 obj
} else {
    console.log("Method is not callable or does not exist.");
}

// 模拟 Invoke 的失败情况
const nonMethod = Reflect.get(obj, 'name', obj);
if (typeof nonMethod !== 'function') {
    console.error(`Error: ${nonMethod} is not a function.`); // name 属性不是函数
}

Reflect API 在编写通用库、代理对象和元编程时非常有用，因为它允许开发者以与JavaScript引擎内部操作更接近的方式来控制对象的行为。

五、结语

GetMethod 和 Call 作为ECMAScript规范中的抽象操作，是JavaScript运行时机制的基石。GetMethod 负责在对象及其原型链上查找并验证一个可调用的方法，确保了我们尝试执行的确实是一个函数。而 Call 则负责为函数创建一个完整的执行上下文，精确地绑定 this 值和函数参数，并最终执行函数体。

通过深入理解这两个操作的细节，包括它们的属性查找机制、严格的符号验证过程以及复杂的 this 绑定规则，我们能够更深刻地洞察JavaScript代码的实际运行方式，从而编写出更健壮、更可预测、更高效的代码。这些内部机制是JavaScript灵活性的来源，也是其行为有时令人感到“魔幻”的根本原因。掌握它们，无疑会使我们成为更专业的JavaScript开发者。

JavaScript 内部机制解析：GetMethod 与 Call 在属性查找、符号验证及执行上下文绑定中的核心作用

一、 JavaScript 对象模型与内部方法概述

二、 GetMethod 抽象操作：查找可调用的方法

1. GetMethod 的定义与目的

2. 属性查找机制 ([[Get]])

3. 符号验证 (IsCallable)

4. GetMethod 与 Proxy

GetMethod 总结表格

三、 Call 抽象操作：执行函数与绑定执行上下文

1. Call 的定义与目的

2. this 值的绑定

3. 执行上下文的绑定

4. Call 与 Proxy

Call 总结表格

四、 GetMethod 与 Call 的协同作用：Invoke 抽象操作

高级应用与 Reflect API

五、 结语

发表回复 取消回复