变量与声明:let、const、var 的选择边界

先看一段几乎每个人都踩过的代码:

javascript 复制代码
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)
}

运行结果不是 0 1 2,而是 3 3 3。

很多人第一次遇到这个结果时,会以为是 setTimeout 的问题。但只要把 var 换成 let:

javascript 复制代码
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)
}
// 0 1 2

问题就消失了。

同一段逻辑,换个声明关键字,行为完全不同。这说明 var、let、const 的差异,不是"新旧写法"这么简单,而是作用域模型的差异。今天就把它彻底讲清楚,最后落到一条可执行的选择边界上。

一、变量声明到底在做什么

一句话:变量声明是把一个名字绑定到某个值上,并且规定这个名字在哪段代码里可见。

这里有两个维度:

  • 绑定:名字和值之间建立关联,之后可以用名字取值、改值。

  • 作用域:这个名字在哪些位置能被访问到。

var、let、const 的差异,本质上是在这两件事上做了不同的规则:

关键字 作用域 可否重新赋值 可否重复声明 是否提升
var 函数作用域 可以 可以 提升为 undefined
let 块级作用域 可以 不可以 提升但进入 TDZ
const 块级作用域 不可以 不可以 提升但进入 TDZ

先记住这张表,下面逐条拆解。因为很多规则光看表很难体会,必须看到代码才明白它为什么重要。

二、var:函数作用域与它的历史包袱

var 是 JavaScript 最早的声明方式。它的核心特征只有一条,但影响深远:作用域是函数,不是块。

1. 块不构成边界

javascript 复制代码
if (true) {
  var a = 1
}
console.log(a)   // 1

按理说 a 是在 if 的花括号里声明的,出了花括号就该消失。但 var 不认花括号,它只认函数:

javascript 复制代码
function fn() {
  if (true) {
    var b = 2
  }
  console.log(b)   // 2,在同一个函数内依然可见
}
fn()
console.log(typeof b)   // "undefined",函数外就没了

这个行为在早期被视为"方便",后来被证明是 bug 温床。for 循环里那个例子就是后果:循环变量 i 在整个函数内只有一份,setTimeout 的回调执行时,循环早已结束,读到的自然是最终值。

2. 可以重复声明

javascript 复制代码
var x = 1
var x = 2
console.log(x)   // 2,不报错

同一作用域内重复声明不报错,后一次覆盖前一次。这意味着你写错变量名、或者在长函数里不小心重名,都不会有任何提示,只能靠运行时行为去猜。

3. 提升为 undefined

javascript 复制代码
console.log(y)   // undefined,不报错
var y = 10

var 声明会被"提升"到作用域顶部,但赋值不会。所以上面等价于:

javascript 复制代码
var y
console.log(y)
y = 10

这就制造了一种很迷惑的现象:变量还没声明就能访问,值是 undefined。它不报错,于是错误被隐藏了。

4. 在全局顶层会挂到全局对象上

javascript 复制代码
var g = 1
console.log(window.g)   // 1

var 在全局作用域声明时,会成为全局对象(浏览器里是 window)的属性。这在多人协作或者引入第三方脚本时,容易造成全局污染和命名冲突。

补充一个细节:在 ES 模块(<script type="module"> 或 .mjs)顶层,var 不会挂到 window 上。所以这条"污染"主要发生在传统脚本场景。具体行为可以用控制台验证,不同环境以实测为准。

三、let 与 const:块级作用域

let 和 const 是 ES2015 引入的。它们把作用域规则改成了"块级"------任何一对花括号都是一个边界。

1. 块是边界

javascript 复制代码
if (true) {
  let a = 1
  const b = 2
}
console.log(typeof a)   // "undefined"
console.log(typeof b)   // "undefined"

出了块就访问不到。这符合大多数人的直觉:在哪儿声明,就在哪儿用。

2. 不能重复声明

javascript 复制代码
let x = 1
let x = 2   // SyntaxError: Identifier 'x' has already been declared

重复声明直接语法报错,问题在写代码时就暴露,而不是等到运行时。

3. 暂时性死区(TDZ)

这是 let/const 最容易被误解的地方。它们也有"提升",但提升之后不能被访问,直到声明语句执行到那一行。这段不可访问的区间叫暂时性死区(Temporal Dead Zone)。

javascript 复制代码
console.log(z)   // ReferenceError: Cannot access 'z' before initialization
let z = 1

对比 var 的 undefined,这里直接报错。看起来更"严格",其实是好事:它把"访问了还没初始化的变量"这种错误明确暴露出来,而不是给你一个看似正常的 undefined。

