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

03.2.1.2 原型链与对象模型

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

03.2.1.2-001 对象的 [[Prototype]] 内部槽是什么?

一句话结论

每个普通对象都有一个内部槽 [[Prototype]],指向其原型对象;属性查找时若自身没有,就沿 [[Prototype]] 链向上查找,直到 null。

概念解释

  • [[Prototype]] 是引擎内部槽,不可直接访问。
  • 读取用 Object.getPrototypeOf(obj),写入/读取旧写法 obj.__proto__。
  • 原型链是 JS 继承的核心机制。

原理流程

  1. 对象创建时关联原型。
  2. 访问属性先查自身。
  3. 自身缺失则沿原型链向上,终点为 Object.prototype 再上 null。

代码 / 示例

const obj = {};
Object.getPrototypeOf(obj) === Object.prototype; // true
obj.__proto__ === Object.prototype;              // true(旧访问器)

常见误区

  • 误区:__proto__ 是规范推荐 API;正解:推荐 Object.getPrototypeOf/Object.setPrototypeOf,__proto__ 是历史访问器。
  • 误区:函数才有原型;正解:每个对象都有 [[Prototype]],函数额外有 prototype 属性。

追问

  • Q:原型链终点是什么? A:Object.prototype 的 [[Prototype]] 为 null。
  • Q:修改原型会影响已有实例吗? A:会,实例沿链查找时读到最新原型属性。

03.2.1.2-002 prototype 与 __proto__ 有什么区别?

一句话结论

prototype 是函数对象的属性,用于确定构造出的实例的原型;__proto__([[Prototype]])是每个对象指向自身原型的访问器,二者分属函数与对象两侧。

概念解释

  • 函数 Foo.prototype:构造实例时实例 [[Prototype]] 指向它。
  • 实例 __proto__:指向 Foo.prototype。
  • 关系:实例.__proto__ === 构造函数.prototype。

原理流程

  1. 定义函数,函数自带 prototype 对象。
  2. new 出实例,实例内部槽指向该 prototype。
  3. 两侧通过原型链关联。

代码 / 示例

function Foo() {}
const f = new Foo();
f.__proto__ === Foo.prototype;          // true
Foo.prototype.constructor === Foo;      // true

常见误区

  • 误区:所有对象都有 prototype;正解:prototype 是函数属性,普通对象只有 [[Prototype]]。
  • 误区:改 __proto__ 会改函数 prototype;正解:它是实例侧引用,设置它改变实例原型链。

追问

  • Q:箭头函数有 prototype 吗? A:没有,不能作为构造函数。
  • Q:Object.create(Foo.prototype) 得到什么? A:一个原型指向 Foo.prototype 的普通对象,未执行构造函数。

03.2.1.2-003 new 操作符执行了哪几步?

一句话结论

new 创建空对象、把对象 [[Prototype]] 指向构造函数 prototype、绑定 this 执行构造函数、若构造函数返回对象则返回该对象,否则返回新对象。

概念解释

  • 新建对象关联原型。
  • 构造函数内 this 指向新对象。
  • 返回值规则:返回对象用对象,返回原始值忽略,返回新对象。

原理流程

  1. 创建普通空对象。
  2. 设置 [[Prototype]] = 构造函数.prototype。
  3. 以 this 调用构造函数。
  4. 判断返回值:对象则返回它,否则返回新对象。

代码 / 示例

function myNew(Ctor, ...args) {
  const obj = Object.create(Ctor.prototype);
  const ret = Ctor.apply(obj, args);
  return ret !== null && typeof ret === 'object' ? ret : obj;
}

常见误区

  • 误区:构造函数必须返回 this;正解:返回对象会覆盖新对象,返回原始值不影响新对象。
  • 误区:new 给对象加了 prototype 属性;正解:是函数 prototype 被实例引用。

追问

  • Q:构造函数返回字符串会怎样? A:原始返回值被忽略,仍返回 new 出的对象。
  • Q:class 构造函数可以 return 对象吗? A:可以,规则与普通构造函数一致。

03.2.1.2-004 constructor 属性指向谁?

一句话结论

prototype.constructor 默认指向构造函数本身;实例通过原型链访问到 constructor,因此 实例.constructor === 构造函数;手动替换 prototype 对象后需补回 constructor 引用。

概念解释

  • constructor 是 prototype 对象上的普通属性。
  • 重写 Foo.prototype = { ... } 会丢失默认 constructor。
  • 继承链上 constructor 也沿链查找。

