罗罗编程学习记录
本页内容 展开查看

03.2.1.4 this 与函数绑定

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.2 JavaScript / 03.2.1 语言核心与对象模型

03.2.1.4-001 this 是什么?由什么决定?

一句话结论

this 是函数执行期绑定的上下文对象,不是函数定义时确定;它由调用方式(调用位置与形式)决定,同一函数在不同调用下 this 可以不同。

概念解释

  • this 不是词法作用域变量,不沿作用域链查找。
  • 绑定在函数被调用时确定。
  • 箭头函数例外:this 继承外层词法作用域。

原理流程

  1. 函数被调用。
  2. 按调用形式匹配绑定规则。
  3. 函数内 this 指向绑定对象。

代码 / 示例

function who() { return this; }
who();            // 非严格模式全局对象,严格模式 undefined
const obj = { who };
obj.who();        // obj

常见误区

  • 误区:this 指向函数自身;正解:this 是调用上下文,不是函数对象本身。
  • 误区:this 由定义位置决定;正解:普通函数 this 由调用方式决定。

追问

  • Q:方法内 this 与作用域变量冲突时? A:this 是上下文绑定,变量沿作用域链查找,两套机制独立。
  • Q:如何在函数内稳定引用 this? A:保存 const self = this,或用箭头函数/ bind。

03.2.1.4-002 默认绑定规则是什么?

一句话结论

函数独立调用(无对象前缀、无显式绑定、非 new)时走默认绑定:非严格模式 this 为全局对象,严格模式为 undefined。

概念解释

  • 独立调用:fn()。
  • 严格模式阻断全局对象绑定。
  • 模块/类代码默认严格模式。

原理流程

  1. 调用形式不满足其他绑定规则。
  2. 按默认规则解析 this。
  3. 严格模式下为 undefined。

代码 / 示例

function f() { console.log(this); }
f(); // 非严格:globalThis;严格:undefined

常见误区

  • 误区:独立调用 this 一定是 window;正解:严格模式与模块中为 undefined。
  • 误区:默认绑定 this 指向函数所在作用域;正解:指向全局/undefined,与词法作用域无关。

追问

  • Q:嵌套函数独立调用也走默认绑定吗? A:是,即使定义在对象方法内,解绑独立调用仍默认绑定。
  • Q:浏览器全局对象引用? A:window,跨环境用 globalThis。

03.2.1.4-003 隐式绑定如何判断?

一句话结论

obj.fn() 形式调用时,调用前缀对象 obj 成为 this;方法引用链上最后一个对象决定 this。

概念解释

  • 调用点有对象前缀。
  • 多级链:a.b.fn(),this 为 b。
  • 方法从对象取出后独立调用,隐式绑定丢失。

原理流程

  1. 识别调用表达式的对象前缀。
  2. 取前缀对象作为 this。
  3. 函数内通过 this 访问该对象。

代码 / 示例

const car = {
  speed: 60,
  show() { return this.speed; }
};
car.show();          // 60,this = car
const fn = car.show;
fn();                // 隐式丢失,走默认绑定

常见误区

  • 误区:方法定义在哪个对象就绑定哪个对象;正解:this 看调用前缀,不看定义位置。
  • 误区:car.show() 中 this 是 car.show;正解:this 是前缀对象 car。

追问

  • Q:链式调用 a.b.c.fn() 的 this? A:c。
  • Q:对象方法作为回调传参会丢失吗? A:会,传入后独立调用,需 bind/箭头函数绑定。

03.2.1.4-004 call 与 apply 如何显式绑定 this?

一句话结论

fn.call(thisArg, arg1, arg2) 与 fn.apply(thisArg, [args]) 立即调用函数并指定 this;区别仅在参数传递形式:call 逐个传参,apply 传参数数组。

概念解释

  • 显式绑定:手动指定 this 对象。
  • 立即执行,不返回新函数。
  • thisArg 为 null/undefined 时按默认规则处理(严格模式按传入值)。

原理流程

  1. 指定 thisArg 与参数。
  2. 函数以该 this 调用。
  3. 返回函数返回值。

代码 / 示例

function sum(a, b) { return a + b; }
sum.call(null, 1, 2);    // 3
sum.apply(null, [1, 2]); // 3

const person = { name: "Ann" };
function greet() { return this.name; }
greet.call(person);       // "Ann"

常见误区

  • 误区:call/apply 返回绑定后的新函数;正解:它们立即调用,bind 才返回新函数。
  • 误区:apply 第二个参数是对象;正解:是类数组/数组参数列表。

