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 继承的核心机制。
原理流程
- 对象创建时关联原型。
- 访问属性先查自身。
- 自身缺失则沿原型链向上,终点为
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。
原理流程
- 定义函数,函数自带 prototype 对象。
- new 出实例,实例内部槽指向该 prototype。
- 两侧通过原型链关联。
代码 / 示例
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 指向新对象。
- 返回值规则:返回对象用对象,返回原始值忽略,返回新对象。
原理流程
- 创建普通空对象。
- 设置
[[Prototype]] = 构造函数.prototype。 - 以 this 调用构造函数。
- 判断返回值:对象则返回它,否则返回新对象。
代码 / 示例
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 也沿链查找。
原理流程
- 函数创建时 prototype 自带 constructor 指回函数。
- 实例沿链读取 constructor。
- 覆盖 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。
原理流程
- 在当前对象属性表查找。
- 命中返回;未命中进入原型。
- 重复直到 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 只枚举自身可枚举属性。
概念解释
- 遮蔽:自身属性优先于原型属性读取。
- 删除自身属性后,原型属性重新可见。
- 原型属性只读时,直接赋值可能在自身建遮蔽属性。
原理流程
- 读取先查自身。
- 自身有同名属性即遮蔽原型。
- 用 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。 - 缺陷:父类实例属性挂在原型上被共享;构造参数无法在继承时传递。
- 组合继承结合构造函数借用解决部分问题。
原理流程
- 子类原型链挂到父类原型/实例。
- 实例查找属性沿链到父类方法。
- 共享属性与初始化问题暴露。
代码 / 示例
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。
原理流程
- 类声明建立原型与构造关系。
- extends 链接两层原型链。
- 实例化时 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 原型不同会误判。
原理流程
- 取左值原型。
- 与右值 prototype 比较。
- 不等则上移一层,直到匹配或 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 的区别:不执行构造函数逻辑。
原理流程
- 新建空对象。
- 设置内部原型为传入对象。
- 按属性描述符定义自身属性。
代码 / 示例
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:读取内部原型。
原理流程
- 区分自身/继承、可枚举/不可枚举。
- 按方法范围收集键。
- 返回数组或原型引用。
代码 / 示例
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 构造类。
原理流程
- 工厂函数内创建对象、闭包变量、返回对象。
- 构造函数定义在 prototype 上复用方法。
- 按封装与复用需求选型。
代码 / 示例
// 工厂
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 指向调用实例。
原理流程
- 公共方法写入 prototype。
- 实例查找方法沿链命中原型。
- 多实例调用同一函数,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 输入。
原理流程
- 不可信输入含原型键。
- 递归合并把键写到原型链。
- 全局对象行为被篡改。
代码 / 示例
// 防护:跳过危险键
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 绑定优先级。
原理流程
- 方法沿原型链解析到函数。
- 调用时按隐式绑定规则确定 this。
- 方法内通过 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()。 - 静态属性:类自身键值。
- 实例不能直接访问静态成员。
原理流程
- 静态定义写入构造函数对象。
- 调用方通过类名访问。
- 子类构造函数链接父构造函数,静态成员沿链继承。
代码 / 示例
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。
原理流程
- 实例创建,
[[Prototype]]指向 Dog.prototype。 - Dog.prototype 链接 Animal.prototype。
- 查找沿链逐级上升。
代码 / 示例
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 是普通对象,其原型保持自身不变,拷贝出的属性与原对象共享嵌套对象引用。
概念解释
- 浅拷贝:一层属性值复制,嵌套对象仍是引用。
- 原型不参与拷贝。
- 合并到已有对象时会覆盖同名自身属性。
原理流程
- 遍历 source 自身可枚举键。
- 把值写入 target 自身。
- 嵌套对象引用共享。
代码 / 示例
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。