原理流程

  1. 函数创建时 prototype 自带 constructor 指回函数。
  2. 实例沿链读取 constructor。
  3. 覆盖 prototype 后需显式设置 constructor。

代码 / 示例

function Person(name) { this.name = name; }
const p = new Person("Ann");
p.constructor === Person; // true

Person.prototype = {
  greet() {},
  constructor: Person     // 补回引用
};

常见误区

  • 误区:constructor 存在实例自身;正解:它在原型上,实例通过链访问。
  • 误区:constructor 可以可靠判断类型;正解:可被覆盖,跨 realm 也不可靠,类型判断需结合其他手段。

追问

  • Q:为什么要补 constructor? A:依赖 instance.constructor 做实例化或类型判断的代码才能正常工作。
  • Q:class 语法自动维护 constructor 吗? A:类原型方法挂在类 prototype 上,constructor 引用由类定义维护。

03.2.1.2-005 属性在原型链上如何查找?终点是什么?

一句话结论

访问属性时先查对象自身,没有则依次查 [[Prototype]] 链;找到即返回,查到 null 仍未找到返回 undefined;查找过程不修改任何对象。

概念解释

  • 自身属性优先于原型属性(属性遮蔽)。
  • 读取沿链向上,写入默认写在自身。
  • 终点:Object.prototype → null。

原理流程

  1. 在当前对象属性表查找。
  2. 命中返回;未命中进入原型。
  3. 重复直到 null,未找到返回 undefined。

代码 / 示例

f ──[[Prototype]]──> Foo.prototype ──> Object.prototype ──> null
自身属性            greet()            toString()

常见误区

  • 误区:原型上找不到属性会报错;正解:返回 undefined,不抛错。
  • 误区:读取属性会把原型属性复制到自身;正解:读取不复制,写入才在自身建属性。

追问

  • Q:in 与 hasOwnProperty 区别? A:in 沿链判断,hasOwnProperty 只看自身。
  • Q:原型链上的方法被多个实例共享吗? A:方法定义在原型上,所有实例共用同一份函数。

03.2.1.2-006 什么是属性遮蔽?如何区分自身属性与继承属性?

一句话结论

实例自身定义同名属性会遮蔽原型链上的同名属性;hasOwnProperty 判断自身属性,in 包含继承属性,Object.keys 只枚举自身可枚举属性。

概念解释

  • 遮蔽:自身属性优先于原型属性读取。
  • 删除自身属性后,原型属性重新可见。
  • 原型属性只读时,直接赋值可能在自身建遮蔽属性。

原理流程

  1. 读取先查自身。
  2. 自身有同名属性即遮蔽原型。
  3. 用 hasOwnProperty 区分来源。

代码 / 示例

const obj = { a: 1 };
const child = Object.create(obj);
child.b = 2;
child.hasOwnProperty("a"); // false
child.hasOwnProperty("b"); // true
"a" in child;              // true(继承)

常见误区

  • 误区:修改原型属性会改实例;正解:赋值默认写在实例自身,形成遮蔽而非改原型。
  • 误区:for...in 只遍历自身;正解:它遍历自身与继承的可枚举属性。

追问

  • Q:如何遍历自身可枚举键? A:Object.keys 或 Object.entries;Object.getOwnPropertyNames 含不可枚举键。
  • Q:遮蔽后如何恢复原型值? A:delete child.a 删除自身遮蔽属性。

03.2.1.2-007 原型链继承怎么实现?有什么缺陷?

一句话结论

让子类原型的 [[Prototype]] 指向父类实例,即可沿链继承父类方法;纯原型链继承的缺陷是父类引用属性被所有实例共享、无法传参初始化、子类原型构造函数丢失。

概念解释

  • 原型链:Sub.prototype.__proto__ = Super.prototype。
  • 缺陷:父类实例属性挂在原型上被共享;构造参数无法在继承时传递。
  • 组合继承结合构造函数借用解决部分问题。

原理流程

  1. 子类原型链挂到父类原型/实例。
  2. 实例查找属性沿链到父类方法。
  3. 共享属性与初始化问题暴露。

代码 / 示例

function Animal(name) { this.name = name; this.legs = 4; }
Animal.prototype.speak = function () {};

function Dog(name) { Animal.call(this, name); } // 借用构造传参
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

常见误区

  • 误区:把父类实例直接赋给子类原型就能传参;正解:实例上的引用属性被共享,需在子类构造中调用父构造初始化。
  • 误区:原型链继承自动维护 constructor;正解:替换原型后需手动补回。