追问

  • Q:借用数组方法给类数组用什么? A:Array.prototype.slice.call(arguments) 或 apply 传数组。
  • Q:thisArg 传原始值会包装吗? A:非严格模式装箱为包装对象,严格模式保持原值。

03.2.1.4-005 bind 硬绑定有什么特点?

一句话结论

fn.bind(thisArg, ...args) 返回一个新函数,内部 this 永久绑定为 thisArg;后续 call/apply 也无法改变其 this,绑定优先级高于隐式与默认绑定。

概念解释

  • 硬绑定:返回函数 this 不可再改。
  • 预置参数:bind 可柯里化部分参数。
  • 多次 bind 不改变首次绑定。

原理流程

  1. 调用 bind 生成包装函数。
  2. 包装函数内部固定 this 与预置参数。
  3. 调用包装函数时按绑定执行。

代码 / 示例

const obj = { n: 1 };
const bound = function () { return this.n; }.bind(obj);
bound();              // 1
bound.call({ n: 99 });// 仍为 1,硬绑定不可改

常见误区

  • 误区:bind 后还能被 call 改 this;正解:硬绑定优先级最高,call/apply 无效。
  • 误区:bind 立即执行原函数;正解:返回新函数,调用时才执行。

追问

  • Q:bind 预置参数怎么工作? A:bind 第二参起作为前置参数,调用新函数时追加在后。
  • Q:箭头函数能 bind 吗? A:可以调用但无效,箭头函数 this 已词法固定。

03.2.1.4-006 new 绑定如何确定 this?

一句话结论

通过 new 调用构造函数时,this 指向新创建的实例对象;构造函数内对 this 的属性赋值成为实例自身属性。

概念解释

  • new 创建对象并关联原型。
  • 构造内 this 为新实例。
  • 返回对象则覆盖新实例,返回原始值忽略。

原理流程

  1. 创建空对象并关联原型。
  2. this 绑定新对象执行构造。
  3. 返回值按规则确定最终实例。

代码 / 示例

function User(name) {
  this.name = name; // this = new 实例
}
const u = new User("Ann");
u.name; // "Ann"

常见误区

  • 误区:构造函数必须显式 return this;正解:默认返回新对象,return 对象才覆盖。
  • 误区:new 绑定 this 是构造函数自身;正解:this 是新实例。

追问

  • Q:构造函数返回字符串会怎样? A:原始返回被忽略,仍返回新实例。
  • Q:箭头函数能 new 吗? A:不能,没有 this 与 prototype。

03.2.1.4-007 四种绑定的优先级顺序是什么?

一句话结论

优先级从高到低:new 绑定 > 显式绑定(call/apply/bind)> 隐式绑定(对象前缀)> 默认绑定;箭头函数 this 不参与这套优先级,按词法捕获。

概念解释

  • 高优先级规则覆盖低优先级。
  • 判断时从高到低匹配。
  • bind 硬绑定在显式层内不可再被覆盖。

原理流程

  1. 是否 new 调用。
  2. 是否显式 call/apply/bind。
  3. 是否对象前缀隐式调用。
  4. 都不满足走默认绑定。

代码 / 示例

new  >  bind/call/apply  >  obj.fn()  >  独立调用默认绑定
箭头函数:词法继承,不参与上述比较

常见误区

  • 误区:隐式绑定可以覆盖 bind;正解:显式绑定优先级更高。
  • 误区:箭头函数 this 可被 new 改变;正解:箭头函数无 this,继承外层。

追问

  • Q:bind 后再 new 会怎样? A:new 优先级更高,实例作为 this,bind 绑定被 new 覆盖(规范行为,以引擎实现为准)。
  • Q:判断 this 的实战步骤? A:先看是否箭头函数,再按 new → 显式 → 隐式 → 默认排查。

03.2.1.4-008 箭头函数的 this 如何确定?

一句话结论

箭头函数没有自己的 this,其 this 捕获定义时外层词法作用域的 this;函数体内 this 不可被 call/apply/bind 改变。

概念解释

  • 词法捕获:定义位置外层 this。
  • 箭头函数 this 随外层上下文。
  • 适合作为回调保持 this。

原理流程

  1. 箭头函数定义时记录外层 this。
  2. 调用时使用捕获的 this。
  3. 显式绑定无效。

代码 / 示例

