JS:值、作用域、函数
本合集目录
本章目录
单册说明:本文件是卷 2 的第 4 章,可独立阅读。前置:第 3 章(变量与断点)。本章把 JavaScript 当作一门独立语言讲清八件事,并写出「读到」的三个数据函数。
| 项 | 内容 |
|---|---|
| 所属卷 | 卷 2 · 浏览器三件套(第 4 / 7 章) |
| 前置章节 | 2.3 CSS 工程化与响应式 |
| 本章产出 | addNote / listNotes / render 三个函数,能把摘录存进 localStorage 并读回来 |
| 对应代码 | code/dudao/index.html(第 4 章版本,<script> 追加在 </body> 前) |
| 配图 | 无(后续统一制图) |
| 读完的判定 | 能在控制台里说清"为什么我改了副本,原对象也变了"和"为什么循环里的回调拿到了同一个值" |
2.4.1 一句话结论:JS 只有一种"传值",但值可能是地址
先看两个现场,它们长得毫不相干,其实是同一个知识点的两面。
现场一。 有人写了一个函数处理摘录,想把标题改成大写:
function upperTitle(note) {
note.title = note.title.toUpperCase();
return note;
}
const origin = { title: '读到' };
const changed = upperTitle(origin);
console.log(origin.title); // "读到" ? 还是 "读到".toUpperCase() ?
他以为函数里改的是"副本",结果 origin.title 也变成了大写。
现场二。 有人给三个按钮绑点击事件,想打印各自的序号:
for (var i = 0; i < 3; i += 1) {
document.querySelectorAll('.tag-btn')[i].addEventListener('click', function () {
console.log(i);
});
}
点三个按钮,打印出来的全是 3。他把 var 改成 let,就好了——但他不知道为什么会好。
这两个 bug 的共同点是:你对"变量里装的是什么"的直觉是错的。 JavaScript 里变量装的是"值",但对象的"值"是一个地址。理解这一条,两个 bug 同时消失。
本章就讲这一件事,以及它牵出来的七个相关概念。这一章没有页面效果,全部在控制台里做,因为语言基础必须在没有界面的干扰下打牢。
2.4.2 原理与方法
① 八种类型,分两类
| 类别 | 类型 | 例子 | 存在哪 |
|---|---|---|---|
| 原始类型(7 种) | string |
'读到' |
值本身 |
number |
42、3.14 |
值本身 | |
boolean |
true / false |
值本身 | |
null |
空,且是"有人故意设的空" | 值本身 | |
undefined |
空,且是"还没赋值" | 值本身 | |
symbol |
唯一标识符 | 值本身 | |
bigint |
超大整数 | 值本身 | |
| 引用类型(1 种) | object(含数组、函数) |
{ title: '读到' }、[] |
一个地址,指向堆里的一块 |
typeof 有两个必须记住的例外:typeof null 返回 'object'(历史 bug,改不了),typeof function 返回 'function'(虽然函数本质是对象)。
② 值类型与引用类型:唯一的区别在"赋值时抄了什么"
| 操作 | 原始类型 | 引用类型 |
|---|---|---|
const b = a |
抄一份值,之后互不影响 | 抄一份地址,两个变量指向同一个对象 |
a === b |
比较值是否相同 | 比较是否指向同一个对象 |
| 传参给函数 | 传值的副本,函数内改不动外面 | 传地址的副本,函数内改属性会影响外面 |
用一个例子走完三种情况:
let a = 1;
let b = a;
b = 2;
console.log(a); // 1,互不影响
const obj1 = { n: 1 };
const obj2 = obj1;
obj2.n = 2;
console.log(obj1.n); // 2,因为 obj1 和 obj2 是同一个对象
const obj3 = { n: 1 };
const obj4 = { n: 1 };
console.log(obj3 === obj4); // false,长得一样但是两个对象
第三行是新手最难接受的:两个内容完全相同的对象,=== 也是 false。因为 === 比的是地址,不是内容。要比较内容得逐字段比,或者先 JSON.stringify 再比(只适用于纯数据)。
那怎么"复制一个对象"?浅拷贝:
const copy = { ...obj1 };
const copy2 = Object.assign({}, obj1);
{ ...obj1 } 只抄第一层。如果对象里还套着对象,内层仍是共享的——这叫浅拷贝。深层嵌套就要递归复制(structuredClone(obj) 是现代浏览器自带的深拷贝)。第 5 章渲染列表时会用到浅拷贝,因为我们的摘录只有一层。
③ == 与 ===:只用后者
=== 要求类型和值都相同;== 会先做隐式类型转换再比。转换规则复杂到需要查表,所以结论很简单:业务代码一律用 ===。
| 表达式 | == 结果 |
=== 结果 |
原因 |
|---|---|---|---|
'1' == 1 |
true |
false |
字符串被转成数字 |
0 == false |
true |
false |
布尔转数字 |
'' == false |
true |
false |
同上 |
null == undefined |
true |
false |
特例,规范单独规定 |
null == 0 |
false |
false |
特例,null 只等于 undefined |
NaN == NaN |
false |
false |
NaN 不等于任何值,包括自己 |
[] == false |
true |
false |
数组转字符串 '',再转数字 0 |
'1' === 1 |
— | false |
类型不同直接 false |
判断 NaN 要用 Number.isNaN(x),不能用 x === NaN(永远 false)。
唯一值得保留 == 的场景是 x == null,它能同时匹配 null 和 undefined,用来写"这个值有没有"很方便。其他情况写 ===。
④ var / let / const:三条差异
| 维度 | var |
let |
const |
|---|---|---|---|
| 作用域 | 函数作用域 | 块级作用域 {} |
块级作用域 {} |
| 变量提升 | 提升并初始化为 undefined |
提升但不初始化(暂时性死区) | 同 let |
| 重复声明 | 允许(静默覆盖) | 报错 | 报错 |
| 重新赋值 | 允许 | 允许 | 不允许 |
挂到 window |
会(全局时) | 不会 | 不会 |
块级作用域是 let 最重要的特性。{} 里声明的变量出了花括号就没了:
if (true) {
var a = 1;
let b = 2;
}
console.log(a); // 1
console.log(b); // ReferenceError: b is not defined
const 常被误解成"值不能改"。它锁的是绑定,不是内容:
const note = { title: '读到' };
note.title = '读到 · 改过'; // 可以,改的是对象的属性
note = { title: '新对象' }; // TypeError: Assignment to constant variable.
所以规则是:默认用 const,需要重新赋值时才用 let,永远不用 var。 这样读代码的人看到 const 就知道"这个名字不会再指向别的东西",省掉一半追踪成本。
⑤ 作用域链:内层看得到外层,外层看不到内层
const site = '读到';
function showTitle() {
const prefix = '【' + site + '】';
console.log(prefix);
}
showTitle(); // 【读到】
console.log(prefix); // ReferenceError: prefix is not defined
函数在定义的地方决定它能看见谁,这叫词法作用域。查找顺序是:自己 → 外层函数 → 更外层 → 全局。找到就停,找不到报 ReferenceError。
这条链是单向的:里面的能看外面,外面的看不到里面。所以两个平级的函数互相看不见对方的局部变量。
⑥ 闭包:函数记得它出生时的地方
闭包的定义只有一句:函数 + 它被定义时所在的那个作用域。只要这个函数还活着,它引用的外部变量就不会被回收。
function createCounter() {
let count = 0;
return function () {
count += 1;
return count;
};
}
const next = createCounter();
console.log(next()); // 1
console.log(next()); // 2
console.log(next()); // 3
const other = createCounter();
console.log(other()); // 1,各自独立
createCounter 执行完之后,按常理 count 应该被销毁。但返回的那个匿名函数还引用着它,所以它活着。每一个 createCounter() 调用都会创建一个独立的作用域,所以 next 和 other 不共享 count。
这有什么用?三个实际用途:
| 用途 | 说明 |
|---|---|
| 私有状态 | count 无法从外部直接改,只能通过 next() 递增 |
| 记住上下文 | 事件回调里能用到绑定时的变量 |
| 工厂函数 | 一次定义,生成多个互不干扰的实例 |
回到开头的现场二。var 声明的 i 是函数作用域,整个循环只有一个 i;三个回调引用的是同一个 i,等它们执行时循环早已结束,i 是 3。改成 let 之后,每一轮循环都会创建一个新的块级绑定,三个回调各记各的:
for (let i = 0; i < 3; i += 1) {
setTimeout(function () {
console.log(i); // 0 1 2
}, 0);
}
(setTimeout 是"过一会儿再执行",第 6 章讲事件循环时会解释它为什么不是立刻执行。这里只需要知道:回调是在循环结束之后才跑的。)
闭包不是特性,是后果。 你没有"使用闭包",你只是用了函数和作用域,闭包自然发生。要小心的是它会让变量活得更久——如果一个闭包引用了一个巨大的数组,那个数组就一直占着内存。
⑦ 箭头函数与 this
const double = (n) => n * 2;
const greet = (name) => {
return `你好,${name}`;
};
两个差别:箭头函数更短;箭头函数没有自己的 this,它沿用外层函数的 this。
普通函数的 this 由"怎么调用"决定:
const counter = {
count: 0,
inc: function () {
this.count += 1;
return this.count;
},
};
counter.inc(); // 1,this 是 counter
const loose = counter.inc;
loose(); // NaN,this 是 undefined(严格模式)或 window
把方法单独拿出来赋值,this 就丢了。这是"对象方法千万别用箭头函数"的原因:
const broken = {
count: 0,
inc: () => {
this.count += 1; // this 是外层(模块里是 undefined),不是 broken
},
};
初学阶段的实用规则:对象的方法、需要 this 的地方用 function;其余回调一律用箭头函数。 箭头函数在回调里特别合适,因为它不会把 this 弄丢。
⑧ 解构与模板字符串
解构是"从对象或数组里把值取出来,顺便起个名":
const note = { title: '读到', tags: ['认知', '写作'] };
const { title, tags } = note;
const [firstTag, secondTag] = tags;
console.log(title); // 读到
console.log(firstTag); // 认知
function renderCard({ title, content }) {
return `${title}:${content}`;
}
最后那个函数参数里的 {} 是参数解构,等价于"传进来一个对象,我只要 title 和 content 两个字段"。它比 function renderCard(note) 更好读,因为调用方一眼能看出需要哪些字段。
模板字符串用反引号,${} 里可以放任何表达式:
const count = 3;
console.log(`共 ${count} 条摘录`);
console.log(`共 ${count * 2} 条(含草稿)`);
它比 '共 ' + count + ' 条' 好在三点:不用数加号、可以换行、嵌表达式不用拆引号。拼 HTML 片段时尤其明显——不过第 5 章会告诉你,拼 HTML 这件事本身要谨慎。
2.4.3 动手:三个数据函数
这一章不碰 DOM。所有代码写在 index.html 的 </body> 前面,包在 <script> 里。
<script>
const STORAGE_KEY = 'dudao.notes.v1';
let notes = [];
function loadNotes() {
const raw = localStorage.getItem(STORAGE_KEY);
if (!raw) return [];
try {
const parsed = JSON.parse(raw);
return Array.isArray(parsed) ? parsed : [];
} catch (err) {
console.warn('本地数据解析失败,按空列表处理', err);
return [];
}
}
function saveNotes() {
localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
}
function splitTags(raw) {
return raw.split(/\s+/).filter(Boolean);
}
function addNote(input) {
const note = {
id: Date.now(),
title: input.title.trim(),
content: input.content.trim(),
sourceUrl: input.sourceUrl.trim(),
tags: splitTags(input.tags),
createdAt: new Date().toISOString(),
};
notes.push(note);
saveNotes();
return note;
}
function listNotes(tag) {
const all = notes.slice();
if (!tag) return all;
return all.filter((note) => note.tags.includes(tag));
}
function render(tag) {
const visible = listNotes(tag);
const html = visible
.map((note) => `<li class="note-card"><h3>${note.title}</h3><p>${note.content}</p></li>`)
.join('');
console.log(`共 ${visible.length} 条,标签:${tag || '全部'}`);
console.log(html);
return html;
}
notes = loadNotes();
addNote({
title: '注意力是稀缺资源',
content: '把注意力当成预算来花,而不是当成免费的空气。',
sourceUrl: '',
tags: '认知 写作',
});
render('认知');
</script>
保存,刷新,打开控制台。你应该看到两行输出:共 1 条,标签:认知 和一段 <li> 字符串。
现在做五个实验,每一个都在验证本章的一个结论。
实验一:验证持久化。 再刷新一次,条数变成 2。因为 addNote 每次都往 localStorage 里追加了一条。清空用:
localStorage.removeItem('dudao.notes.v1');
实验二:验证引用。 在控制台执行:
const list = listNotes('');
list[0].title = '被改过了';
console.log(notes[0].title);
结果是 被改过了。listNotes 里的 notes.slice() 只复制了数组这一层,里面每个元素仍是同一个对象的地址。要真正隔离,得 notes.map((n) => ({ ...n }))。这个知识点第 5 章会保护你:渲染时绝不改数据。
实验三:验证 const 锁的是绑定。 执行 notes.push({}) 能成功,执行 notes = [] 会报 TypeError: Assignment to constant variable.——可 notes 是用 let 声明的,所以现在两句都能过。把声明改成 const notes = [] 再试,push 仍然成功,重新赋值才报错。
实验四:验证闭包。 执行:
const counter = (function () {
let n = 0;
return () => (n += 1);
})();
counter(); counter(); counter(); // 3
外部没有任何办法直接读写 n,只能通过 counter。这就是"私有状态"。
实验五:验证 ===。 执行 '1' === 1 得 false,'1' == 1 得 true,[] === [] 得 false。三个结果解释完,本章的核心就掌握了。
render 现在只是把 HTML 字符串打到控制台,千万不要把它塞进页面——里面的 note.title 是用户输入,拼进 HTML 就给了注入脚本的机会。第 5 章会用 createElement 和 textContent 重写它,那时才真正上屏。
2.4.4 三个坑
坑 1:以为 const 声明的对象不能改
症状:把 const config = { debug: true } 传给函数,函数里改了 config.debug,回来发现真的变了,于是怀疑 const 没生效。
成因:const 保证的是"这个名字不再指向别的对象",不保证"这个对象内部不变"。对象内部的可变性由 Object.freeze() 控制,而它是浅冻结。
修法:需要不可变就显式冻结(Object.freeze(obj)),或者干脆约定"只读不写"——每次修改都产出一个新对象({ ...obj, debug: false })。第 4 章讲 React 时会看到,整个框架都建立在这个约定上。
坑 2:在循环里用 var 捕获索引
症状:给一批按钮绑事件,点击全部打印最后一个索引;或者所有回调拿到的都是循环结束后的值。
成因:var 是函数作用域,整段循环只有一个变量。回调执行时循环早已结束,读到的是终值。
修法:循环计数器用 let,它每轮创建独立的块级绑定。如果非要用 var,就在循环体里套一个立即执行函数把当前值"存进去"——但那是 let 出现之前的迂回写法,现在没有理由再用。
坑 3:把对象方法写成箭头函数,this 变成 undefined
症状:obj.method() 正常,但把方法传给 setTimeout 或事件监听后,里面访问 this.xxx 报 TypeError: Cannot read properties of undefined。
成因:箭头函数没有自己的 this,它捕获的是定义时外层的 this。在对象字面量里定义箭头方法,this 指向的是模块/全局,不是这个对象。
修法:对象方法用 function 或简写方法语法(inc() { ... })。如果非要把方法当回调传出去,用 obj.method.bind(obj) 固定 this,或者把回调改成箭头函数并直接引用 obj。
本章验收
- 刷新页面后条数递增,
localStorage.removeItem后归零 - 能说清
list[0].title = 'x'为什么会改到notes[0] - 能默写
var/let/const的三条差异 - 能写出一个计数器闭包,并解释
count为什么不会被回收 - 能说出循环里
var打印3的完整原因 - 全部代码里没有
==(== null除外),没有var
自测
Q1:const a = { list: [1, 2] }; const b = a; b.list.push(3); 之后 a.list 是什么?为什么?
看答案
是 `[1, 2, 3]`。`b = a` 复制的是地址,`a` 和 `b` 指向同一个对象,所以通过 `b` 改 `list` 就是改 `a` 的 `list`。`const` 只阻止 `b = 另一个对象`,不阻止 `b.list.push()`。如果要隔离,需要 `const b = { ...a, list: [...a.list] }`。Q2:下面这段代码打印什么?把 var 换成 let 呢?
for (var i = 0; i < 2; i += 1) {
setTimeout(() => console.log(i), 0);
}
看答案
用 `var` 打印两次 `2`。整段循环只有一个 `i`,两个回调都在循环结束后才执行,那时 `i` 已经是 2。换成 `let` 打印 `0` 和 `1`,因为 `let` 每一轮创建新的块级绑定,两个箭头函数各自捕获了当轮的 `i`。注意 `setTimeout(..., 0)` 不是"立刻",它要等当前同步代码全部跑完——第 6 章会讲清这个顺序。Q3:typeof null 和 Array.isArray([]) 分别返回什么?为什么不能用 typeof 判断数组?
看答案
`typeof null` 返回 `'object'`,这是语言诞生初期的历史遗留,为了兼容性一直没改。`Array.isArray([])` 返回 `true`。`typeof []` 也返回 `'object'`,因为数组本质是对象,所以 `typeof` 无法区分数组和普通对象。判断数组一律用 `Array.isArray()`;判断 `null` 用 `x === null`。下一步
语言基础齐了,但页面还是死的。下一章把这三个函数接到真界面上:渲染列表、处理提交、用事件委托管理标签过滤。