深入理解JavaScript中变量声明var、let和const的区别
作者:李少兄
在 JavaScript 的日常开发中,变量声明是使用频率最高的语法之一。然而,var、let、const 之间的差异远不止"能不能重新赋值"这么简单——它们背后牵扯到作用域模型、执行上下文、变量提升、暂时性死区等一系列语言核心机制。很多线上 Bug、面试题陷阱、代码规范争议,根源都在于对这些声明机制的理解不够深入。
一、为什么需要 let 和 const:var 的设计缺陷
要理解 let 和 const 存在的意义,必须先搞清楚 var 到底有什么问题。JavaScript 诞生于 1995 年,Brendan Eich 用十天写出这门语言时,变量声明的设计参考了早期脚本语言的宽松风格,这埋下了几个长期困扰开发者的隐患。
1.1 没有块级作用域,只有函数作用域
var 声明的变量,其有效范围是最近的函数作用域(如果在函数外声明则是全局作用域)。if、for、while、switch、try...catch 这些用花括号包裹的代码块,不会为 var 创建新的作用域。
function demo() {
if (true) {
var x = 10; // 看起来像在 if 块内,实际提升到了函数顶部
}
console.log(x); // 10 —— x 泄漏到了 if 之外
}
这在直觉上非常反常。绝大多数 C 系语言(C、C++、Java、C#、PHP)的代码块都会创建作用域,而 var 不会。更麻烦的是,循环变量同样遵循这一规则:
for (var i = 0; i < 5; i++) {
setTimeout(function () {
console.log(i);
}, i * 100);
}
// 输出:5 5 5 5 5
这段代码是 JavaScript 面试史上被问得最多的问题之一。原因是:整个循环共享同一个 i 变量,当五个回调在事件循环中依次执行时,循环早已结束,i 已经是终止值 5。五个闭包捕获的是同一个变量绑定,自然打印出相同的值。
ES5 时代的标准解法是用立即执行函数表达式(IIFE)为每次迭代手动创建作用域:
for (var i = 0; i < 5; i++) {
(function (j) { // 每轮迭代把 i 的当前值复制给形参 j
setTimeout(function () {
console.log(j);
}, j * 100);
})(i);
}
// 输出:0 1 2 3 4
这种写法能工作,但显然丑陋且低效。let 的出现正是为了从语言层面解决这个问题:
for (let i = 0; i < 5; i++) {
setTimeout(function () {
console.log(i);
}, i * 100);
}
// 输出:0 1 2 3 4
这里有一个容易被忽略的细节:for (let ...) 循环的每一轮迭代都会创建一个全新的绑定。规范规定,循环变量在每次迭代开始时被重新初始化,并将上一轮的值复制过来。所以每个 setTimeout 回调捕获的是各自迭代中独立的 i,互不干扰。这个"每轮一个新绑定"的语义是专门为 let 设计的,var 不具备。
1.2 变量提升与 undefined 初始化
var 声明会被提升(Hoisting)到所在作用域的顶部。需要精确理解的是:引擎在编译阶段就把声明本身处理掉了,但赋值语句留在原地。以下代码:
function demo() {
console.log(a); // undefined
var a = 1;
console.log(a); // 1
}
引擎实际"看到"的是:
function demo() {
var a; // 声明被提升,自动初始化为 undefined
console.log(a); // undefined
a = 1; // 赋值留在原地
console.log(a); // 1
}
问题在于:在声明语句之前访问变量不会报错,只会得到一个安静的 undefined。这意味着拼写错误、执行顺序错乱等问题会被静默吞掉,直到很久之后才以难以追踪的方式爆发。举例:
var value = 10;
function process() {
console.log(value); // undefined,而不是预期的 10!
var value = 20; // 函数内的声明遮蔽了外层的 value
}
process();
开发者本意是读取外层的 value,但函数内的 var value 被提升到函数顶部,遮蔽(shadowing)了外层变量,导致第一次打印得到 undefined。这类 Bug 在大型代码库中排查成本极高。
1.3 允许重复声明
同一作用域内可以用 var 多次声明同名变量,不会有任何报错:
var name = "Alice"; // ...中间隔了几百行代码... var name = "Bob"; // 静默覆盖,无任何警告
在多人协作的大型项目中,这几乎必然导致意外的变量覆盖。全局作用域下尤其危险——var 声明的全局变量会直接挂载到 window 对象上(浏览器环境),任何第三方脚本、任何引入的库都可能与之冲突:
var RegExp = "oops"; // 覆盖了全局的 RegExp 构造函数! console.log(window.RegExp); // "oops"
let 和 const 从语法层面禁止了重复声明,全局声明也不再污染 window,这两个问题被彻底根除。
二、let:现代 JavaScript 的可变绑定
let 在 ES6(ES2015)中引入,目标是提供一个"行为符合直觉"的可变变量声明。
2.1 块级作用域
let 的变量被限制在最近的一对花括号 {} 内,这对花括号可以来自 if、for、while、try、catch、switch 或任意裸代码块:
if (true) {
let y = 20;
}
console.log(y); // ReferenceError: y is not defined
这也让"用代码块显式限制变量生命周期"成为可能,这在需要精确控制作用域的场景下非常有用:
{
let temp = computeHeavyResult();
useIt(temp);
} // temp 在这里确定性地消亡,之后的代码不可能误用它
2.2 暂时性死区(TDZ)
let 同样存在提升——变量绑定在块开始时就已创建——但在声明语句被执行之前,任何对该变量的读取或写入都会抛出 ReferenceError。从块顶部到声明语句之间的这段区域,被称为暂时性死区(Temporal Dead Zone,TDZ)。
{
console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 10;
}
TDZ 是一个运行时概念,不是编译时概念。以下代码完全合法,只要函数调用发生在声明之后:
function getValue() {
return config; // 声明时不报错,执行时才求值
}
let config = { debug: true };
getValue(); // 正常返回,因为调用发生在 TDZ 结束之后
TDZ 的设计目的有两个:其一,把 var 那种"静默返回 undefined"的危险行为变成显式报错,让 Bug 在第一时间暴露;其二,保证代码在变量初始化之前无法以任何方式触碰它,使程序行为更可推理。
一个常见的意外触发场景是循环中引用尚未声明的变量:
for (let i = 0; i < 3; i++) {
let j = i + j; // ReferenceError: Cannot access 'j' before initialization
}
2.3 禁止重复声明
同一作用域内不允许 let 重复声明同名变量,也不允许 let 与同作用域的 var、function、class、const 声明同名:
let a = 1; let a = 2; // SyntaxError: Identifier 'a' has already been declared let b = 1; var b = 2; // 同样 SyntaxError
注意一个微妙的边界情况:同一作用域内的不同嵌套块分别声明是合法的,内层遮蔽外层:
let x = 1;
{
let x = 2; // 合法,内层块遮蔽外层 x
console.log(x); // 2
}
console.log(x); // 1
2.4 全局 let 不挂载到 window
在脚本顶层用 let 声明的变量属于全局词法环境,但不会成为全局对象(window / globalThis)的属性:
var legacyVar = 1; let modernLet = 2; console.log(window.legacyVar); // 1 console.log(window.modernLet); // undefined
这一行为隔离了全局词法环境与全局对象环境,大幅降低了全局命名冲突的风险,也意味着用 let 声明的顶层变量无法被 eval 或第三方脚本通过 window.xxx 访问到。
三、const:不可重新赋值的绑定
const 与 let 拥有完全相同的作用域规则、提升规则和 TDZ 行为,差异只有两点:必须在声明时初始化,以及绑定不可重新赋值。
3.1 "常量"二字的真正含义
const 常被翻译为"常量声明",但这个称呼具有误导性。const 保证的是变量与其所指向的内存地址之间的绑定关系不可改变,而不是"值本身不可变"。
对于原始类型(number、string、boolean、null、undefined、symbol、bigint),值直接存储在绑定指向的内存中,因此 const 事实上等价于不可变:
const MAX = 100; MAX = 200; // TypeError: Assignment to constant variable
但对于对象和数组,绑定指向的是堆内存中对象的引用,const 只保护这个引用不被替换,对象内部的属性、数组的元素依然可以自由修改:
const user = { name: "Alice" };
user.name = "Bob"; // ✅ 修改属性,合法
user.age = 30; // ✅ 新增属性,合法
delete user.name; // ✅ 删除属性,合法
user = {}; // ❌ TypeError —— 试图改变绑定指向
数组同理:
const arr = [1, 2, 3]; arr.push(4); // ✅ arr[0] = 99; // ✅ arr.length = 0; // ✅ 甚至清空数组也是合法的 arr = []; // ❌ TypeError
这不是缺陷,而是有意的设计。JavaScript 中不存在内建的"深不可变"类型,const 只负责它职责范围内的事:防止引用被意外替换。
3.2 需要真正的不可变时怎么办
如果业务逻辑确实要求对象内容不可变,有以下手段:
Object.freeze()——浅冻结:
const config = Object.freeze({
server: { port: 8080 },
retries: 3
});
config.retries = 5; // 静默失败(严格模式下抛 TypeError)
config.server.port = 9999; // ⚠️ 成功!freeze 不递归,嵌套对象仍可变
Object.freeze 只做一层冻结。要实现深冻结需要递归处理:
function deepFreeze(obj) {
Object.values(obj).forEach(value => {
if (value && typeof value === "object") {
deepFreeze(value);
}
});
return Object.freeze(obj);
}
使用不可变数据结构库: 对状态管理有严格不可变要求的场景(如 Redux 的 reducer),业界通行做法是引入 Immutable.js,或遵循"永不原地修改、始终返回新对象"的编码约定,配合展开运算符:
const state = { count: 0 };
const nextState = { ...state, count: state.count + 1 }; // 产生新对象而非修改旧对象
TypeScript 的辅助: readonly 修饰符提供编译期的不可变检查,as const 断言可将字面量收窄为只读的精确类型,与运行时的 const 形成互补。
3.3 必须在声明时初始化
const 声明不允许省略初始值,也不允许"先声明后赋值"的两段式写法:
const x; // SyntaxError: Missing initializer in const declaration const y = 1; // 唯一的合法形式
这一限制与 TDZ 共同保证了:任何 const 变量在被外界观察到之前,必然已经拥有一个确定的值。
四、function 声明:完整提升的特殊存在
function 声明虽然主要用于定义函数,但它同样创建变量绑定,且提升行为与 var/let/const 都不同——它是完整提升:声明和函数体一起被提升到作用域顶部,因此在声明语句之前就可以调用。
greet(); // "Hello" —— 正常工作
function greet() {
console.log("Hello");
}
这带来两个实际影响:
其一,函数声明可以先用后定义,这让组织代码时可以"接口在前、实现在后",阅读时先看主干再看细节。
其二,函数声明会被变量提升规则干扰。 注意函数表达式与函数声明的本质区别:
// 函数声明:完整提升,可以提前调用
hoisted(); // ✅
// 函数表达式:只有变量声明被提升(值为 undefined),提前调用会 TypeError
notHoisted(); // ❌ TypeError: notHoisted is not a function
function hoisted() {}
var notHoisted = function () {};
4.1 块级作用域中的函数声明:历史泥潭
在 ES6 之前,规范并未定义"块内的函数声明"的行为,各浏览器自行其是,导致同一段代码在不同环境下的表现可能完全不同。ES6 将块内函数声明纳入规范:严格模式下,块内函数声明表现为块级作用域(类似 let):
"use strict";
if (true) {
function f() { return 1; }
}
// f 在此不可访问(块级作用域)
但在非严格模式的浏览器环境中,规范还定义了一套 Web 兼容的宽松行为(Annex B),函数名可能同时泄漏到外层函数作用域,规则极其复杂。
实践结论:不要在块(if/for/while 的花括号)内写函数声明。 需要在块内定义函数时,使用 const + 函数表达式或箭头函数,行为完全可预测:
if (someCondition) {
const handler = () => { /* ... */ };
}
五、class 声明:语法之下的 let 语义
ES6 的 class 声明创建的绑定,其行为完全对齐 let:
- 块级作用域;
- 存在 TDZ——
class虽然也会被提升,但在声明语句之前访问会抛出ReferenceError(这与function的完整提升形成鲜明对比):
console.log(MyClass); // ReferenceError: Cannot access 'MyClass' before initialization
class MyClass {}
- 禁止同作用域重复声明;
- 与
let不同的是,class绑定可以被重新赋值(class本质上是创建了一个指向类构造函数的变量,除非用const声明):
class A {}
A = function () {}; // 语法上允许,但强烈不建议
正因为如此,社区惯例是用 const 声明类,明确表达"这个类绑定不应被替换"的意图:
const UserService = class { /* ... */ };
// 或更常见的
class UserService {} // 顶层 class 声明本身已足够,模块内不会被重新赋值
六、import:模块作用域中的只读活绑定
ES Modules 的 import 声明创建的绑定有几个独一无二的性质,值得单独说明。
6.1 只读性
import 进来的绑定是只读的,在导入方对其进行赋值会抛出 TypeError:
// counter.js
export let count = 0;
export function increment() { count++; }
// main.js
import { count, increment } from "./counter.js";
count = 10; // ❌ TypeError: Assignment to constant variable
increment(); // ✅ 通过导出方提供的函数修改
console.log(count); // 1
6.2 活绑定(Live Binding)
上例还揭示了 import 最特殊的性质:活绑定。导入方拿到的不是导出值的一份快照拷贝,而是与导出模块内部变量保持实时同步的引用。导出方修改了变量,导入方读到的就是新值。
这与 CommonJS 的 require 形成对比——require 拿到的是模块导出对象在加载完成时刻的一份(浅)拷贝,后续导出方的修改不会反映到已导入的引用上(除非修改的是共享的嵌套对象)。
6.3 静态结构与提升
import 声明必须位于模块顶层,不能出现在条件语句、循环或函数体内(需要动态导入时使用 import() 表达式)。模块的所有 import 在任何代码执行之前就被解析和链接(这是 ESM 能做 Tree Shaking 静态分析的基础),因此:
// 这在 ESM 中是合法的——import 被提升到模块最顶部
console.log(value); // 如果 value 来自 import,这里已经可用
import { value } from "./data.js";
6.4 模块作用域
每个 ES 模块拥有独立的模块作用域:模块顶层的 var、let、const 声明都不会泄漏到全局。这是 ESM 天然解决全局污染问题的原因,也是现代前端工程不再需要 IIFE 包裹模式的原因。
七、其他产生绑定的语法结构
除了上述"显式声明关键字",JavaScript 中还有若干隐式或结构性的标识符绑定机制,理解它们同样重要。
7.1 catch 参数
catch 子句的参数拥有独立的块级作用域(ES3 起即是如此,语义上与 let 一致):
try {
throw new Error("boom");
} catch (err) {
console.log(err.message); // "boom"
}
console.log(err); // ReferenceError —— err 不泄漏到外部
ES2019 引入了可选 catch 绑定,当不需要错误对象时可以省略参数:
try {
JSON.parse(input);
} catch {
// 只关心"解析失败了",不需要错误详情
return defaultValue;
}
7.2 函数参数与默认值
函数参数是函数作用域内的绑定,ES6 之后支持默认值、解构和 rest 参数。一个关键细节是:参数的默认值表达式拥有自己独立的中间作用域,可以引用前面的参数,但不能引用函数体内用 let/const 声明的变量:
function f(a, b = a * 2) { // ✅ b 的默认值可以引用 a
return a + b;
}
function g(a, b = inner) { // ❌ 默认值在函数体执行前求值
let inner = 10; // 此时 inner 处于 TDZ
return b;
}
g(1); // ReferenceError
7.3 解构赋值中的声明
解构只是绑定变量的模式语法,作用域规则由前面的关键字决定:
const { name, age = 18 } = user; // const 语义
let [first, ...rest] = list; // let 语义
for...of、for...in 循环头中同样可以使用三种关键字,且 let 版本同样享有"每轮迭代一个新绑定"的语义:
for (const item of items) { /* item 每轮都是新绑定,可安全用于闭包 */ }
这也是遍历循环推荐 for (const ...) 的原因:循环变量在每轮迭代中天然不可变,杜绝了在循环体内误改迭代变量的可能。
7.4 arguments 对象
非箭头函数内部自动存在 arguments 绑定,是一个包含实参的类数组对象。它在非严格模式下与命名参数存在"神奇联动"(修改 arguments[0] 会同步修改第一个命名参数,反之亦然),严格模式下则切断联动。现代代码中一律推荐用 rest 参数替代:
function sum(...nums) { // nums 是真正的数组
return nums.reduce((a, b) => a + b, 0);
}
7.5 label 语句
标签不是变量声明,但它为 break/continue 提供了一个命名的跳转目标,属于标识符绑定的一种:
outer: for (let i = 0; i < 3; i++) {
for (let j = 0; j < 3; j++) {
if (i === 1 && j === 1) continue outer;
console.log(i, j);
}
}
标签的使用场景极其有限(几乎只用于跳出多层嵌套循环),且可读性差,通常建议重构为函数 + return 的形式来替代。
7.6 应当远离的动态作用域机制
with 语句:将对象属性注入作用域链,使静态作用域分析完全失效,严格模式已将其列为语法错误。任何情况下都不应使用。
eval:在非严格模式下可以在当前作用域动态创建变量,破坏引擎的所有优化假设(含 TDZ 检查、内联缓存等),并带来注入风险。严格模式下 eval 拥有独立作用域,但性能惩罚依然存在。需要动态执行代码时优先考虑 new Function()(至少作用域是全局的、可预测的),或从根本上重新设计避免动态执行。
八、提升机制的统一模型
把前面分散讨论的提升行为汇总,可以得到一个统一的心智模型。JavaScript 的执行分为两个阶段:编译阶段(创建执行上下文、建立所有绑定)和执行阶段(逐行运行代码)。不同声明在编译阶段建立的绑定,其初始化时机各不相同:
| 声明形式 | 绑定时机 | 初始化时机 | 初始化前的访问行为 |
|---|---|---|---|
var x = 1 | 作用域创建时 | 立即(undefined) | 返回 undefined |
let x = 1 | 块进入时 | 执行到声明语句时 | ReferenceError(TDZ) |
const x = 1 | 块进入时 | 执行到声明语句时(必须带初始值) | ReferenceError(TDZ) |
function f() {} | 作用域创建时 | 立即(完整函数对象) | 正常调用 |
class C {} | 块进入时 | 执行到声明语句时 | ReferenceError(TDZ) |
import x from ... | 模块链接时 | 模块求值前(链接阶段完成) | 通常已可用(活绑定) |
需要纠正一个流传甚广的说法:“let 和 const 不存在变量提升”。这是错误的。 它们的绑定同样在编译阶段被创建(否则引擎无法在声明前访问时精确报出 “Cannot access ‘x’ before initialization” 这样的 TDZ 错误——如果绑定完全不存在,报的会是 “x is not defined”)。准确的说法是:let/const/class 被提升但不在提升时初始化,提升与初始化之间的区域就是 TDZ。
同名标识符的优先级规则也值得记录:在同一作用域中,函数声明会覆盖 var 声明;而 let/const/class 与任何同名声明(包括 var 和函数声明)在同一作用域中共存都会直接产生语法错误。
九、var、let、const 全维度对比
在逐一深入之后,这里给出三者的完整对比总表,作为速查参考:
| 维度 | var | let | const |
|---|---|---|---|
| 引入版本 | ES1 | ES6 | ES6 |
| 作用域 | 函数作用域 / 全局 | 块级作用域 | 块级作用域 |
| 提升 | 提升并初始化为 undefined | 提升,TDZ | 提升,TDZ |
| 声明前访问 | undefined(静默) | ReferenceError | ReferenceError |
| 声明时初始化 | 可选 | 可选 | 必须 |
| 重新赋值 | 允许 | 允许 | 禁止(引用类型内容仍可变) |
| 同作用域重复声明 | 允许 | 禁止 | 禁止 |
| 循环中每轮新绑定 | 否 | 是 | 是(for...of/for...in) |
| 全局声明挂载到 window | 是 | 否 | 否 |
| 可被 delete 删除(全局) | 是 | 否 | 否 |
| 现代代码中的定位 | 已淘汰 | 需要重新赋值时使用 | 默认选择 |
补充说明表中两个较少被提及的行为:
delete:全局var声明创建的是全局对象的可配置属性,delete window.xxx可以将其移除;let/const的绑定存在于词法环境中,delete对它们无效(返回true但什么都不做,严格模式下甚至报错)。- 遮蔽链:三种声明都遵循词法作用域的遮蔽规则——内层作用域的同名声明会遮蔽外层,但互不影响:
const value = "outer";
function demo() {
const value = "inner"; // 遮蔽外层 value
console.log(value); // "inner"
}
demo();
console.log(value); // "outer"
十、实践规范:什么场景用什么声明
理论梳理完毕后,落地为可执行的编码规范。以下规则综合了 Airbnb、Google、Standard 等主流风格指南以及社区多年实践的共识。
10.1 默认使用 const
除非有明确的重新赋值需求,一律使用 const。 这条规则的价值不在于性能,而在于它向读代码的人传递了确定性信息:这个绑定在它的整个生命周期内不会被替换,阅读时无需担心它在某处被悄悄改掉。
需要特别强调:对象和数组即使内容会变,也应该用 const 声明。 const 保护的是引用,"引用不变、内容可变"是 JavaScript 中最常见也最健康的对象使用模式:
const items = [];
items.push(1, 2, 3); // 完全符合 const 的语义约定
const state = { loading: true };
state.loading = false; // 同理
如果你发现自己"因为要修改数组所以用了 let",那是对 const 语义的误解。
10.2 仅在需要重新赋值时使用 let
典型的 let 场景包括:
// 1. 循环计数器
for (let i = 0; i < items.length; i++) { /* ... */ }
// 2. 条件分支赋值(无法在声明点确定值)
let discount;
if (isVip) {
discount = 0.8;
} else {
discount = 1.0;
}
// 3. 累积器 / 状态翻转
let total = 0;
for (const item of cart) total += item.price;
// 4. 交换变量
[a, b] = [b, a]; // a、b 需为 let
如果一段代码中 let 声明之后从未被重新赋值,ESLint 的 prefer-const 规则会自动报警,应当修正为 const。
10.3 彻底弃用 var
新代码中没有任何理由使用 var。维护遗留代码时,遇到 var 应评估是否可以安全地改为 let 或 const——需要注意的迁移风险点有两个:一是依赖了 var 的函数级提升和跨块可见性的代码(如前面提到的块内赋值、块外读取的模式);二是依赖全局 var 挂载到 window 供其他脚本访问的代码。这两类情况需要连带重构,而非机械替换。
工程上建议通过 ESLint 强制约束:
{
"rules": {
"no-var": "error",
"prefer-const": "error",
"one-var": ["error", "never"]
}
}
one-var: never 禁止 let a, b, c; 这种多变量合并声明——每个变量独立一行声明,才能独立选择 const 或 let,也让 diff 更清晰。
10.4 各场景的选择速查
| 场景 | 选择 | 说明 |
|---|---|---|
| 模块导入 | import | 天然只读活绑定 |
| 顶层函数定义 | function 声明 | 完整提升便于组织代码,或统一用 const + 箭头函数 |
| 块内定义的函数 | const + 箭头函数/函数表达式 | 规避块级函数声明的历史泥潭 |
| 类定义 | class | 需要强调绑定不可替换时用 const X = class {} |
| 配置、常量、魔法数字 | const | 全大写命名(MAX_RETRY)标记语义常量 |
| 对象 / 数组 / Map / Set | const | 引用不变,内容可变 |
| 回调函数、箭头函数 | const | 函数引用几乎从不重新赋值 |
| 循环计数器 | let | 需要逐轮递增 |
| 遍历循环的迭代变量 | const(for...of / for...in) | 每轮新绑定,天然只读 |
| 延迟初始化 / 条件赋值 | let | 声明点无法确定值 |
| catch 参数 | 默认省略(ES2019+),需要时由语法决定 | 块级作用域 |
10.5 命名与风格约定
声明关键字的选择之外,配套的命名约定同样构成代码质量的一部分:
const语义常量(不会变的配置值)使用UPPER_SNAKE_CASE;普通const/let变量使用camelCase。- 布尔变量使用
is/has/should前缀(isLoading、hasPermission),配合let声明状态标记。 - 声明位置遵循"最近使用原则":变量应在首次使用前尽量近的地方声明,而不是函数顶部。这是
let/const时代对"变量必须声明在函数开头"这一旧惯例(C89 风格)的明确反叛——就近声明缩小了变量的可见范围,降低了认知负担。 - 缩小作用域优先:能用块包起来限制生命周期的,就不要让变量在整个函数中存活。
十一、常见误区澄清
最后汇总几个在社区中反复出现的错误认知,逐一澄清。
误区一:“let/const 没有变量提升。”
错误。它们同样被提升(绑定在块进入时创建),只是初始化被延迟到声明语句处,中间形成 TDZ。引擎能报出 “Cannot access before initialization” 而非 “is not defined”,恰恰证明绑定早已存在。
误区二:“const 声明的对象是不可变的。”
错误。const 只冻结绑定,不冻结内容。对象的属性、数组的元素可以自由增删改。需要内容不可变时应使用 Object.freeze(注意其浅冻结特性)或不可变数据结构方案。
误区三:“TDZ 只存在于 let/const。”
不完全正确。class 声明同样有 TDZ;函数的默认参数作用域中引用函数体内声明的 let/const 变量同样会触发 TDZ 错误。甚至可以说 typeof 在 TDZ 中也不安全——typeof undeclaredVar 返回 "undefined" 不报错,但 typeof tdzVar 会抛出 ReferenceError,这是探测变量是否处于 TDZ 的经典手段。
误区四:“块级作用域中的函数声明和 let 行为一样。”
仅在严格模式且现代引擎下近似成立。非严格模式的浏览器环境受 Annex B 兼容规则影响,行为复杂且各引擎不完全一致。唯一可靠的实践是:不在块内使用函数声明。
误区五:“var 声明的循环变量在每次迭代中是新的。”
错误,且这正是 var 闭包陷阱的根源。整个循环共享一个绑定;只有 let(以及 for...of/for...in 中的 const)才具备每轮创建新绑定的语义。
误区六:“全局 let/const 也是全局变量,和 var 没区别。”
错误。全局 var 成为 window/globalThis 的属性,可被任意脚本访问、覆盖、delete;全局 let/const 只存在于全局词法环境中,不挂载到全局对象,天然隔离。
结语
从 var 到 let/const 的演进,本质上是 JavaScript 从"宽松容错的脚本语言"走向"严谨可推理的应用语言"的缩影。函数作用域让位于块级作用域,静默的 undefined 让位于显式的 TDZ 报错,放任的重复声明让位于编译期拦截——每一处收紧都在用早期的一次性学习成本,换取长期开发中数量级下降的 Bug 率和认知负担。
对今天的开发者而言,需要记忆的规则其实非常简洁:
- const 是默认,let 是例外,var 是历史;
- 对象用 const,改的是内容不是引用;
- 块内不用 function 声明,遍历循环放心用 const;
- 理解 TDZ,就理解了 let/const 提升的全部。
到此这篇关于深入理解JavaScript中变量声明var、let和const的区别的文章就介绍到这了,更多相关JS中var let和const区别内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!