const obj = {
  name: "Ann",
  timer() {
    setTimeout(() => {
      console.log(this.name); // this 捕获 timer 的 this = obj
    }, 100);
  }
};
obj.timer(); // "Ann"

常见误区

  • 误区:箭头函数 this 由调用方式决定;正解:定义时词法固定。
  • 误区:箭头函数适合作为对象方法;正解:对象方法需要自己的 this,箭头会继承外层,不适合。

追问

  • Q:顶层箭头函数 this 是什么? A:捕获外层全局/模块 this,浏览器脚本顶层为全局对象,模块为 undefined。
  • Q:箭头函数 this 可以改吗? A:call/apply/bind 传入的 thisArg 被忽略。

03.2.1.4-009 箭头函数有哪些限制?

一句话结论

箭头函数没有自己的 this、没有 arguments、没有 prototype,不能作为构造函数/new 调用,也不能生成 generator;适合短回调,不适合构造与方法定义。

概念解释

  • 无 arguments 对象,用剩余参数替代。
  • 无 prototype 属性。
  • 不能 new,抛 TypeError。

原理流程

  1. 箭头函数设计为词法 this 的轻量函数。
  2. 省略 this/arguments/prototype 机制。
  3. 受限场景改用普通函数或类方法。

代码 / 示例

const sum = (a, b) => a + b;
// new sum();           // TypeError
// sum.prototype;       // undefined
const args = (...rest) => rest; // 用剩余参数

常见误区

  • 误区:箭头函数有 arguments 只是别名叫 rest;正解:没有 arguments 对象。
  • 误区:箭头函数可以作为构造函数封装类;正解:必须用普通函数或 class。

追问

  • Q:箭头函数能作为事件监听器吗? A:可以,但监听器 this 不会自动指向元素,需要用 event.currentTarget。
  • Q:方法定义推荐箭头还是普通? A:对象/类方法需要 this 指向实例,用普通方法或类方法语法。

03.2.1.4-010 JavaScript 函数有哪些种类?

一句话结论

函数可分为函数声明、函数表达式(命名/匿名)、箭头函数、方法(对象/类方法)、构造函数、生成器函数、async 函数;调用方式与 this 规则按种类有所差异。

概念解释

  • 声明:提升,有函数名。
  • 表达式:赋值给变量或参数。
  • 方法:对象属性中的函数。
  • 生成器:function*,async:async function。

原理流程

  1. 按语法形式归类函数种类。
  2. 确定提升、this、参数机制。
  3. 按场景选择写法。

代码 / 示例

function decl() {}              // 声明
const expr = function named() {};// 表达式
const arrow = () => {};         // 箭头
const obj = { method() {} };    // 方法
function* gen() {}             // 生成器
async function fetch() {}       // async

常见误区

  • 误区:函数种类只影响写法不影响行为;正解:提升、this、arguments、构造能力差异明显。
  • 误区:方法与普通函数调用规则不同;正解:方法 this 仍按隐式绑定规则。

追问

  • Q:类字段箭头函数是什么绑定? A:实例初始化时绑定当前实例,this 固定指向实例。
  • Q:async 函数返回值有什么特殊? A:总是返回 Promise,见 03.2.2.2。

03.2.1.4-011 arguments 对象与剩余参数有什么区别?

一句话结论

arguments 是类数组对象,包含本次调用所有实参,只在普通函数中存在;剩余参数 ...rest 是真数组,只收集剩余实参,箭头函数也支持。

概念解释

  • arguments:类数组,有 length 与索引,不是数组原型。
  • rest:数组实例,可直接用数组方法。
  • arguments 与形参存在同步绑定(非严格模式)。

原理流程

  1. 调用收集实参。
  2. 普通函数生成 arguments 类数组。
  3. rest 语法把剩余实参装入数组。

代码 / 示例

function f(a, ...rest) {
  console.log(arguments[0]); // 类数组
  console.log(rest);         // 数组
}
f(1, 2, 3);

常见误区

  • 误区:箭头函数有 arguments;正解:箭头函数捕获外层 arguments,自身没有。
  • 误区:arguments 可以直接 map/filter;正解:需先转数组(Array.from(arguments))。

追问

  • Q:严格模式 arguments 同步绑定吗? A:非严格模式 arguments 与形参同步,严格模式解绑。
  • Q:优先用哪个? A:剩余参数是数组、语义清晰,新代码优先 rest。

03.2.1.4-012 this 丢失常见发生在哪些场景?

一句话结论