追问

  • Q:组合继承解决了什么? A:构造函数借用保证各实例有独立父类属性,原型链继承方法复用。
  • Q:class extends 底层做了什么? A:子类原型与实例原型都链接到父类,super 调用父构造/方法,见 03.2.1.2-008。

03.2.1.2-008 class extends 的本质是什么?

一句话结论

class extends 是原型链继承的语法糖:子类构造函数原型与实例原型都链接到父类,super 分别调用父类构造与父类方法;本质仍是原型链 + 构造调用。

概念解释

  • 类方法挂在类 prototype 上。
  • 继承:Sub.__proto__ === Super,Sub.prototype.__proto__ === Super.prototype。
  • 子类构造必须先 super() 才能绑定 this。

原理流程

  1. 类声明建立原型与构造关系。
  2. extends 链接两层原型链。
  3. 实例化时 super 初始化父类部分。

代码 / 示例

class Animal {
  constructor(name) { this.name = name; }
  speak() { return `${this.name}`; }
}
class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }
}

常见误区

  • 误区:class 是面向对象的全新模型;正解:底层仍是原型链机制,语法糖封装了链接与调用细节。
  • 误区:子类方法会复制父类方法;正解:方法沿原型链共享,不复制。

追问

  • Q:super 在构造与方法中分别指向什么? A:构造中 super 是父类构造函数;方法中 super 指向父类原型对象。
  • Q:静态成员会继承吗? A:会,子类构造函数自身链接父类构造函数,静态方法沿构造链继承。

03.2.1.2-009 instanceof 的判定过程是什么?

一句话结论

instanceof 从左值的 [[Prototype]] 链开始向上遍历,遇到右值构造函数的 prototype 即返回 true,链到 null 返回 false。

概念解释

  • 右值必须是可调用构造函数。
  • 原始值返回 false。
  • 跨 realm 原型不同会误判。

原理流程

  1. 取左值原型。
  2. 与右值 prototype 比较。
  3. 不等则上移一层,直到匹配或 null。

代码 / 示例

function myInstanceof(obj, Ctor) {
  let proto = Object.getPrototypeOf(obj);
  while (proto) {
    if (proto === Ctor.prototype) return true;
    proto = Object.getPrototypeOf(proto);
  }
  return false;
}

常见误区

  • 误区:instanceof 检查构造函数是否被调用过;正解:只检查原型链包含关系。
  • 误区:instanceof 能判断原始类型;正解:原始值无原型链,返回 false。

追问

  • Q:继承场景 instanceof 成立吗? A:成立,父类 prototype 在子类实例链上。
  • Q:跨 iframe 为什么失效? A:两个全局环境的 Array.prototype 不是同一引用。

03.2.1.2-010 Object.create 如何设置原型?

一句话结论

Object.create(proto) 创建一个 [[Prototype]] 为指定对象的新对象,第二个参数可添加自身属性描述符;它不调用任何构造函数。

概念解释

  • 传入 null 创建无原型对象。
  • 常用于规范设置子类原型、创建纯原型对象。
  • 与 new 的区别:不执行构造函数逻辑。

原理流程

  1. 新建空对象。
  2. 设置内部原型为传入对象。
  3. 按属性描述符定义自身属性。

代码 / 示例

const parent = { greet() { return "hi"; } };
const child = Object.create(parent, {
  name: { value: "Ann", enumerable: true }
});
child.greet(); // "hi"

常见误区

  • 误区:Object.create 会调用父构造函数;正解:只设置原型,初始化需手动调用父构造。
  • 误区:第二个参数是普通对象字面量;正解:是属性描述符对象,键对应描述符。

追问

  • Q:Object.create(null) 有什么用? A:创建无原型字典对象,避免原型键干扰,适合做哈希映射。
  • Q:如何修改已有对象原型? A:Object.setPrototypeOf(obj, proto),性能上建议创建时指定。

03.2.1.2-011 常用对象反射方法有哪些?

一句话结论

Object.keys/values/entries 枚举自身可枚举属性;Object.getOwnPropertyNames 含不可枚举;Object.getPrototypeOf 取原型;Object.assign 浅拷贝自身可枚举属性。

概念解释

  • keys:自身可枚举键数组。
  • getOwnPropertyNames:自身全部键(含不可枚举)。
  • getPrototypeOf:读取内部原型。

原理流程

  1. 区分自身/继承、可枚举/不可枚举。
  2. 按方法范围收集键。
  3. 返回数组或原型引用。

代码 / 示例

const obj = { a: 1, b: 2 };
Object.keys(obj);              // ["a","b"]
Object.values(obj);            // [1,2]
Object.entries(obj);           // [["a",1],["b",2]]
Object.getPrototypeOf(obj);    // Object.prototype

