JavaScript构造函数是什么:与普通函数的区别及基本用法

作者:半夏时间:2026-11-21 19:11:19浏览:233

深入浅出讲解JavaScript构造函数的核心概念、new操作符的4步执行机制、构造函数与普通函数的关键区别,以及原型方法共享与防漏new等实用开发技巧。

JavaScript 面向对象核心 技术原理与规范 阅读时长约 8 分钟
JavaScript构造函数是什么:与普通函数的区别及基本用法
JavaScript 构造函数核心概览:以函数为蓝图模板,通过 new 操作符批量生产具备独立状态与共享特性的对象实例

在 JavaScript 中,构造函数(Constructor Function)本质上就是一个常规的 JavaScript 函数,它的专门用途是与 new 操作符配合使用,充当“对象制造蓝图”,负责快速、规范地批量初始化结构一致的实例对象。本文将直接回答构造函数的核心运行机制,逐步解析 new 操作符底层的 4 个关键步骤,深入对比构造函数与普通函数在调用指令、this 指向和返回值行为上的本质差异,并通过规范代码展示原型方法挂载、防漏 new 保护与 ES6 语法的平滑对应。

一、什么是构造函数?从批量创建对象的需求谈起

在深入底层原理前,有必要看清构造函数要解决的核心工程问题。在日常开发中,若需要表示多个同类型实体(例如用户、订单、图表节点),最直观的写法是使用对象字面量:

// 使用对象字面量创建两个用户
const user1 = { name: "张三", role: "管理员", score: 95 };
const user2 = { name: "李四", role: "普通成员", score: 80 };

当实体数量变多、逻辑变复杂时,这种写法会暴露出两个明显问题:一是属性键名与初始结构必须手工重复书写,极易漏填或拼写错误;二是这些对象在内存中彼此孤立,无法通过类型系统识别它们属于哪一类具体业务实体(user1.constructor 仅泛泛指向 Object)。

构造函数正是为解决这个问题而生的标准化模式。它允许开发者定义一个统一的模型函数,把属性初始化逻辑收敛在函数内部,随后通过 new 关键字快速“批量开炉生产”:

// 声明一个用户构造函数(遵循大驼峰命名规范 PascalCase)
function User(name, role, score) {
  this.name = name;
  this.role = role;
  this.score = score;
}

// 使用 new 调用构造函数,批量生成规范对象
const u1 = new User("张三", "管理员", 95);
const u2 = new User("李四", "普通成员", 80);

console.log(u1);
console.log(u2 instanceof User);
[示例执行输出]
User { name: '张三', role: '管理员', score: 95 }
true

此时,u1 与 u2 不仅具备统一清晰的属性结构,而且能够通过 instanceof User 准确识别出所属的类型身份。

二、new 操作符底层发生了什么:执行四步法拆解

为什么同一个函数,只要在前面加上一个简单的 new 关键字,就能凭空生成一个对象并把属性挂上去?理解构造函数的关键,正在于透视 new 在背后执行的底层机制。

JavaScript构造函数是什么:与普通函数的区别及基本用法
图 1:JavaScript 引擎执行 new Constructor() 时的四步底层流转

当引擎执行 new Func(...args) 时,底层严格按顺序执行以下四个动作:

  1. 步骤 1:在内存堆中开辟新对象
    引擎首先创建一个全新的、没有任何自有属性的纯净普通对象(类似于 const obj = {})。
  2. 步骤 2:建立原型链关联
    将这个新对象的内部隐藏属性 [[Prototype]](浏览器中通常体现为 __proto__)直接指向构造函数的 prototype 属性对象。这一步奠定了实例能使用构造函数原型上共享方法的基础,也是 instanceof 校验成功的核心纽带。
  3. 步骤 3:绑定 this 并执行构造函数体
    将构造函数内部的执行上下文环境 this 强制绑定到第一步创建的新对象上,接着传入参数执行函数体代码。在这一阶段,代码中写下的 this.name = name 会把属性逐一赋值到这个新对象上。
  4. 步骤 4:审查返回值并决定最终产物
    审查构造函数本身的执行返回值:如果函数体显式执行了 return 并且返回的是一个非空对象/引用类型(如 Object、Array、Function),则以显式返回的对象为准;如果函数没有写 return,或者返回的是原始基本类型(如 number、string、boolean、null、undefined),则一律忽略该返回值,最终返回第一步创建的新实例对象。

为了加深理解,可以用一段简明的 JavaScript 代码模拟写一个 myNew 函数,完全复现上述四个步骤:

// 手写模拟 new 操作符的执行逻辑
function myNew(Constructor, ...args) {
  // 步骤 1 & 步骤 2:创建新对象并建立原型链连接
  const obj = Object.create(Constructor.prototype);

  // 步骤 3:将 this 绑定到 obj,传入参数执行构造逻辑
  const result = Constructor.apply(obj, args);

  // 步骤 4:返回值裁决:若显式返回对象则采用,否则返回 obj
  const isObject = result !== null && (typeof result === "object" || typeof result === "function");
  return isObject ? result : obj;
}

// 验证自定义 myNew 的表现
const userCustom = myNew(User, "王五", "测试员", 88);
console.log(userCustom.name); // 成功获取属性
console.log(userCustom instanceof User); // 确认原型关系成立
[示例执行输出]
王五
true

三、构造函数与普通函数的四大核心区别

许多初学者常会产生一个误区:“构造函数是不是 JavaScript 语法里一种专门定义的新函数类型?”

认知辨析:构造函数与普通函数的语法本质

澄清:在 ECMAScript 规范层面,常规的 function 声明并没有“普通函数”与“构造函数”的两套语法分类。绝大多数使用 function 关键字声明的函数内部同时具备两套内部调用槽:一个是供常规调用的 [[Call]],另一个是供实例化调用的 [[Construct]]。

也就是说,同一个函数,直接调用时它就表现为普通函数;在前面加上 new 时它就进入构造函数模式。二者的分水岭不在于“如何声明”,而在于“如何被调用”以及“引擎在调用时触发的分支机制”。

JavaScript构造函数是什么:与普通函数的区别及基本用法
图 2:普通函数调用与构造函数调用的核心行为与机制对比

具体到代码行为,二者在以下 4 个关键维度存在本质区别:

对比维度 普通函数调用(如 fn()) 构造函数实例化(如 new Fn())
底层触发方法 触发内部方法 [[Call]] 触发内部方法 [[Construct]]
内部 this 绑定 非严格模式指向全局(window/global);严格模式为 undefined 严格且确定地指向本次新创建的实例对象
默认返回值 若无显式 return,返回 undefined 即使不写 return,也默认返回新创建的实例对象
显式 return 基本类型 如实返回该基本类型(如数字、字符串) 静默忽略该基本类型,依然返回构造的新实例
命名规范约定 通常以动词开头的小驼峰(camelCase),如 getUserInfo() 通常以名词开头的大驼峰(PascalCase),如 User()
箭头函数支持度 完全支持,常用于回调或需要保留外部上下文场景 不支持;箭头函数缺少 [[Construct]] 与 prototype

1. this 指向的差异代码演示

在普通函数直接调用时,this 默认依附于执行上下文的调用发起者;而在构造函数中,this 始终被约束为新生成的实体:

function Account(id) {
  this.id = id;
}

// 场景 A:作为普通函数直接调用(错误用法)
// 非严格模式下,this 指向全局 window/global,导致在全局挂上了 window.id
const res1 = Account(101);
console.log(res1); // undefined(普通函数没有写 return)

// 场景 B:作为构造函数使用 new 调用(正确用法)
const res2 = new Account(102);
console.log(res2); // Account { id: 102 }
[示例执行输出]
undefined
Account { id: 102 }

2. 返回值处理规则的差异演示

构造函数的返回值逻辑是许多开发者容易混淆的地方:

// 案例 1:在构造函数中显式返回基础类型(如数字 123)
function ProductA(name) {
  this.name = name;
  return 123; // 返回原始值
}
const pa = new ProductA("笔记本");
console.log(pa); // 原始值 123 被丢弃,依然得到实例 ProductA { name: '笔记本' }

// 案例 2:在构造函数中显式返回对象类型
function ProductB(name) {
  this.name = name;
  return { customTag: "被覆盖的对象" }; // 返回引用对象
}
const pb = new ProductB("手机");
console.log(pb); // 构造生成的实例被彻底丢弃,得到返回的对象 { customTag: '被覆盖的对象' }
[示例执行输出]
ProductA { name: '笔记本' }
{ customTag: '被覆盖的对象' }

规范建议:除非在实现单例模式或特定工厂缓存,否则切勿在构造函数中编写任何带值的 return 语句,让引擎天然完成实例交付即可。

3. 为什么箭头函数不能充当构造函数?

若尝试对箭头函数使用 new 操作符,引擎会直接抛出运行异常:

const ArrowBox = (val) => {
  this.val = val;
};

new ArrowBox(10); // 抛出 TypeError: ArrowBox is not a constructor

这是因为在语言规范中,箭头函数设计初衷是轻量级的函数表达式,它既没有自身的 this 绑定逻辑,内部也没有 [[Construct]] 槽,更没有 prototype 原型属性,因此彻底被剥夺了作为构造函数实例化的资格。