方法从对象取出后作为独立调用/回调传入、嵌套函数独立调用、解构赋值方法后调用,都会丢失隐式绑定,this 退化为默认绑定或 undefined。

概念解释

  • 丢失:调用前缀对象不再存在。
  • 常见:事件回调、定时器、数组迭代回调。
  • 本质:函数引用脱离对象后独立调用。

原理流程

  1. 方法引用从对象中取出。
  2. 传递给异步/回调上下文。
  3. 调用时无对象前缀,隐式绑定失效。

代码 / 示例

const app = {
  count: 0,
  add() { this.count++; },
  start() {
    setInterval(this.add, 1000); // add 解绑,this 丢失
  }
};

常见误区

  • 误区:回调里 this 还是原对象;正解:回调由宿主独立调用,隐式绑定不延续。
  • 误区:解构出的方法 this 跟随原对象;正解:const { add } = app; add() 独立调用。

追问

  • Q:class 方法传给监听会丢失吗? A:会,类方法解绑后 this 不指向实例,需绑定或箭头字段。
  • Q:React 类组件回调 this 问题? A:构造 bind 或类字段箭头函数固定实例 this。

03.2.1.4-013 回调中保持 this 有哪些处理方式?

一句话结论

常用方式:bind 预绑定、外层保存 const self = this、箭头函数回调、类字段箭头函数;按场景选择,避免在回调中依赖隐式 this。

概念解释

  • bind:返回硬绑定新函数。
  • self 缓存:闭包引用外层 this。
  • 箭头函数:词法捕获外层 this。

原理流程

  1. 识别回调将被独立调用。
  2. 选定绑定方式固定 this。
  3. 回调执行时 this 符合预期。

代码 / 示例

class Timer {
  constructor() {
    this.count = 0;
    // 方式一:类字段箭头函数
    this.tick = () => { this.count++; };
  }
  start() {
    const self = this;
    setInterval(function () { self.count++; }, 100); // 方式二
    setInterval(this.tick.bind(this), 100);          // 方式三
  }
}

常见误区

  • 误区:bind 在每次渲染都创建新函数无副作用;正解:频繁创建影响内存与引用比较,框架中注意性能。
  • 误区:箭头函数在对象方法内也能保持 this;正解:它捕获外层,对象方法自身 this 仍需普通函数。

追问

  • Q:事件监听器 this 指向什么? A:默认指向绑定元素,需要实例 this 时用 bind/箭头,事件内用 currentTarget。
  • Q:setTimeout 回调 this 规则? A:独立调用,非严格默认全局,严格 undefined;箭头捕获外层。

03.2.1.4-014 对象方法简写与 this 有什么关系?

一句话结论

对象字面量方法简写 { m() {} } 等价于 { m: function() {} },this 仍按隐式绑定规则由调用前缀决定,简写不改变 this 行为。

概念解释

  • 简写是语法糖,函数属性不变。
  • 方法内 this 取调用对象。
  • 与 getter/setter 不同。

原理流程

  1. 字面量解析方法简写。
  2. 函数挂到对象属性。
  3. 调用时隐式绑定前缀对象。

代码 / 示例

const obj = {
  name: "Ann",
  hi() { return this.name; } // 简写
};
obj.hi(); // "Ann"

常见误区

  • 误区:简写方法 this 绑定对象字面量;正解:仍由调用前缀决定。
  • 误区:简写方法是箭头函数;正解:是普通方法,有自己的 this。

追问

  • Q:对象方法内箭头函数 this 指向? A:捕获方法 this(即调用对象)。
  • Q:计算属性方法怎么写? A:{ [key]() {} },行为同普通方法。

03.2.1.4-015 构造函数返回值规则是什么?

一句话结论

new 调用时,构造函数返回对象则该对象作为实例;返回原始值(undefined/数字/字符串等)被忽略,返回 new 出的新对象;不写 return 默认返回新对象。

概念解释

  • 对象返回覆盖:返回的对象取代新实例。
  • 原始返回忽略:新实例正常返回。
  • null 视为原始值,返回新实例。

原理流程

  1. new 创建新对象绑定 this。
  2. 执行构造函数。
  3. 判断返回值类型决定最终实例。

代码 / 示例

function A() { this.x = 1; return { y: 2 }; }
new A(); // { y: 2 },对象返回覆盖

function B() { this.x = 1; return 5; }
new B(); // B 实例,x = 1