常见误区

  • 误区:keys 包含继承属性;正解:只列自身可枚举。
  • 误区:getOwnPropertyNames 只列可枚举;正解:含不可枚举键,不含 Symbol 键。

追问

  • Q:Symbol 键怎么取? A:Object.getOwnPropertySymbols(obj)。
  • Q:Reflect.ownKeys 包含哪些? A:自身所有键,含字符串、Symbol、不可枚举。

03.2.1.2-012 工厂函数与构造函数有什么区别?

一句话结论

工厂函数普通返回对象,不依赖 new;构造函数通过 new 初始化实例,原型链自动关联;工厂函数更灵活,构造函数配合原型实现方法复用。

概念解释

  • 工厂:内部创建对象并 return,方法可闭包私有。
  • 构造:new 绑定 this,原型挂公共方法。
  • 二者可组合:工厂内部 new 构造类。

原理流程

  1. 工厂函数内创建对象、闭包变量、返回对象。
  2. 构造函数定义在 prototype 上复用方法。
  3. 按封装与复用需求选型。

代码 / 示例

// 工厂
function makeCounter() {
  let n = 0;
  return { inc: () => ++n };
}
// 构造
function Counter() { this.n = 0; }
Counter.prototype.inc = function () { return ++this.n; };

常见误区

  • 误区:工厂函数不能共享方法;正解:可把方法挂到共享原型对象上。
  • 误区:构造函数必须大写命名;正解:大写是约定,不是语法强制。

追问

  • Q:私有变量用哪种方式天然支持? A:工厂闭包,外部无法直接访问闭包变量。
  • Q:class 与工厂如何选? A:需要原型复用、继承体系用 class;轻量封装、闭包私有用工厂。

03.2.1.2-013 原型上的方法如何被实例共享?

一句话结论

方法定义在构造函数 prototype 上,所有实例的 [[Prototype]] 指向同一 prototype,因此共用同一份函数对象,不在每个实例上复制。

概念解释

  • 实例自身只存状态属性。
  • 行为方法挂原型,节省内存。
  • 方法内 this 指向调用实例。

原理流程

  1. 公共方法写入 prototype。
  2. 实例查找方法沿链命中原型。
  3. 多实例调用同一函数,this 各自绑定。

代码 / 示例

function User(name) { this.name = name; }
User.prototype.say = function () { return this.name; };
const u1 = new User("A"), u2 = new User("B");
u1.say === u2.say; // true,共享同一函数

常见误区

  • 误区:在构造函数内定义方法能复用;正解:每个实例新建一份函数,内存随实例增长。
  • 误区:原型方法复制到每个实例;正解:只共享引用。

追问

  • Q:原型方法修改共享变量要注意什么? A:方法内不要挂可变状态到原型,避免实例间互相影响。
  • Q:class 实例方法定义在哪? A:类 prototype 上,实例共享。

03.2.1.2-014 什么是原型污染?如何防护?

一句话结论

原型污染指通过递归合并/深拷贝用户输入,把 __proto__、prototype 等键写入 Object.prototype,污染全局对象行为;防护是过滤危险键、使用无原型对象、避免不可信深合并。

概念解释

  • 攻击键:__proto__、constructor.prototype。
  • 污染后所有对象继承被注入属性。
  • 常见于 merge、defaults 类工具与 JSON 输入。

原理流程

  1. 不可信输入含原型键。
  2. 递归合并把键写到原型链。
  3. 全局对象行为被篡改。

代码 / 示例

// 防护:跳过危险键
function safeMerge(target, source) {
  for (const key of Object.keys(source)) {
    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
    target[key] = source[key];
  }
  return target;
}
// 字典用无原型对象
const dict = Object.create(null);

常见误区

  • 误区:JSON.parse 会自动污染原型;正解:parse 只生成普通对象,污染发生在后续合并/赋值逻辑。
  • 误区:深拷贝工具天然免疫;正解:递归赋值同样可能写入原型键。

追问

  • Q:如何检测原型被污染? A:检查 Object.prototype 上是否出现意外键。
  • Q:框架/SDK 如何处理? A:合并工具内置危险键过滤,关键映射用 Object.create(null)。

03.2.1.2-015 原型方法中的 this 指向谁?

一句话结论

原型方法被实例调用时,this 指向调用该方法的实例对象;方法定义在原型上不改变 this 绑定规则,仍按调用方式确定。