四、构造函数的基本用法与规范实践

掌握了区别与原理之后,在实际编写 JavaScript 构造函数时,应当遵循以下三项行业通用最佳实践:

1. 属性放在函数体内,方法务必挂载在原型(prototype)上

很多初学者习惯在构造函数体内直接使用 this.method = function() {} 定义方法。这种写法在语法上完全能跑通,但在内存工程上是一个严重的性能陷阱:

// 不推荐的写法:在函数体内挂载方法
function BadUser(name) {
  this.name = name;
  this.sayHello = function() {
    console.log("你好,我是 " + this.name);
  };
}

const uA = new BadUser("小明");
const uB = new BadUser("小华");
console.log(uA.sayHello === uB.sayHello); // false!二者各自在内存中创建了一份一模一样的函数

如果系统中创建了 10,000 个 BadUser 实例,内存中就会重复开辟 10,000 个一模一样的 sayHello 函数闭包。

JavaScript构造函数是什么:与普通函数的区别及基本用法
图 3:构造函数、原型对象与实例对象之间的指针关系与方法共享机制

规范做法:将公共方法挂载到构造函数的 prototype 对象上。此时所有由该构造函数创建出来的实例,通过隐式原型链 __proto__ 最终都指向同一份原型方法,在内存中仅占用一份空间:

// 规范实践:状态独享,行为共享
function GoodUser(name, role) {
  // 独享属性放在构造函数体内
  this.name = name;
  this.role = role;
}

// 共享行为挂载在 prototype 上
GoodUser.prototype.sayHello = function() {
  console.log("你好,我是 " + this.name + ",角色为 " + this.role);
};

const gA = new GoodUser("小明", "开发工程师");
const gB = new GoodUser("小华", "产品经理");

console.log(gA.sayHello === gB.sayHello); // true!共享同一个原型函数指针
gA.sayHello();
gB.sayHello();
[示例执行输出]
true
你好,我是 小明,角色为 开发工程师
你好,我是 小华,角色为 产品经理

2. 建立防漏 new 的安全防护机制

如果使用者忘记写 new,直接调用了 GoodUser('张三', '开发'),代码不仅拿不到实例,还会导致 this.name 污染全局变量。为了增加代码健壮性,可以在构造函数内部增加防御检查:

function SafeUser(name) {
  // 现代方案:使用 ES6 引入的 new.target 元属性
  if (!new.target) {
    // 用户漏写了 new,在此自动帮其以 new 方式补全
    return new SafeUser(name);
  }

  this.name = name;
}

// 测试:无论带不带 new,都能安全获得合法实例
const safe1 = SafeUser("直接调用的实例");
const safe2 = new SafeUser("带 new 的实例");

console.log(safe1 instanceof SafeUser);
console.log(safe2 instanceof SafeUser);
[示例执行输出]
true
true

3. 构造函数与现代 ES6 Class 的映射关系

在现代前端开发中,虽然更常使用 ES6 的 class 关键字,但必须明确:JavaScript 的 class 本质上依然是构造函数与原型链的语法糖。二者有着严格的一一对应关系:

// ES6 Class 语法
class Employee {
  constructor(name) {
    this.name = name; // 相当于在传统构造函数体内赋值 this
  }

  work() {
    console.log(this.name + " 正在处理工作..."); // 相当于挂载在 Employee.prototype.work
  }
}

console.log(typeof Employee); // "function"
console.log(Employee.prototype.work); // 依然作为原型函数存在

与传统构造函数的唯一关键区别在于:ES6 的 class 在引擎规范中被强制设定了只能通过 new 调用,若直接像普通函数执行 Employee('张三'),会直接报错 TypeError: Class constructor Employee cannot be invoked without 'new',这正是语言规范在语法层面强制落地最佳实践的体现。

五、核心总结与知识全景速查

理解 JavaScript 构造函数的全貌,有助于透彻掌握原型链继承、this 指向判定以及面向对象架构设计的底层根基。

JavaScript构造函数是什么:与普通函数的区别及基本用法
图 4:JavaScript 构造函数核心知识全景与日常开发规范决策卡片

在日常开发与面试考查中,可将核心要点精简总结为以下三句话:

  • 是什么:构造函数是配合 new 操作符专门用于创建和初始化对象实例的函数模板。
  • 核心区别:普通调用触发 [[Call]],this 绑定由调用发起方决定;构造调用触发 [[Construct]],强制生成新空对象作为 this,挂接原型链并默认产出新实例。
  • 规范做法:坚持 PascalCase 大驼峰命名;独有属性写进函数体,公共方法挂载至 prototype 原型;必要时配合 new.target 进行调用防护。
作者最新文章
相关文章
更多