常见误区

  • 误区:构造函数 return 任何值都覆盖;正解:只有对象返回覆盖,原始值忽略。
  • 误区:return null 返回 null;正解:null 非对象,仍返回新实例。

追问

  • Q:class 构造函数规则相同吗? A:相同,返回对象覆盖实例,原始值忽略。
  • Q:单例模式如何用构造返回实现? A:构造内返回共享实例对象。

03.2.1.4-016 call/apply/bind 手写实现要点是什么?

一句话结论

手写要点:把函数挂到指定对象上作为临时方法调用以确定 this,收集参数执行,删除临时属性并返回结果;bind 需返回包装函数并处理 new 场景。

概念解释

  • call:临时挂载调用,逐个参数。
  • apply:参数数组展开。
  • bind:返回函数,预置参数,支持 new。

原理流程

  1. 在 thisArg 上挂临时函数引用。
  2. 调用并传参。
  3. 清理临时属性,返回结果。

代码 / 示例

Function.prototype.myCall = function (ctx, ...args) {
  ctx = ctx ?? globalThis;
  const key = Symbol();
  ctx[key] = this;
  const result = ctx[key](...args);
  delete ctx[key];
  return result;
};

Function.prototype.myBind = function (ctx, ...pre) {
  const fn = this;
  return function (...args) {
    if (new.target) return new fn(...pre, ...args);
    return fn.apply(ctx, [...pre, ...args]);
  };
};

常见误区

  • 误区:bind 返回函数直接调用原函数即可;正解:需处理 new 绑定优先级与预置参数拼接。
  • 误区:临时方法名用普通字符串;正解:Symbol 避免覆盖原有属性。

追问

  • Q:thisArg 为 null/undefined 怎么办? A:默认绑定规则处理,非严格指向全局。
  • Q:手写 apply 与 call 差在哪? A:参数来源一个是数组展开,一个是逐个收集。

03.2.1.4-017 类方法解绑后 this 为什么指向丢失?

一句话结论

类方法本质是原型上的普通函数,实例只是通过原型链引用;方法单独取出后调用没有实例前缀,this 不再指向实例,严格模式下为 undefined。

概念解释

  • 类方法不在实例自身,而在 prototype 上。
  • 解绑调用 = 独立调用,走默认绑定。
  • 回调传参场景最常见。

原理流程

  1. 实例访问方法沿原型链取得函数。
  2. 函数引用被传给回调。
  3. 回调独立调用,隐式绑定失效。

代码 / 示例

class Button {
  constructor() { this.label = "ok"; }
  click() { console.log(this.label); }
}
const b = new Button();
const handler = b.click;
handler(); // 严格模式 this = undefined,报错

常见误区

  • 误区:类方法自动绑定实例;正解:类方法不自动绑定,需 bind 或箭头字段。
  • 误区:把方法赋给实例属性能解决? A:在构造/字段中绑定后,每个实例持有自己的绑定函数。

追问

  • Q:类字段箭头函数如何避免解绑问题? A:字段初始化时创建绑定当前实例的箭头函数,引用不丢失。
  • Q:框架事件监听如何处理? A:组件库通常内部绑定或要求传绑定后的处理器。

03.2.1.4-018 this 与闭包组合时如何推演结果?

一句话结论

先按调用规则确定 this,再按词法作用域确定闭包变量;箭头函数 this 走词法捕获,普通函数 this 走调用绑定,两套机制分别判断后组合。

概念解释

  • 变量:沿作用域链(闭包)查找。
  • this:按调用绑定规则确定。
  • 嵌套回调分别判断各自 this。

原理流程

  1. 区分当前函数是箭头还是普通。
  2. 普通函数按优先级确定 this。
  3. 变量引用沿闭包链解析。

代码 / 示例

const counter = {
  n: 0,
  increment() {
    const self = this;
    setTimeout(function () {
      self.n++;          // self 闭包捕获 increment 的 this
      // 这里普通函数 this 是默认绑定,不能用 this.n
    }, 100);
  }
};

常见误区

  • 误区:闭包内 this 继承外层函数 this;正解:普通函数闭包不继承 this,需 self 缓存或箭头函数。
  • 误区:箭头函数变量也继承;正解:变量本来就沿作用域链,箭头只是 this 词法化。

追问

  • Q:对象方法内箭头函数 this 是什么? A:捕获方法调用时的 this(对象实例)。
  • Q:如何检查 this 指向是否符合预期? A:在函数首行打印 this,结合调用位置与绑定规则复盘。