认识 JavaScript:让页面动起来
它是什么 · 在网页中的位置 · defer / async · 控制台与调试
1995 年,Brendan Eich 用十天时间写出了这门语言的最初版本。 三十年后,它成了世界上被运行次数最多的语言——网页、编辑器、服务器、甚至小程序,都有它的身影。
与 HTML、CSS 最大的不同在于:JavaScript 是一门真正的编程语言。 它拥有变量、类型、条件、循环、函数和对象,可以描述逻辑、处理数据、做出判断。 当网页里出现一个会展开的菜单、一个会变色的按钮、一个不用刷新就能更新内容的列表, 背后几乎都有 JavaScript 在维持秩序。
它到底能做什么
- 操作页面:读取、修改、创建和删除页面上的元素与文字。
- 响应用户:监听点击、输入、滚动、键盘等行为,并作出反应。
- 处理数据:排序、筛选、聚合,把一堆原始数据整理成可读的信息。
- 与服务器通信:在不刷新页面的前提下请求数据,也就是常说的 Ajax / fetch。
- 记住状态:借助
localStorage把用户的偏好留在浏览器里。 - 绘制与动画:用 CSS 变量、Canvas、WebGL 做出更复杂的视觉表达。
// 用变量存下一份数据
const name = "青禾";
let visits = 1;
// 用函数组织一段可复用的逻辑
function greet(who) {
return "你好," + who + ",这是第 " + visits + " 次见面。";
}
console.log(greet(name));
visits = visits + 1;
console.log(greet(name));
这段代码里已经出现了后面几章的主角:const 与 let 声明变量,
function 定义函数,+ 拼接字符串,console.log 把结果输出到控制台。
现在不必全部理解,先感受一件事:代码是按顺序执行的。
在网页中的位置
让 JavaScript 进入页面,常见有三种方式:
| 方式 | 写法 | 适用场景 |
|---|---|---|
| 外部文件 | <script src="app.js"></script> | 绝大多数情况,推荐使用 |
| 内嵌脚本 | <script>...</script> | 极短的初始化代码,或演示页面 |
| 行内事件 | <button onclick="save()"> | 不推荐,逻辑与结构混在一起,难以维护 |
// ① 外部文件(推荐):可缓存、可维护、可复用
// <script src="assets/js/site.js" defer></script>
// ② 内嵌:适合极短的初始化代码
// <script>
// console.log("hello");
// </script>
// ③ 放在 body 末尾:此时 DOM 已经解析完,不需要 defer
// <script src="app.js"></script>
浏览器解析 HTML 时,一旦遇到普通的 <script>,就会停下解析,
先去下载并执行脚本,然后再继续往下读。这就是为什么把脚本放在 <head> 里,
常常拿不到下面的元素——执行时它们还不存在。
defer 与 async:脚本什么时候执行
| 写法 | 下载 | 执行时机 | 执行顺序 |
|---|---|---|---|
<script> | 立即,并阻塞解析 | 下载完立刻执行 | 按出现顺序 |
<script defer> | 与解析并行 | DOM 解析完成后、DOMContentLoaded 之前 | 严格按出现顺序 |
<script async> | 与解析并行 | 下载完立刻执行,可能打断解析 | 谁先下载完谁先执行 |
<script type="module"> | 与解析并行 | 默认相当于 defer | 按模块依赖顺序 |
实践中的选择很简单:需要操作 DOM 的脚本,用 defer;
完全独立、不依赖 DOM 与其它脚本的第三方统计代码,可以用 async。
Cannot read properties of null (reading 'addEventListener'),十有八九是脚本执行得太早,querySelector 什么都没找到。先检查脚本位置,或者加上 defer,再检查选择器有没有写错。
控制台与调试
开发者工具是写 JavaScript 时最该常开的一扇窗。右键页面选择「检查」,或者按
F12,你就能看到它。
- Console:报错信息、
console.log的输出,还能直接输入代码即时求值。 - Sources:给代码打断点,逐行执行,观察每一个变量此刻的值。
- Elements:查看 DOM 结构,右侧能看到作用在元素上的样式。
- Network:看请求是否成功、返回了什么、花了多久。
const user = { name: "林小满", level: 2, tags: ["HTML", "CSS"] };
console.log("普通输出", user);
console.info("提示信息");
console.warn("警告:这里可能有问题");
console.error("错误:接口返回 500");
console.table(user.tags);
console.time("循环 10 万次");
for (let i = 0; i < 100000; i++) {
// 空转,只为计时
}
console.timeEnd("循环 10 万次");
const line = document.querySelector("#line");
line.textContent = "这段文字,是 JavaScript 在页面加载后写进去的。";
const info = document.querySelector("#info");
const rows = [
"浏览器语言:" + navigator.language,
"视口宽度:" + window.innerWidth + " px",
"当前时间:" + new Date().toLocaleTimeString("zh-CN", { hour12: false })
];
rows.forEach(function (text) {
const li = document.createElement("li");
li.textContent = text;
info.appendChild(li);
});
你好,JavaScript
脚本正在运行…
页面没有按预期工作时,先打开 Console。红色的报错通常会直接指出文件名和行号,比盯着代码猜要快得多。
脚本里的 defer 和 async,应该怎么选?
需要操作 DOM、或与其它脚本有先后依赖时,用 defer:它保证 DOM 解析完成后、按顺序执行。完全独立、不关心顺序的脚本(比如统计代码)可以用 async,它下载完就立刻执行,但也因此可能打断页面解析。
变量、数据类型与类型转换
let / const / var · 七种原始类型 · 模板字符串 · typeof · 显式与隐式转换
程序做的第一件事,往往是把一个值放进某个名字里,稍后再取出来。 这个「名字」就是变量,而值有各自的类型。把这两件事弄清楚,后面的一切都会顺很多。
let、const 与 var
现代 JavaScript 里,声明变量主要用 let 和 const。
var 是早期写法,仍有历史代码在用,但新代码不建议再写。
| 关键字 | 能否重新赋值 | 作用域 | 重复声明 | 建议 |
|---|---|---|---|---|
const | 不能 | 块级 | 不允许 | 默认首选,尤其是不会变的值 |
let | 可以 | 块级 | 不允许 | 确实需要改变时才用 |
var | 可以 | 函数级 | 允许 | 旧代码中见到即可,新代码避免 |
let count = 0; // 之后还要改,用 let
count = count + 1;
const PI = 3.14159; // 之后不再改,用 const
// PI = 3; // 这行会直接报错
// const 限制的是「不能换一个值」,不是「内容不能改」
const profile = { name: "青禾" };
profile.name = "林小满"; // 可以,改的是对象内部
console.log(profile.name);
// 块级作用域:花括号外看不到
{
let inside = "只在块内";
console.log(inside);
}
// console.log(inside); // 报错:inside is not defined
七种原始类型
JavaScript 的原始类型有七种。除此之外的值,都是对象(包括数组和函数)。 原始类型的值不可变,赋值时复制的是值本身。
| 类型 | 例子 | 说明 |
|---|---|---|
string | "青禾" | 文本,单引号、双引号、反引号都可以 |
number | 18、3.14 | 整数与小数同属一种类型,另有 NaN 与 Infinity |
boolean | true / false | 只有两个值,用于判断 |
undefined | undefined | 声明了但还没有赋值 |
null | null | 「有意为之的空」,通常由开发者主动赋值 |
symbol | Symbol("id") | 独一无二的值,常用作对象的键 |
bigint | 9007199254740993n | 超出安全整数范围的大整数 |
const text = "青禾"; // string
const age = 18; // number
const isReady = true; // boolean
let nothing; // undefined
const empty = null; // null
const id = Symbol("id"); // symbol
const big = 9007199254740993n; // bigint
console.log(typeof text); // "string"
console.log(typeof age); // "number"
console.log(typeof nothing); // "undefined"
console.log(typeof null); // "object"(历史遗留问题)
console.log(typeof []); // "object"
console.log(Array.isArray([])); // true,判断数组更可靠
这是语言早期实现留下的 bug,因为兼容性一直保留至今。判断「是不是 null」请直接用 value === null;判断数组请用 Array.isArray()。
模板字符串:把变量织进句子里
用反引号包裹的字符串叫模板字符串,它可以换行,也可以用 ${} 直接嵌入表达式。
拼接长句子时,它比一串加号清爽得多。
const name = "小满";
const courses = ["HTML", "CSS", "JS"];
const message = `你好,${name}!
你正在学习 ${courses.length} 门课程:${courses.join("、")}。
预计还需要 ${courses.length * 2} 天。`;
console.log(message);
// 三元与函数调用也能放进去
const score = 86;
console.log(`结果:${score >= 60 ? "通过" : "再练练"}(${score} 分)`);
显式转换与隐式转换
浏览器拿到的表单值永远是字符串。"18" 和 18 看起来一样,
参与运算时却可能得到完全不同的结果。所以类型转换是必须跨过的一道坎。
| 写法 | 结果 | 类型 | 备注 |
|---|---|---|---|
Number("42") | 42 | number | 标准转换 |
Number("42px") | NaN | number | 整串必须合法 |
parseInt("42px", 10) | 42 | number | 从头开始解析,遇到非数字就停 |
String(42) | "42" | string | 转成文本 |
Boolean("") | false | boolean | 空字符串为假 |
Boolean("0") | true | boolean | 非空字符串都是真 |
"5" + 2 | "52" | string | 加号遇到字符串就拼接 |
"5" - 2 | 3 | number | 减号会先把两边转成数字 |
// 显式转换:把意图写在脸上
Number("42"); // 42
Number("42px"); // NaN
parseInt("42px", 10); // 42
String(42); // "42"
Boolean(0); // false
Boolean("0"); // true(非空字符串)
// 隐式转换:语言自动做的,容易出错
console.log("5" + 2); // "52"
console.log("5" - 2); // 3
console.log("5" * "2"); // 10
console.log([] + {}); // "[object Object]"
// 判断 NaN 不能用 ===
console.log(NaN === NaN); // false
console.log(Number.isNaN(NaN)); // true
const rows = document.querySelector("#rows");
function show(expression, value) {
const row = document.createElement("div");
row.className = "row";
const code = document.createElement("code");
code.textContent = expression;
const result = document.createElement("span");
result.textContent = String(value);
const type = document.createElement("em");
type.textContent = typeof value;
row.append(code, result, type);
rows.appendChild(row);
}
show('Number("42")', Number("42"));
show('Number("42px")', Number("42px"));
show('parseInt("42px", 10)', parseInt("42px", 10));
show('"5" + 2', "5" + 2);
show('"5" - 2', "5" - 2);
show('Boolean("0")', Boolean("0"));
show('Boolean("")', Boolean(""));
show('null + 1', null + 1);
类型转换实验室
同一份数据,换一种写法,结果就完全不同。
== 会先做隐式类型转换再比较,0 == ""、[] == false 都成立,很容易埋下难以发现的 bug。=== 同时比较类型与值,行为可预测。只有判断 value == null(同时覆盖 null 与 undefined)时,可以谨慎使用双等号。
"5" + 2 和 "5" - 2 的结果分别是什么?
"5" + 2 得到字符串 "52":加号在遇到字符串时执行拼接。"5" - 2 得到数字 3:减号没有字符串语义,会把两边都转成数字再相减。正因为加号有这种歧义,处理用户输入时最好先 Number() 一下。
运算符与表达式
算术 · 赋值 · === · 逻辑短路 · ?? · ?. · 三元 · 优先级
运算符是句子的动词。同样是「加」,对数字是求和,对字符串是拼接;
同样是「或者」,|| 和 ?? 的判断条件却不一样。
这一章把常用的符号一次讲清,顺便拆掉几个常见的坑。
算术运算符与赋值
| 运算符 | 含义 | 例子 | 结果 |
|---|---|---|---|
+ - * / | 加减乘除 | 7 / 2 | 3.5 |
% | 取余 | 17 % 5 | 2 |
** | 幂运算 | 2 ** 10 | 1024 |
+= -= *= /= | 运算后赋值 | x += 3 | 等同于 x = x + 3 |
++ -- | 自增 / 自减 | n++ | 先返回再加一 |
let price = 128;
price += 12; // 140
price -= 20; // 120
price *= 2; // 240
price /= 3; // 80
console.log(17 % 5); // 2
console.log(2 ** 10); // 1024
let n = 5;
console.log(n++); // 5(先返回,再加)
console.log(n); // 6
console.log(++n); // 7(先加,再返回)
// 浮点数的取余也有精度问题
console.log(5.5 % 2); // 1.5
比较运算符:请优先使用 ===
=== 同时比较类型与值,== 会先做隐式转换。
另外要记住:对象之间的比较,比的是是不是同一个引用,而不是内容是否相同。
console.log(1 === 1); // true
console.log(1 === "1"); // false(类型不同)
console.log(1 == "1"); // true(隐式转换,不推荐)
console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); // true
const list = [1, 2];
const copy = list; // 指向同一个数组
console.log(list === copy); // true
console.log([1, 2] === [1, 2]); // false(两个不同的对象)
// 字符串比较按 Unicode 编码逐位进行
console.log("apple" < "banana"); // true
console.log("10" < "9"); // true(按字符比较)
想判断两个数组/对象的内容是否相同,=== 帮不了你。简单场景可以比较 JSON.stringify(a) === JSON.stringify(b)(要求键顺序一致),复杂场景需要自己写逐层比较的函数。
逻辑短路、?? 与 ?.
&& 和 || 会「短路」:左边一旦能决定结果,右边就不再执行。
这既是性能优化,也是常用的写法技巧。
| 写法 | 返回什么 | 典型用途 |
|---|---|---|
a && b | a 为假返回 a,否则返回 b | 条件成立才继续 |
a || b | a 为假返回 b,否则返回 a | 兜底默认值 |
a ?? b | a 是 null/undefined 时返回 b | 保留 0 与空字符串的默认值 |
obj?.prop | obj 为空时返回 undefined | 安全访问可能不存在的属性 |
const user = { name: "小满", address: { city: "杭州" } };
// ||:左边为假就取右边
const nickname = user.nickname || "匿名用户";
console.log(nickname); // "匿名用户"
// ?? 只在 null / undefined 时兜底
const score = 0;
console.log(score || 60); // 60(不是我们想要的)
console.log(score ?? 60); // 0
// ?. 安全访问:中间断了就返回 undefined,不会抛错
console.log(user.address?.city); // "杭州"
console.log(user.contact?.email); // undefined
// console.log(user.contact.email); // 这里会报错
// 配合调用:方法存在才执行
user.sayHi?.();
三元运算符与优先级
三元表达式是 条件 ? 值A : 值B,适合「二选一」的小判断。
超过两层嵌套就该改用 if 或查表,否则读起来会非常吃力。
| 优先级(从高到低) | 运算符 |
|---|---|
| 1 | 分组 ( )、成员访问 .、可选链 ?. |
| 2 | 一元 !、typeof、++ |
| 3 | 算术 * / %,然后 + - |
| 4 | 比较 < > <= >=,然后 === |
| 5 | 逻辑 &&,然后 ||、?? |
| 6 | 三元 ? : |
| 7 | 赋值 = += |
const age = 17;
const label = age >= 18 ? "成年" : "未成年";
console.log(label);
// 两层还可以接受,再多就换成 if
const level = age < 12 ? "儿童" : age < 18 ? "少年" : "成年";
console.log(level);
// 优先级陷阱:先算加法,再做字符串拼接
console.log("结果:" + 1 + 2); // "结果:12"
console.log("结果:" + (1 + 2)); // "结果:3"
// 不确定就加括号,括号永远是最划算的可读性投资
console.log((1 + 2) * 3);
const price = 128;
const count = 3;
const level = 2;
const subtotal = price * count;
const rate = level >= 2 ? 0.85 : level === 1 ? 0.95 : 1;
const discount = subtotal * (1 - rate);
const shipping = subtotal - discount >= 300 ? 0 : 12;
const user = { coupon: null };
const coupon = user.coupon ?? 0;
const total = subtotal - discount + shipping - coupon;
const lines = [
["商品小计", "¥" + subtotal.toFixed(2)],
["会员折扣", "-¥" + discount.toFixed(2)],
["运费", shipping === 0 ? "包邮" : "¥" + shipping.toFixed(2)],
["优惠券", coupon === 0 ? "暂无" : "-¥" + coupon.toFixed(2)]
];
const out = document.querySelector("#lines");
lines.forEach(function (line) {
const li = document.createElement("li");
const name = document.createElement("span");
name.textContent = line[0];
const value = document.createElement("b");
value.textContent = line[1];
li.append(name, value);
out.appendChild(li);
});
document.querySelector("#total").textContent = "¥" + total.toFixed(2);
购物小票
应付 —
if (x = 5) 是赋值,不是比较,它会静默地把 5 写进 x,并永远为真。真正想比较请写 if (x === 5)。这类错误不报错,只是结果永远不对,最难排查。
0 || 60 与 0 ?? 60 有什么区别?
0 || 60 返回 60,因为 || 把 0 当成假值;0 ?? 60 返回 0,因为 ?? 只在左侧是 null 或 undefined 时才兜底。分数、数量、价格这类允许为 0 的数据,应该用 ??。
流程控制
if / else · switch · for · while · for...of / for...in · break / continue
程序真正开始「思考」,是从分支和循环开始的。 分支决定走哪条路,循环决定把同一件事做多少遍。这两件事组合起来,就能描述绝大多数业务逻辑。
if / else 与真假值
if 后面的括号里可以是任何值,JavaScript 会自动把它转成布尔值。
记住下面这几个 falsy 值,其余都是 truthy:
false、0、-0、0n、""、
null、undefined、NaN。
const score = 86;
if (score >= 90) {
console.log("优秀");
} else if (score >= 75) {
console.log("良好");
} else if (score >= 60) {
console.log("及格");
} else {
console.log("需要再练一练");
}
// 空数组、空对象都是 truthy
if ([]) console.log("空数组是 truthy");
if ({}) console.log("空对象是 truthy");
// 判断数组是否为空要看长度
const list = [];
if (list.length === 0) {
console.log("列表是空的");
}
// 提前返回,能让嵌套更浅
function checkAge(age) {
if (typeof age !== "number") return "请输入数字";
if (age < 0) return "年龄不能为负";
return age >= 18 ? "可以注册" : "未成年";
}
console.log(checkAge(20));
switch:一串等值判断
当一个值需要和多组固定选项比较时,switch 比一长串 else if 更整齐。
注意每个 case 后面通常要写 break,否则会继续往下执行。
const day = "周三";
switch (day) {
case "周一":
case "周二":
console.log("刚开始,慢慢进入状态");
break;
case "周三":
case "周四":
console.log("一周的正中间");
break;
case "周五":
console.log("收个尾,准备休息");
break;
default:
console.log("周末,读书或散步");
}
// 多个 case 共用一段逻辑,就是「有意的穿透」
// switch 用的是严格比较 ===,所以 "1" 和 1 不会匹配
for 与 while
知道循环次数时用 for;只知道「满足条件就继续」时用 while;
需要至少执行一次时用 do...while。无论哪一种,都要确保条件最终会变成假,否则就是死循环。
// 经典 for:适合知道次数
for (let i = 1; i <= 3; i++) {
console.log("第 " + i + " 次");
}
// while:只看条件
let n = 1;
while (n < 100) {
n *= 2;
}
console.log(n); // 128
// do...while:至少执行一次
let input;
do {
input = "先做一次,再判断";
} while (false);
console.log(input);
for...of、for...in 与 break / continue
| 写法 | 遍历什么 | 适合 |
|---|---|---|
for (let i = 0; i < arr.length; i++) | 下标 | 需要索引,或要倒序、跳步 |
for...of | 可迭代对象的值 | 数组、字符串、Map、Set,最常用 |
for...in | 对象的可枚举键名 | 遍历普通对象,不要用于数组 |
forEach | 数组每一项 | 只做遍历,不能中途 break |
const fruits = ["苹果", "梨", "桃"];
for (const fruit of fruits) { // 取值
console.log(fruit);
}
for (const index in fruits) { // 取键名(字符串)
console.log(index); // "0" "1" "2"
}
for (let i = 0; i < 10; i++) {
if (i % 2 === 0) continue; // 跳过偶数
if (i > 7) break; // 到 9 就停
console.log(i); // 1 3 5 7
}
// 对象用 for...in 或 Object.entries
const book = { title: "前端手账", pages: 320 };
for (const key in book) {
console.log(key, book[key]);
}
const grid = document.querySelector("#grid");
for (let i = 1; i <= 24; i++) {
const cell = document.createElement("div");
cell.className = "cell";
if (i % 15 === 0) {
cell.textContent = "FizzBuzz";
cell.classList.add("both");
} else if (i % 3 === 0) {
cell.textContent = "Fizz";
cell.classList.add("hit");
} else if (i % 5 === 0) {
cell.textContent = "Buzz";
cell.classList.add("hit");
} else {
cell.textContent = i;
}
grid.appendChild(cell);
}
FizzBuzz · 1 → 24
3 的倍数说 Fizz,5 的倍数说 Buzz,同时是则 FizzBuzz。
for...in 取的是键名,而且会沿原型链找到可枚举属性。数组上用它,不仅拿到的是字符串 "0"、"1",还可能遍历到额外属性。数组请用 for...of 或 forEach。
什么时候用 for...of,什么时候用 for...in?
遍历数组、字符串、Set、Map 这类「一组值」时,用 for...of,它直接给你每一项。遍历普通对象的键名时,用 for...in(更推荐 Object.keys() / Object.entries())。一句话:数组取值用 of,对象取键用 in。
函数与作用域
声明与表达式 · 箭头函数 · 参数 · 作用域链 · 闭包 · 递归
函数是把一段逻辑打包起来,并给它起个名字。它是 JavaScript 里最重要的零件: 回调、模块、组件、事件处理,最终都落在函数上。而理解函数,绕不开作用域与闭包。
函数声明与函数表达式
| 写法 | 示例 | 能否提前调用 |
|---|---|---|
| 函数声明 | function sum(a, b) {} | 可以,声明会被提升 |
| 函数表达式 | const sum = function (a, b) {} | 不可以,变量赋值之后才存在 |
| 箭头函数 | const sum = (a, b) => a + b | 不可以,且没有自己的 this |
// 函数声明:会被提升,可以在定义之前调用
console.log(sum(2, 3)); // 5
function sum(a, b) {
return a + b;
}
// 函数表达式:赋值给变量,之后才能用
const multiply = function (a, b) {
return a * b;
};
// 箭头函数:更短,适合小逻辑
const divide = (a, b) => a / b;
const square = n => n * n;
console.log(multiply(2, 3)); // 6
console.log(divide(6, 3)); // 2
console.log(square(4)); // 16
箭头函数的脾气
箭头函数不只是「写法更短」。它没有自己的 this,
会沿用外层作用域的 this;也没有 arguments,
不能当作构造函数使用。所以在对象的方法、需要动态 this 的场景里,要谨慎使用。
const timer = {
seconds: 0,
// 普通函数:this 指向调用它的对象
startNormal: function () {
setTimeout(function () {
// 这里的 this 已经不是 timer 了
console.log("普通函数", this.seconds);
}, 0);
},
// 箭头函数:this 继承自外层,也就是 timer
startArrow: function () {
setTimeout(() => {
this.seconds += 1;
console.log("箭头函数", this.seconds);
}, 0);
}
};
timer.startNormal();
timer.startArrow();
参数默认值、rest 与返回值
function greet(name = "朋友", greeting = "你好") {
return `${greeting},${name}!`;
}
// rest:把剩下的参数收成一个数组
function total(...numbers) {
return numbers.reduce((sum, n) => sum + n, 0);
}
console.log(greet());
console.log(greet("小满", "早上好"));
console.log(total(1, 2, 3, 4)); // 10
// 没有 return 的函数,返回 undefined
function noop() {}
console.log(noop()); // undefined
// 可以返回对象,也可以返回另一个函数
function makeUser(name) {
return { name: name, createdAt: Date.now() };
}
console.log(makeUser("青禾"));
作用域与作用域链
变量不是在任何地方都能访问。函数内部可以读外部,外部读不到内部; 查找变量时,会从当前作用域开始,一层层往外找,直到全局,这条路径就是作用域链。
const globalName = "全局";
function outer() {
const outerName = "外层";
function inner() {
const innerName = "内层";
console.log(globalName, outerName, innerName); // 都能访问
}
inner();
// console.log(innerName); // 报错:内层变量外面看不到
}
outer();
// 同级块之间也彼此隔离
{
const a = 1;
console.log(a);
}
// console.log(a); // 报错
闭包:函数记住了它出生时的环境
当内层函数被返回到外部,它依然能访问当初定义它的那个作用域——这就是闭包。 闭包常用于封装私有状态,比如一个只能通过方法修改的计数器。
function createCounter() {
let count = 0; // 外部无法直接访问
return {
inc: function () {
count += 1;
return count;
},
get: function () {
return count;
}
};
}
const counter = createCounter();
console.log(counter.inc()); // 1
console.log(counter.inc()); // 2
console.log(counter.get()); // 2
// 每调用一次,就得到一份独立的状态
const another = createCounter();
console.log(another.inc()); // 1
递归则是函数调用自己。写递归必须有两样东西:终止条件, 以及每次都在向终止条件靠近,否则会栈溢出。
function factorial(n) {
if (n <= 1) return 1; // 终止条件
return n * factorial(n - 1); // 向终止条件靠近
}
console.log(factorial(5)); // 120
// 递归处理树形结构很自然
function sumTree(node) {
let total = node.value;
(node.children || []).forEach(function (child) {
total += sumTree(child);
});
return total;
}
console.log(sumTree({ value: 1, children: [{ value: 2 }, { value: 3 }] })); // 6
function createCounter() {
let count = 0;
return {
inc: function () { count += 1; return count; },
reset: function () { count = 0; return count; },
get: function () { return count; }
};
}
const counter = createCounter();
const num = document.querySelector("#num");
const hint = document.querySelector("#hint");
function paint(value) {
num.textContent = value;
hint.textContent = "当前计数 " + value + ",但外部没有变量指向 count。";
}
document.querySelector("#inc").addEventListener("click", function () {
paint(counter.inc());
});
document.querySelector("#reset").addEventListener("click", function () {
paint(counter.reset());
});
paint(counter.get());
闭包计数器
0
count 藏在 createCounter 内部,外部拿不到。
setTimeout、forEach、addEventListener 的回调里,如果要用外层的 this,优先写箭头函数,可以省掉 const self = this 这类旧写法。
闭包为什么能在函数执行完之后,继续访问内部变量?
因为内层函数被返回或保存到了外部,它仍然持有对定义时作用域的引用。只要这个函数还活着,它引用的变量就不会被回收。所以 count 一直存在,只是外部没法直接读写,只能通过返回的方法操作。
数组与对象
map / filter / find / reduce / sort · 解构 · 展开 · Object 遍历 · JSON
真实的数据几乎都长成数组与对象的样子:一页商品、一条用户信息、一组课程。 能熟练地筛选、变换与汇总它们,才算真正开始用 JavaScript 解决问题。
数组的五个高频方法
| 方法 | 做什么 | 返回 | 是否改原数组 |
|---|---|---|---|
map | 把每项变换成新值 | 新数组(长度不变) | 否 |
filter | 留下符合条件的项 | 新数组(可能更短) | 否 |
find | 找到第一个符合条件的项 | 那一项,或 undefined | 否 |
reduce | 把整个数组折叠成一个值 | 任意值 | 否 |
sort | 排序 | 原数组的引用 | 是 |
const scores = [82, 95, 67, 88, 91];
const doubled = scores.map(n => n * 2);
const passed = scores.filter(n => n >= 80);
const firstTop = scores.find(n => n >= 90);
const total = scores.reduce((sum, n) => sum + n, 0);
const sorted = [...scores].sort((a, b) => b - a);
console.log(doubled); // [164, 190, 134, 176, 182]
console.log(passed); // [82, 95, 88, 91]
console.log(firstTop); // 95
console.log(total); // 423
console.log((total / scores.length).toFixed(1)); // "84.6"
console.log(sorted); // [95, 91, 88, 82, 67]
console.log(scores); // 原数组没有被 sort 改变
// reduce 还能做分组统计
const words = ["js", "css", "js", "html", "css", "js"];
const tally = words.reduce(function (map, word) {
map[word] = (map[word] || 0) + 1;
return map;
}, {});
console.log(tally); // { js: 3, css: 2, html: 1 }
第一,sort 会直接修改原数组,想保留原数据请先 [...arr] 复制。第二,不传比较函数时,它会按字符串排序,[10, 2, 33].sort() 会得到 [10, 2, 33]("10" 排在 "2" 前面)。数字排序务必写 (a, b) => a - b。
解构与展开
解构是「按形状取值」,展开是「把里面的东西摊开」。 它们让取值和合并的代码短了一大截,也更接近数据的本来结构。
const [first, second, ...rest] = [1, 2, 3, 4, 5];
console.log(first, second, rest); // 1 2 [3, 4, 5]
const user = { name: "小满", age: 18, city: "杭州" };
const { name, city: hometown } = user; // 可以顺便改名
console.log(name, hometown);
// 展开:浅拷贝并覆盖部分字段
const updated = { ...user, age: 19, tag: "学习者" };
console.log(updated);
// 合并数组
const merged = [...[1, 2], ...[3, 4]];
console.log(merged); // [1, 2, 3, 4]
// 参数直接用解构
function card({ name, age }) {
return `${name} · ${age} 岁`;
}
console.log(card(user));
// 注意:展开只是浅拷贝,嵌套对象仍然共享引用
const profile = { name: "小满", address: { city: "杭州" } };
const shallow = { ...profile };
shallow.address.city = "苏州";
console.log(profile.address.city); // "苏州"
对象的遍历
const book = { title: "前端手账", pages: 320, author: "青禾" };
Object.keys(book).forEach(function (key) {
console.log(key, book[key]);
});
Object.values(book).forEach(function (value) {
console.log(value);
});
for (const [key, value] of Object.entries(book)) {
console.log(`${key} → ${value}`);
}
console.log("pages" in book); // true
console.log(book.hasOwnProperty("title")); // true
// 删除与新增
delete book.pages;
book.year = 2026;
console.log(book);
JSON:和外界交换数据的通用格式
JSON.stringify 把对象变成字符串,JSON.parse 把字符串还原成对象。
发请求、写本地存储,都靠这一对方法。
const data = { name: "青禾", tags: ["HTML", "JS"] };
const text = JSON.stringify(data);
console.log(text); // {"name":"青禾","tags":["HTML","JS"]}
const parsed = JSON.parse(text);
console.log(parsed.tags[0]); // "HTML"
// 第三个参数是缩进,方便阅读
console.log(JSON.stringify(data, null, 2));
// 函数、undefined、Symbol 会被忽略
console.log(JSON.stringify({ a: 1, b: undefined, c: function () {} }));
// {"a":1}
// 解析失败会抛错,来自外部的字符串要 try / catch
try {
JSON.parse("{ 不是合法的 JSON }");
} catch (error) {
console.warn("解析失败:", error.message);
}
const lessons = [
{ title: "HTML 语义化", minutes: 45, done: true },
{ title: "CSS 布局", minutes: 60, done: true },
{ title: "JavaScript 基础", minutes: 90, done: false },
{ title: "DOM 操作", minutes: 50, done: false },
{ title: "异步与 Promise", minutes: 70, done: false }
];
const doneList = lessons.filter(function (item) {
return item.done;
});
const totalMinutes = lessons.reduce(function (sum, item) {
return sum + item.minutes;
}, 0);
const sorted = lessons.slice().sort(function (a, b) {
return b.minutes - a.minutes;
});
const stats = document.querySelector("#stats");
[
["课程数", lessons.length],
["已完成", doneList.length],
["总时长", totalMinutes + " 分钟"],
["平均", (totalMinutes / lessons.length).toFixed(1) + " 分钟"]
].forEach(function (pair) {
const box = document.createElement("div");
box.className = "stat";
const label = document.createElement("span");
label.textContent = pair[0];
const value = document.createElement("b");
value.textContent = pair[1];
box.append(label, value);
stats.appendChild(box);
});
const list = document.querySelector("#list");
sorted.forEach(function (item) {
const li = document.createElement("li");
li.textContent = item.title;
const time = document.createElement("em");
time.textContent = item.minutes + " min";
li.appendChild(time);
if (item.done) li.classList.add("done");
list.appendChild(li);
});
整理我的学习清单
map 和 forEach 看起来都在遍历,区别是什么?
map 会把回调的返回值收集成一个新数组,长度与原数组一致,适合「变换数据」;forEach 只负责遍历,返回值是 undefined,适合「做一件事」,而且不能用 break 提前结束。需要新数组就选 map。
字符串、数字与 Math
常用字符串方法 · toFixed · Math · 随机数 · 数字精度
页面上看到的一切,最终都可以归结为文字与数字。
字符串负责表达,数字负责计算,而 Math 提供了现成的工具箱。
这一章不讲新概念,只把最常用的几件工具摆到手边。
常用字符串方法
| 方法 | 作用 | 例子 |
|---|---|---|
trim() | 去掉两端空白 | " hi ".trim() → "hi" |
includes() | 是否包含某段文字 | "JavaScript".includes("Script") |
startsWith() / endsWith() | 是否以某段开头 / 结尾 | 判断文件后缀 |
slice(start, end) | 截取一段(不含 end) | "青禾手账".slice(0, 2) |
split(sep) | 按分隔符切成数组 | "a-b-c".split("-") |
replace() / replaceAll() | 替换第一处 / 全部 | 替换占位符 |
padStart() / padEnd() | 补足长度 | 时间补零 |
toUpperCase() / toLowerCase() | 转大小写 | 统一比较 |
repeat(n) | 重复 n 次 | 生成分隔线 |
const title = " JavaScript 手记 ";
console.log(title.trim()); // "JavaScript 手记"
console.log(title.trim().slice(0, 10)); // "JavaScript"
console.log("a-b-c".split("-")); // ["a", "b", "c"]
console.log("你好,世界".replace("世界", "青禾"));
console.log("ha".repeat(3)); // "hahaha"
console.log("7".padStart(2, "0")); // "07"
console.log("JavaScript".includes("Script")); // true
// 链式调用:把多个小操作串起来
const slug = " Hello World "
.trim()
.toLowerCase()
.replaceAll(" ", "-");
console.log(slug); // "hello-world"
// 字符串本身不可变,所有方法都返回新值
console.log(title); // 仍是带空格的原字符串
用户输入的大小写、前后空格往往不可控。比较之前先 trim().toLowerCase(),可以避免大量「明明一样却不相等」的问题。
数字与 toFixed
toFixed(n) 用来保留小数位,但它返回的是字符串,
如果要继续计算,得再用 Number() 转回来。
const price = 19.9;
console.log(price.toFixed(2)); // "19.90"(字符串)
console.log(typeof price.toFixed(2)); // "string"
console.log(Number(price.toFixed(2))); // 19.9
console.log(Number.parseInt("42px", 10)); // 42
console.log(Number.parseFloat("3.14元")); // 3.14
console.log(Number.isInteger(5)); // true
console.log(Number.isNaN(NaN)); // true
// 金额显示:千分位
const amount = 1234567.891;
console.log(amount.toLocaleString("zh-CN", { minimumFractionDigits: 2 }));
Math 与随机数
console.log(Math.round(4.5)); // 5
console.log(Math.floor(4.9)); // 4
console.log(Math.ceil(4.1)); // 5
console.log(Math.abs(-7)); // 7
console.log(Math.max(3, 9, 2)); // 9
console.log(Math.min(3, 9, 2)); // 2
console.log(Math.PI.toFixed(4)); // "3.1416"
// 取 [min, max] 之间的整数(含两端)
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(randomInt(1, 10));
// 从数组里随机取一项
function pick(list) {
return list[Math.floor(Math.random() * list.length)];
}
console.log(pick(["青禾", "小满", "林间"]));
关于数字精度的一句提醒
JavaScript 的数字是双精度浮点数,有些小数无法被精确表示,于是出现了
0.1 + 0.2 !== 0.3 这种看似荒谬的结果。这不是 bug,而是二进制表示的固有局限。
console.log(0.1 + 0.2); // 0.30000000000000004
console.log((0.1 + 0.2).toFixed(2)); // "0.30"
// 比较浮点数:看差值是否足够小
const a = 0.1 + 0.2;
const b = 0.3;
console.log(Math.abs(a - b) < 1e-9); // true
// 金额建议用「分」为单位的整数计算
const cents = 1990 + 2990;
console.log((cents / 100).toFixed(2)); // "49.80"
// 大整数超出安全范围会丢精度
console.log(9007199254740992 + 1); // 9007199254740992
console.log(9007199254740993n + 1n); // 9007199254740994n
const pool = [
"用 map 把一组数字平方",
"写一个防抖函数,并在输入框里试一次",
"用 while 倒序打印 10 到 1",
"把一个对象用 Object.entries 遍历一遍",
"给一张卡片加上 hover 时的 classList 切换"
];
const task = document.querySelector("#task");
const meta = document.querySelector("#meta");
function pick() {
const index = Math.floor(Math.random() * pool.length);
const lucky = (Math.random() * 100).toFixed(1);
task.textContent = pool[index];
meta.textContent = "签号 " + (index + 1) + " / " + pool.length +
" · 心动指数 " + lucky;
}
document.querySelector("#draw").addEventListener("click", pick);
pick();
今天练点什么
点击下面的按钮,抽一张练习签。
为什么 0.1 + 0.2 === 0.3 是 false?
因为 0.1 和 0.2 在二进制浮点数中无法被精确表示,相加后得到一个极接近 0.3 但并不完全相等的值(0.30000000000000004)。判断时应该比较差值:Math.abs(a - b) < 1e-9,或者用 toFixed 先统一精度。
DOM 操作:让页面听从指令
选取元素 · 内容与样式 · classList · 节点增删 · 表单取值
浏览器把 HTML 解析成一棵树,树上的每个节点都是一个对象。 DOM 操作的本质,就是找到某个节点,然后读它、改它、造一个新的、或者把它删掉。
选取元素
| 方法 | 返回 | 说明 |
|---|---|---|
querySelector(css) | 第一个匹配的元素或 null | 最常用,支持任意 CSS 选择器 |
querySelectorAll(css) | NodeList(静态集合) | 需要用 forEach 或转数组 |
getElementById(id) | 元素或 null | 速度略快,但只能按 id |
closest(css) | 最近的祖先(含自身) | 事件委托时非常好用 |
const title = document.querySelector("h1");
const allLinks = document.querySelectorAll(".nav a"); // NodeList
const box = document.querySelector("#app");
console.log(title.textContent);
console.log(allLinks.length);
// NodeList 转成数组,才能用 map / filter
const linkArray = Array.from(allLinks);
linkArray.forEach(function (a) {
console.log(a.href);
});
// 拿到元素后,可以继续往下找
const firstItem = document.querySelector(".list");
console.log(firstItem?.querySelector("li"));
// 找不到时返回 null,直接访问属性会报错
const missing = document.querySelector(".not-exist");
console.log(missing); // null
console.log(missing?.textContent); // undefined,不报错
读写内容、样式与属性
textContent 只认文本,innerHTML 会把字符串当 HTML 解析。
前者安全,后者方便但危险——只要内容来自用户,就该用前者。
const note = document.querySelector(".note");
note.textContent = "纯文本,尖括号会被当成文字显示";
note.classList.add("is-active");
note.classList.toggle("hidden");
note.classList.remove("is-active");
// 行内样式:属性名用驼峰
note.style.color = "#4b6a5a";
note.style.backgroundColor = "#f4f8f5";
note.style.setProperty("--accent", "#c58a6f");
// 普通属性与 data-* 属性
note.setAttribute("aria-label", "一条便签");
note.dataset.state = "done"; // 对应 data-state="done"
console.log(note.dataset.state); // "done"
// 读取元素的实际尺寸与位置
const rect = note.getBoundingClientRect();
console.log(rect.width, rect.height);
把用户输入直接拼进 innerHTML,就等于允许对方在你的页面里插入任意标签甚至脚本。展示用户内容请用 textContent;确实需要渲染一段 HTML 时,先确保它来自可信来源。
创建、插入与删除节点
const list = document.querySelector("#list");
const li = document.createElement("li");
li.className = "item";
li.textContent = "新的一条";
list.appendChild(li); // 放到末尾
list.prepend(li); // 放到开头(同一个节点会被移动)
li.remove(); // 删除自己
// 在某个兄弟节点前后插入
const anchor = list.firstElementChild;
list.insertBefore(li, anchor); // 插到 anchor 前面
anchor.after(li); // 插到 anchor 后面
anchor.before(li);
// 批量写入:一次性赋值比循环 append 更快
list.innerHTML = "<li>一</li><li>二</li>";
// 清空一个容器
list.innerHTML = "";
读取表单的值
输入框用 .value,复选框和单选用 .checked,
下拉框同样用 .value。提交表单时记得先 preventDefault(),
否则页面会刷新,脚本里的状态全部丢失。
const form = document.querySelector("#todo-form");
const input = document.querySelector("#todo-input");
form.addEventListener("submit", function (event) {
event.preventDefault(); // 阻止页面刷新
const value = input.value.trim();
if (!value) return; // 空内容不处理
console.log("提交:", value);
input.value = ""; // 清空输入框
input.focus(); // 光标放回去
});
// 复选框与下拉框
const agree = document.querySelector("#agree");
console.log(agree.checked);
const city = document.querySelector("#city");
console.log(city.value);
// 实时监听输入
input.addEventListener("input", function (event) {
console.log("正在输入:", event.target.value);
});
const form = document.querySelector("#form");
const input = document.querySelector("#input");
const wall = document.querySelector("#wall");
const empty = document.querySelector("#empty");
function updateEmpty() {
const hasNote = wall.querySelector(".note") !== null;
empty.style.display = hasNote ? "none" : "block";
}
form.addEventListener("submit", function (event) {
event.preventDefault();
const text = input.value.trim();
if (!text) return;
const note = document.createElement("div");
note.className = "note";
note.textContent = text;
const del = document.createElement("button");
del.type = "button";
del.textContent = "×";
del.setAttribute("aria-label", "删除便签");
del.addEventListener("click", function () {
note.remove();
updateEmpty();
});
note.appendChild(del);
wall.appendChild(note);
input.value = "";
input.focus();
updateEmpty();
});
便签墙
墙上还是空的。
textContent 和 innerHTML 应该怎么选?
只展示文字时永远用 textContent:它把内容当纯文本,尖括号不会变成标签,天然避免了 XSS。只有当你确实想渲染一段可信的 HTML(比如自带的模板字符串)时才用 innerHTML。用户输入绝不能直接交给它。
事件与交互
addEventListener · 事件对象 · 冒泡与捕获 · 事件委托 · 节流防抖
页面从「静态」变成「可交互」的那一刻,就是事件发生的瞬间。 点击、输入、提交、滚动——用户做了什么,浏览器就发出一个事件, 我们只需要提前说清楚:发生这件事时,要执行哪段代码。
addEventListener:把函数交给事件
现代写法统一使用 addEventListener(类型, 处理函数, 选项)。
相比 onclick = ...,它不会覆盖之前的监听,还能注册多个、可以移除。
const btn = document.querySelector("#save");
function handleSave(event) {
console.log("点击了", event.target);
}
btn.addEventListener("click", handleSave);
// 只触发一次
btn.addEventListener("click", function () {
console.log("这句只会出现一次");
}, { once: true });
// 移除时必须传同一个函数引用,匿名函数是移除不掉的
btn.removeEventListener("click", handleSave);
// 旧写法:同一个属性只能挂一个处理函数
// btn.onclick = handleSave;
事件对象:到底发生了什么
| 属性 / 方法 | 含义 |
|---|---|
event.type | 事件类型,如 "click" |
event.target | 真正被操作的元素(可能是子元素) |
event.currentTarget | 绑定监听器的那个元素 |
event.preventDefault() | 阻止默认行为,如表单提交、链接跳转 |
event.stopPropagation() | 阻止事件继续冒泡 |
event.clientX / clientY | 鼠标相对视口的位置 |
event.key | 按下的键,如 "Enter" |
const box = document.querySelector("#box");
box.addEventListener("click", function (event) {
console.log(event.type); // "click"
console.log(event.target); // 真正点到的元素
console.log(event.currentTarget); // 绑定监听的 box
console.log(event.clientX, event.clientY);
// 阻止默认行为:链接不跳转、表单不提交
event.preventDefault();
// 阻止继续冒泡到父元素
event.stopPropagation();
});
// 键盘:判断具体按了哪个键
document.addEventListener("keydown", function (event) {
if (event.key === "Escape") {
console.log("按下了 Esc");
}
});
冒泡、捕获与事件委托
事件发生时,会先从最外层往里「捕获」,到达目标后再从里往外「冒泡」。 默认的监听都在冒泡阶段触发。正因为会冒泡,我们才能在父元素上统一处理子元素的事件,这叫事件委托。
const list = document.querySelector("#list");
// 不给每个 li 绑定,而是交给父元素统一处理
list.addEventListener("click", function (event) {
const item = event.target.closest("li");
// 点在列表空隙里,closest 可能是 null
if (!item || !list.contains(item)) return;
item.classList.toggle("done");
console.log("操作了:", item.textContent.trim());
});
// 捕获阶段(第三个参数为 true):从外往里
list.addEventListener("click", function () {
console.log("捕获阶段");
}, true);
// 动态新增的 li 不需要重新绑定,自动就能响应
const li = document.createElement("li");
li.textContent = "新任务";
list.appendChild(li);
1. 只绑定一个监听器,内存更省;
2. 后插入的子元素自动生效,不必重复绑定;
3. 统一在一处处理逻辑,代码更好维护。
表单、键盘、鼠标与性能
| 事件 | 触发时机 | 常用场景 |
|---|---|---|
click | 点击元素 | 按钮、卡片、菜单 |
input | 输入框内容每次变化 | 实时搜索、字数统计 |
change | 值改变且失去焦点 | 下拉框、复选框 |
submit | 表单提交 | 校验后阻止默认提交 |
keydown | 按下键盘 | 快捷键、回车发送 |
mouseenter / mouseleave | 进入 / 离开元素 | 悬停效果 |
scroll | 滚动 | 吸顶导航、懒加载 |
input 与 scroll 这类事件触发得非常频繁。
如果每次都执行较重的逻辑,页面就会卡。常见做法是防抖(停下来才执行)
与节流(固定间隔最多执行一次)。
// 防抖:事件停下 delay 毫秒后才执行,适合搜索框
function debounce(fn, delay = 300) {
let timer = null;
return function (...args) {
clearTimeout(timer);
timer = setTimeout(() => fn.apply(this, args), delay);
};
}
const search = document.querySelector("#search");
search.addEventListener("input", debounce(function (event) {
console.log("搜索:", event.target.value);
}, 400));
// 节流:固定间隔最多执行一次,适合滚动
function throttle(fn, gap = 200) {
let last = 0;
return function (...args) {
const now = Date.now();
if (now - last < gap) return;
last = now;
fn.apply(this, args);
};
}
window.addEventListener("scroll", throttle(function () {
console.log("当前滚动位置:", window.scrollY);
}, 200));
const list = document.querySelector("#list");
const log = document.querySelector("#log");
list.addEventListener("click", function (event) {
const item = event.target.closest("li");
if (!item || !list.contains(item)) return;
item.classList.toggle("picked");
const picked = list.querySelectorAll("li.picked").length;
log.textContent = "刚才点到:" + item.dataset.name +
" · 标签 " + item.tagName.toLowerCase() +
" · 已选 " + picked + " 条";
});
事件委托
整个列表只绑定了 1 个监听器,新加的项也会自动生效。
- HTML · 结构
- CSS · 样式
- JavaScript · 交互
- DOM · 操作页面
点一条看看。
事件委托为什么能减少监听器数量?
因为事件会冒泡:子元素被点击后,事件会一层层向上传递。我们只要在共同的父元素上监听一次,再用 event.target.closest() 判断「实际点到的是哪一项」,就能处理所有子元素。动态新增的子元素也天然被覆盖。
异步与 Promise
setTimeout · 回调 · Promise · async / await · fetch 与错误处理
JavaScript 是单线程的,同一时刻只能做一件事。但网络请求、定时器、文件读取都需要等待, 如果傻等,页面就卡住了。异步要解决的正是这个问题: 先把等待交出去,等结果回来再继续。
setTimeout 与回调
setTimeout(fn, ms) 会在至少 ms 毫秒后把函数放进任务队列,
而不是立刻插队执行。下面这段代码的输出顺序,值得亲手跑一遍。
console.log("1 · 开始");
setTimeout(function () {
console.log("3 · 1 秒后");
}, 1000);
console.log("2 · 结束");
// 定时器返回一个 id,可以取消
const id = setTimeout(function () {
console.log("这句不会执行");
}, 500);
clearTimeout(id);
// 回调嵌套多了会形成「回调地狱」
setTimeout(function () {
setTimeout(function () {
setTimeout(function () {
console.log("三层之后");
}, 200);
}, 200);
}, 200);
Promise:把「未来的结果」装进一个盒子
Promise 有三种状态:pending(进行中)、fulfilled(成功)、
rejected(失败)。状态一旦改变就不会再变。
它把回调从「层层嵌套」变成了「链式调用」。
function wait(ms) {
return new Promise(function (resolve) {
setTimeout(resolve, ms);
});
}
wait(600)
.then(function () {
console.log("等到了");
return "下一步的数据";
})
.then(function (data) {
console.log(data);
})
.catch(function (error) {
console.error(error);
})
.finally(function () {
console.log("无论成功失败都会执行");
});
// 失败示例
function fail() {
return Promise.reject(new Error("出错了"));
}
fail().catch(function (error) {
console.warn(error.message);
});
| 状态 | 含义 | 之后会走 |
|---|---|---|
pending | 还在进行中 | 等待 |
fulfilled | 成功,带着结果 | then |
rejected | 失败,带着原因 | catch |
async / await:让异步看起来像同步
async 函数总是返回一个 Promise;await 会暂停当前函数的执行,
等 Promise 有结果再继续。它只是语法糖,底层仍然是 Promise,但读起来顺畅得多。
function delay(ms) {
return new Promise(function (resolve) {
setTimeout(resolve, ms);
});
}
async function loadProfile() {
console.log("开始加载");
await delay(800);
console.log("拿到用户");
await delay(400);
return { name: "小满", level: 3 };
}
async function main() {
try {
const profile = await loadProfile();
console.log("完成", profile);
} catch (error) {
console.error("出错了", error);
}
}
main();
// 并行等待:两个请求同时发出,总耗时约 800ms 而不是 1200ms
async function loadAll() {
const [user, courses] = await Promise.all([
delay(800).then(() => "用户"),
delay(800).then(() => ["HTML", "CSS", "JS"])
]);
console.log(user, courses);
}
loadAll();
fetch 与错误处理
fetch 返回的 Promise 在收到响应时就会 resolve,
哪怕状态码是 404 或 500。所以必须自己检查 response.ok,
否则会把错误页当成正常数据解析。
async function getTodos() {
try {
const response = await fetch("https://jsonplaceholder.typicode.com/todos?_limit=3");
if (!response.ok) {
throw new Error("请求失败:" + response.status);
}
const data = await response.json();
console.log(data);
return data;
} catch (error) {
console.error("网络或解析错误:", error.message);
} finally {
console.log("请求结束");
}
}
getTodos();
// 连续 await 是串行;互不依赖就放进 Promise.all 并行
async function loadBoth() {
const [a, b] = await Promise.all([getTodos(), getTodos()]);
console.log(a, b);
}
const start = document.querySelector("#start");
const timeline = document.querySelector("#timeline");
const hint = document.querySelector("#hint");
function wait(ms) {
return new Promise(function (resolve) {
setTimeout(resolve, ms);
});
}
function addLine(text, tone) {
const li = document.createElement("li");
li.textContent = text;
if (tone) li.className = tone;
timeline.appendChild(li);
}
async function load() {
start.disabled = true;
timeline.innerHTML = "";
hint.textContent = "正在请求数据…";
addLine("① 发起请求");
await wait(700);
addLine("② 拿到用户:小满");
await wait(500);
addLine("③ 拿到课程:3 门");
await wait(500);
addLine("④ 渲染完成", "done");
hint.textContent = "全部完成,一共等待约 1.7 秒,页面始终可以操作。";
start.disabled = false;
}
start.addEventListener("click", load);
load();
异步加载模拟
点击按钮,看代码如何按顺序等待。
只有网络中断、跨域被拒这类情况才会进入 catch。服务器返回 404 / 500 时,Promise 依然是成功状态。所以每次请求都要判断 response.ok,必要时再手动 throw。
async / await 和 Promise 是什么关系?
async / await 是建立在 Promise 之上的语法糖。async 函数一定返回 Promise,await 只是在等待 Promise 落定,并把结果取出来。它没有改变异步的本质,只是让链式调用看起来更像同步代码,配合 try / catch 处理错误更自然。
综合实战:待办清单
需求拆解 · 完整代码 · 逐段讲解 · localStorage · 扩展练习
现在把前面十章串起来,做一个真正能用的小工具。 它不复杂,却包含了状态、渲染、事件委托、表单处理与本地存储—— 几乎是所有前端应用的缩小版。
先拆需求,再写代码
| 需求 | 用到的知识 | 实现要点 |
|---|---|---|
| 添加任务 | 表单 submit、数组 unshift | 阻止默认提交,清空输入框 |
| 标记完成 | 事件委托、find、取反 | 点击整行切换 done |
| 删除任务 | 事件委托、filter | 点 × 时按 id 过滤掉 |
| 筛选全部 / 未完成 / 已完成 | filter、classList | 保留一个 filter 状态 |
| 显示剩余数量 | reduce / filter、textContent | 每次渲染后同步更新 |
| 刷新后仍在 | localStorage、JSON | 读写都包在 try / catch 里 |
一个很重要的习惯:先定义数据,再写界面。 数据想清楚了,渲染只是「把数据翻译成 DOM」,事件只是「修改数据,然后重新渲染」。
第一步:定义状态与持久化
整个应用只有两个状态:todos 数组,和当前的筛选条件 filter。
每条任务长成 { id, text, done },id 用来在事件里定位它。
const STORAGE_KEY = "qh-todo-demo";
let todos = loadTodos();
let filter = "all"; // all | active | done
function loadTodos() {
const seeds = [
{ id: 1, text: "读完这一章", done: true },
{ id: 2, text: "在演练场默写一遍", done: false }
];
try {
const raw = localStorage.getItem(STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (error) {
console.warn("本地存储不可用,使用默认数据");
}
return seeds;
}
function saveTodos() {
try {
localStorage.setItem(STORAGE_KEY, JSON.stringify(todos));
} catch (error) {
console.warn("本地存储不可用,修改只在当前页面有效");
}
}
第二步:把数据渲染成列表
render() 是整个应用的中心:先按 filter 算出可见数据,
清空列表,再逐条创建节点。所有子节点都用 createElement 与
textContent 生成,天然避免了 HTML 注入。
function render() {
const visible = todos.filter(function (item) {
if (filter === "active") return !item.done;
if (filter === "done") return item.done;
return true;
});
list.innerHTML = "";
visible.forEach(function (item) {
const li = document.createElement("li");
li.className = item.done ? "item done" : "item";
li.dataset.id = item.id;
const check = document.createElement("span");
check.className = "check";
check.textContent = "✓";
const text = document.createElement("span");
text.className = "text";
text.textContent = item.text;
const del = document.createElement("button");
del.className = "del";
del.type = "button";
del.textContent = "×";
li.append(check, text, del);
list.appendChild(li);
});
const left = todos.filter(function (item) {
return !item.done;
}).length;
countEl.textContent = left;
empty.style.display = visible.length ? "none" : "block";
}
第三步:事件只负责改数据
添加、切换、删除、筛选——四类交互最终都只做一件事:修改 todos 或
filter,然后调用 saveTodos() 与 render()。
界面永远由数据推导出来,不需要手动去改某一行的样式。
form.addEventListener("submit", function (event) {
event.preventDefault();
const text = input.value.trim();
if (!text) return;
todos.unshift({ id: Date.now(), text: text, done: false });
input.value = "";
saveTodos();
render();
input.focus();
});
list.addEventListener("click", function (event) {
const li = event.target.closest("li");
if (!li) return;
const id = Number(li.dataset.id);
if (event.target.classList.contains("del")) {
todos = todos.filter(function (item) {
return item.id !== id;
});
} else {
const item = todos.find(function (item) {
return item.id === id;
});
if (item) item.done = !item.done;
}
saveTodos();
render();
});
document.querySelectorAll("[data-filter]").forEach(function (button) {
button.addEventListener("click", function () {
filter = button.dataset.filter;
document.querySelectorAll("[data-filter]").forEach(function (other) {
other.classList.toggle("active", other === button);
});
render();
});
});
完整示例:亲手点一点
下面的预览是完整版本。添加几条任务、勾选完成、切换筛选,然后点「重新运行」,
看看数据是否还在——这就是 localStorage 的作用。
const STORAGE_KEY = "qh-todo-demo";
const form = document.querySelector("#form");
const input = document.querySelector("#input");
const list = document.querySelector("#list");
const empty = document.querySelector("#empty");
const countEl = document.querySelector("#count");
let todos = loadTodos();
let filter = "all";
function loadTodos() {
const seeds = [
{ id: 1, text: "读完这一章", done: true },
{ id: 2, text: "在演练场默写一遍", done: false }
];
try {
const raw = localStorage.getItem(STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (error) {
console.warn("本地存储不可用,使用默认数据");
}
return seeds;
}
function saveTodos() {
try {
localStorage.setItem(STORAGE_KEY, JSON.stringify(todos));
} catch (error) {
console.warn("本地存储不可用,修改只在当前页面有效");
}
}
function render() {
const visible = todos.filter(function (item) {
if (filter === "active") return !item.done;
if (filter === "done") return item.done;
return true;
});
list.innerHTML = "";
visible.forEach(function (item) {
const li = document.createElement("li");
li.className = item.done ? "item done" : "item";
li.dataset.id = item.id;
const check = document.createElement("span");
check.className = "check";
check.textContent = "✓";
const text = document.createElement("span");
text.className = "text";
text.textContent = item.text;
const del = document.createElement("button");
del.className = "del";
del.type = "button";
del.textContent = "×";
del.setAttribute("aria-label", "删除任务");
li.append(check, text, del);
list.appendChild(li);
});
const left = todos.filter(function (item) {
return !item.done;
}).length;
countEl.textContent = left;
empty.style.display = visible.length ? "none" : "block";
}
form.addEventListener("submit", function (event) {
event.preventDefault();
const text = input.value.trim();
if (!text) return;
todos.unshift({ id: Date.now(), text: text, done: false });
input.value = "";
saveTodos();
render();
input.focus();
});
list.addEventListener("click", function (event) {
const li = event.target.closest("li");
if (!li) return;
const id = Number(li.dataset.id);
if (event.target.classList.contains("del")) {
todos = todos.filter(function (item) {
return item.id !== id;
});
} else {
const item = todos.find(function (item) {
return item.id === id;
});
if (item) item.done = !item.done;
}
saveTodos();
render();
});
document.querySelectorAll("[data-filter]").forEach(function (button) {
button.addEventListener("click", function () {
filter = button.dataset.filter;
document.querySelectorAll("[data-filter]").forEach(function (other) {
other.classList.toggle("active", other === button);
});
render();
});
});
render();
今日小事
还没有任务,先写下第一条吧。
数据保存在 localStorage,刷新后会回来。
演示运行在与页面同源的 iframe 里,localStorage 正常可用。个别浏览器在直接双击打开的 file:// 页面下会限制本地存储,此时脚本会自动退回内存模式;用本地服务器打开即可正常持久化。
逐段回看与扩展练习
- 单一数据源:界面不保存自己的状态,只由
todos推导。改完数据统一调用render(),避免「数据改了但页面没变」。 - 委托而非批量绑定:列表会频繁重建,在
list上监听一次,比给每个li绑定更稳。 - 用 id 而不是下标:筛选后下标会错位,
data-id始终指向唯一的任务。 - 先 trim 再判断:只输入空格不应该产生一条空任务。
- 存储失败不崩溃:隐私模式或配额用尽时,
try / catch让应用继续可用,只是不再持久化。 - 每次修改都保存:在添加、切换、删除之后立刻
saveTodos(),不依赖页面卸载事件。
扩展练习 当基本功能跑通,可以按下面的顺序继续加难度,每一项都只用到了前面学过的知识:
- 给任务加「重要」标记,用不同颜色区分,并在排序时置顶。
- 双击文字进入编辑态,按
Enter保存、Esc取消。 - 增加「清除已完成」按钮,用
filter一次移除。 - 把创建时间存进去,在列表里显示「3 分钟前」。
- 把
render()拆成renderItem()与renderStats(),练习函数拆分。 - 把数据层单独写成一个对象,暴露
add / toggle / remove / getAll,为以后换成接口请求做准备。
为什么删除任务要用 id 定位,而不是用数组下标?
因为列表可能处于筛选状态,界面上的第一行未必是原数组的第一项,下标与数据对不上。用 data-id 记录唯一标识,再 filter 掉对应项,无论怎么筛选都不会删错。这也是真实项目里列表渲染的通用做法。
如果这个待办清单已经跑通,你已经走完了前端三件套的最后一程。 想立刻动手,就去 在线演练场 把这一章的代码默写一遍; 也可以回到 首页,挑一个综合项目继续拆解。
语法会被忘记,但「先想数据,再画界面」的顺序,会一直陪着你写下去。—— 青禾手记