TDZ 的边界是"进入作用域"到"声明语句执行完"之间:

javascript 复制代码
let a = 1
{
  // 从这里开始,块内的 a 进入 TDZ
  console.log(a)   // ReferenceError
  let a = 2
}

这个例子里,块内声明了 let a,所以整个块内都优先使用块内的 a。在声明之前访问,就落进了 TDZ。这类代码本身就该避免,但理解 TDZ 能让你在遇到报错时知道原因。

4. const 必须初始化

javascript 复制代码
const PI = 3.14     // 正确
const MAX           // SyntaxError: Missing initializer in const declaration

const 声明必须同时赋值。这也是它和 let 唯一的语法差异。

四、const 的"不可变"到底指什么

这是新手最容易误解的一点。const 保证的是绑定不可变 ,不是值不可变。

javascript 复制代码
const user = { name: 'Tom' }
user.name = 'Jerry'   // 可以,修改的是对象内容
console.log(user)     // { name: 'Jerry' }

user = { name: 'Bob' }   // TypeError: Assignment to constant variable.

原因很直接:const 锁的是"user 这个名字指向哪个对象",不是"这个对象内部长什么样"。对象本身还是可变的,只是不能再让 user 指向别的对象。

数组同理:

javascript 复制代码
const list = [1, 2, 3]
list.push(4)      // 可以
list = [1]        // TypeError

如果真的想让对象内容也不可变,需要 Object.freeze:

javascript 复制代码
const config = Object.freeze({ a: 1, b: 2 })
config.a = 100
console.log(config.a)   // 1,修改被忽略

注意 Object.freeze 是浅冻结,嵌套对象内部的属性仍然可以改。要深冻结需要递归处理,或者借助工具库。这个细节在实际项目中经常被忽略。

五、选择边界:一条可以直接执行的规则

规则很简单,按顺序判断:

  1. 默认写 const。

  2. 需要重新赋值时,改成 let。

  3. 不要用 var。

为什么默认 const?因为多数变量在初始化之后就不该再变。用 const 声明,相当于给读代码的人一个明确信号:"这个值后面不会变,你可以放心往下读"。一旦有人想改,语法层会立刻拦住,逼他重新思考这段逻辑是否合理。

为什么不用 var?不是因为它"过时",而是它的三条特性(函数作用域、可重复声明、提升为 undefined)都在降低错误暴露的速度 。同样的 bug,用 let 写会在编码阶段报错,用 var 写可能要到线上才发现。

工程上可以直接用 ESLint 固化这条规则:

javascript 复制代码
{
  "rules": {
    "no-var": "error",
    "prefer-const": "error"
  }
}

no-var 禁止使用 var,prefer-const 会把"声明后从未重新赋值"的 let 提示改成 const。这两条规则成本极低,收益很直接。

六、三个高频场景的对比

场景一:循环里的闭包

javascript 复制代码
// var:只有一份 i
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)   // 3 3 3
}

// let:每轮迭代创建新的绑定
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)   // 0 1 2
}

let 在 for 循环里有个特殊行为:每轮迭代都会创建一个新的绑定,并把上一轮的值复制过来。所以每个回调捕获的是各自的 i。

var 只有一份,回调执行时循环已经结束,读到的都是终值。想用 var 达到同样效果,得靠 IIFE 手动造作用域:

javascript 复制代码
for (var i = 0; i < 3; i++) {
  ;(function (j) {
    setTimeout(() => console.log(j), 100)
  })(i)
}

能跑,但写起来费劲。let 把这个模式变成了默认能力。

场景二:if 块内的临时变量

javascript 复制代码
// var:泄漏到函数作用域
function check(flag) {
  if (flag) {
    var result = 'yes'
  }
  return result   // flag 为 false 时返回 undefined,不报错
}

// let:块内生命周期
function check(flag) {
  if (flag) {
    let result = 'yes'
    return result
  }
  return 'no'
}

第一版在 flag 为 false 时返回 undefined,不会报错,调用方可能拿着 undefined 继续往下走。第二版把变量的生命周期压在块内,逻辑边界更清楚。

场景三:顶层全局变量

javascript 复制代码
var appName = 'demo'
console.log(window.appName)   // "demo"

let appName2 = 'demo'
console.log(window.appName2)  // undefined

var 在全局作用域会挂到 window 上,let/const 不会。前者容易和其他脚本冲突,后者更安全。这也是现代代码倾向于 let/const 的原因之一。

七、几个容易忽略的细节

1. switch 里的声明

switch 的 case 之间共享同一个块作用域,所以:

javascript 复制代码
switch (type) {
  case 'a':
    let x = 1
    break
  case 'b':
    let x = 2   // SyntaxError: 'x' has already been declared
    break
}

两个 case 里都声明 x,会被认为重复声明。解决办法是给 case 加花括号:

javascript 复制代码
switch (type) {
  case 'a': {
    let x = 1
    break
  }
  case 'b': {
    let x = 2
    break
  }
}

2. 循环里的 const

for (const i of list) 是合法的,因为每次迭代都会创建新的绑定:

javascript 复制代码
for (const item of [1, 2, 3]) {
  console.log(item)   // 1 2 3
}

但 for (const i = 0; i < 3; i++) 不行,因为 i++ 要重新赋值,const 不允许。

3. 同一作用域下 var 和 let 混用

javascript 复制代码
var a = 1
let a = 2   // SyntaxError

不管是先 var 后 let,还是反过来,同一作用域内混用都会报错。这条规则比单纯记"let 不能重复声明"更准确。

八、初学者常见疑问

问:既然 const 这么好,是不是干脆不用 let 了?

不行。计数器、累加器、状态标记这类变量天生需要重新赋值:

javascript 复制代码
let count = 0
count++

let isLoading = false
isLoading = true

该用 let 就用 let,强行用 const 只会写出一堆变通写法,反而更难读。

问:const 声明的对象能改,那它到底有什么用?

作用在绑定层 。它保证你拿到的一直是同一个对象引用,不会因为某处代码误写 user = {...} 而悄悄换掉。这在传递配置、依赖注入、模块导出时尤其重要。

问:var 现在还有使用场景吗?

几乎没有。少数老代码、或者需要在全局挂属性的场景下才会见到。新代码里没有理由再用。

问:TDZ 报错和"变量未定义"报错有什么区别?

javascript 复制代码
console.log(a)   // ReferenceError: a is not defined(作用域里根本没有 a)
console.log(b)   // ReferenceError: Cannot access 'b' before initialization(有 b,但还在TDZ)
let b = 1

报错信息会区分这两种情况。看报错文案就能判断是拼写错了,还是声明顺序有问题。

问:为什么 let 在循环里每次迭代都是新绑定?

这是规范为 for 语句定义的特殊行为:每轮迭代都会基于上一轮的值创建新的词法环境。理解这一点,就能解释为什么 setTimeout 在 let 版本里能拿到正确的值。具体规范细节需查阅 ECMAScript 对应版本,行为本身可以用控制台直接验证。

九、落到团队约定

如果要把上面这些变成团队里能执行的规则,只需要三条:

  1. ESLint 开 no-var 和 prefer-const,把选择交给工具,不靠自觉。

  2. 默认写 const,需要重新赋值再改 let,写代码时就按这个顺序想。

  3. 审查时关注"变量作用域是否过大" ,var 泄漏和块级变量被提到函数顶部,都是常见问题源。

规则本身不复杂,难的是在写代码的瞬间形成条件反射。多写几百行,const 就会变成默认手感。

结语

var、let、const 的差异,表面看是三个关键字,实质是两套作用域模型:一个只看函数边界,一个看所有花括号;一个允许重复声明并把错误藏到运行时,一个在编码阶段就报错。

记住那条选择边界就够了:默认 const,需要重新赋值用 let,var 不用。它不是风格偏好,而是让错误尽早暴露的工程选择。代码写得越久,越会感激那些"写错了立刻报错"的设计。

相关推荐
程序员大阳26 分钟前
副队长Vue3教程(8)--列表渲染 v-for
javascript·vue3·v-for·列表渲染
个 人 练 习 生1 小时前
C++:从零基础到深入了解vector的使用
开发语言·c++·经验分享·学习·程序人生·stl
H.莓飛2 小时前
【C++】【STL】stack_OJ题
服务器·c语言·开发语言·数据结构·c++·算法·visual studio
hudd6682 小时前
JavaEE 初阶 - 文件操作和IO
java·开发语言·java-ee
JavaGuide3 小时前
Cloudflare 开源的这套神级安全审计 Skill 太好用了!
前端·后端
starzy19903 小时前
深入理解Scala隐式参数:上下文流转
开发语言·python·scala
孟健4 小时前
用 unslop 拯救 AI 生成网页的塑料感,7 分钟重构落地实测
前端·人工智能·ai编程
feixing_fx4 小时前
JavaScript 是什么:从浏览器脚本到通用编程语言
开发语言·前端·javascript·前端框架·ecmascript
丘山望岳4 小时前
【开发工具】 cluade code常用快捷键
前端