概念解释

  • 方法调用:instance.method(),this 为 instance。
  • 解构后单独调用会丢失 this,需 bind 或箭头函数。
  • 原型链不影响 this 绑定优先级。

原理流程

  1. 方法沿原型链解析到函数。
  2. 调用时按隐式绑定规则确定 this。
  3. 方法内通过 this 访问实例状态。

代码 / 示例

User.prototype.say = function () { return this.name; };
const u = new User("Ann");
u.say();              // this = u
const fn = u.say;
fn();                 // this 丢失(严格模式 undefined)

常见误区

  • 误区:原型方法的 this 指向 prototype;正解:this 由调用方决定,通常是实例。
  • 误区:把原型方法赋值给变量后 this 仍指向实例;正解:解绑后需显式绑定。

追问

  • Q:类字段箭头函数如何绑定 this? A:实例字段初始化时绑定当前实例,适合作为回调传递。
  • Q:原型方法中 this 为 undefined 的场景? A:严格模式下独立调用、回调解绑、未绑定传参。

03.2.1.2-016 静态属性与静态方法挂在哪里?

一句话结论

静态成员直接挂在类/构造函数自身(不挂 prototype),通过类名调用;子类通过构造函数链继承父类静态成员。

概念解释

  • 静态方法:Class.staticMethod()。
  • 静态属性:类自身键值。
  • 实例不能直接访问静态成员。

原理流程

  1. 静态定义写入构造函数对象。
  2. 调用方通过类名访问。
  3. 子类构造函数链接父构造函数,静态成员沿链继承。

代码 / 示例

class Registry {
  static count = 0;
  static increment() { this.count++; }
}
Registry.increment();
Registry.count; // 1

常见误区

  • 误区:静态方法能通过实例调用;正解:实例链上没有静态成员,需类名调用。
  • 误区:静态属性挂在 prototype 上;正解:挂在构造函数自身。

追问

  • Q:静态成员继承如何实现? A:Sub.__proto__ === Super,子类构造函数可沿链访问父类静态成员。
  • Q:静态方法中的 this 指向? A:指向调用它的类/构造函数对象。

03.2.1.2-017 画出一条典型继承链并说明属性查找

一句话结论

以 class Dog extends Animal 为例:实例 → Dog.prototype → Animal.prototype → Object.prototype → null;实例自身属性先命中,方法沿链向上解析。

概念解释

  • 两层原型:实例原型链与构造函数链。
  • 实例方法在 Dog.prototype,继承方法在 Animal.prototype。
  • 终点 null。

原理流程

  1. 实例创建,[[Prototype]] 指向 Dog.prototype。
  2. Dog.prototype 链接 Animal.prototype。
  3. 查找沿链逐级上升。

代码 / 示例

dog ──> Dog.prototype ──> Animal.prototype ──> Object.prototype ──> null
自身属性  bark()           speak()              toString()

常见误区

  • 误区:实例直接链接父类 prototype;正解:先经子类 prototype 再到父类 prototype。
  • 误区:链上找不到属性会复制原型值;正解:读取只查找不复制。

追问

  • Q:覆盖父类方法怎么写? A:子类原型定义同名方法遮蔽父类,super 可调用父版本。
  • Q:如何判断方法来自哪一层? A:沿 Object.getPrototypeOf 逐层检查方法归属。

03.2.1.2-018 Object.assign 拷贝时原型会保持吗?

一句话结论

Object.assign(target, source) 只复制 source 自身可枚举属性到 target,不复制原型;若 target 是普通对象,其原型保持自身不变,拷贝出的属性与原对象共享嵌套对象引用。

概念解释

  • 浅拷贝:一层属性值复制,嵌套对象仍是引用。
  • 原型不参与拷贝。
  • 合并到已有对象时会覆盖同名自身属性。

原理流程

  1. 遍历 source 自身可枚举键。
  2. 把值写入 target 自身。
  3. 嵌套对象引用共享。

代码 / 示例

const src = { a: 1, nested: { x: 2 } };
const copy = Object.assign({}, src);
copy.a = 9;
src.a;            // 1,一层独立
copy.nested.x = 99;
src.nested.x;     // 99,嵌套共享

常见误区

  • 误区:assign 是深拷贝;正解:只浅拷贝一层。
  • 误区:assign 复制原型方法;正解:继承属性不复制。

追问

  • Q:展开运算符 {...src} 与 assign 区别? A:都是浅拷贝自身可枚举属性,行为基本一致。
  • Q:如何保持拷贝对象原型? A:Object.create(proto) 后再 assign,或深拷贝时按原型重建,见 03.2.1.5。