COURSE 03 — BEHAVIOR

JavaScript · 交互之魂

如果 HTML 是骨架、CSS 是衣裳,那么 JavaScript 就是让页面呼吸的那口气。 这一章从变量、类型和表达式出发,一路走到函数、DOM、事件与异步, 最后亲手写一个刷新也不会丢数据的待办清单。

11 个章节 22+ 段代码 约 6 小时 难度 · 进阶
学习进度 0%
01

认识 JavaScript:让页面动起来

它是什么 · 在网页中的位置 · defer / async · 控制台与调试

1995 年,Brendan Eich 用十天时间写出了这门语言的最初版本。 三十年后,它成了世界上被运行次数最多的语言——网页、编辑器、服务器、甚至小程序,都有它的身影。

与 HTML、CSS 最大的不同在于:JavaScript 是一门真正的编程语言。 它拥有变量、类型、条件、循环、函数和对象,可以描述逻辑、处理数据、做出判断。 当网页里出现一个会展开的菜单、一个会变色的按钮、一个不用刷新就能更新内容的列表, 背后几乎都有 JavaScript 在维持秩序。

它到底能做什么

  • 操作页面:读取、修改、创建和删除页面上的元素与文字。
  • 响应用户:监听点击、输入、滚动、键盘等行为,并作出反应。
  • 处理数据:排序、筛选、聚合,把一堆原始数据整理成可读的信息。
  • 与服务器通信:在不刷新页面的前提下请求数据,也就是常说的 Ajax / fetch。
  • 记住状态:借助 localStorage 把用户的偏好留在浏览器里。
  • 绘制与动画:用 CSS 变量、Canvas、WebGL 做出更复杂的视觉表达。
JS · 第一段脚本
// 用变量存下一份数据
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()">不推荐,逻辑与结构混在一起,难以维护
JS · 脚本的三种引入方式
// ① 外部文件(推荐):可缓存、可维护、可复用
// <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:看请求是否成功、返回了什么、花了多久。
JS · 控制台的几种用法
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 万次");
Live Preview
JS · 第一次操作页面
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);
});
调试的第一反应

页面没有按预期工作时,先打开 Console。红色的报错通常会直接指出文件名和行号,比盯着代码猜要快得多。

脚本里的 defer 和 async,应该怎么选?

需要操作 DOM、或与其它脚本有先后依赖时,用 defer:它保证 DOM 解析完成后、按顺序执行。完全独立、不关心顺序的脚本(比如统计代码)可以用 async,它下载完就立刻执行,但也因此可能打断页面解析。

02

变量、数据类型与类型转换

let / const / var · 七种原始类型 · 模板字符串 · typeof · 显式与隐式转换

程序做的第一件事,往往是把一个值放进某个名字里,稍后再取出来。 这个「名字」就是变量,而值有各自的类型。把这两件事弄清楚,后面的一切都会顺很多。

let、const 与 var

现代 JavaScript 里,声明变量主要用 let 和 const。 var 是早期写法,仍有历史代码在用,但新代码不建议再写。

关键字能否重新赋值作用域重复声明建议
const不能块级不允许默认首选,尤其是不会变的值
let可以块级不允许确实需要改变时才用
var可以函数级允许旧代码中见到即可,新代码避免
JS · 声明与赋值
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"青禾"文本,单引号、双引号、反引号都可以
number18、3.14整数与小数同属一种类型,另有 NaN 与 Infinity
booleantrue / false只有两个值,用于判断
undefinedundefined声明了但还没有赋值
nullnull「有意为之的空」,通常由开发者主动赋值
symbolSymbol("id")独一无二的值,常用作对象的键
bigint9007199254740993n超出安全整数范围的大整数
JS · 用 typeof 看清类型
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,判断数组更可靠
typeof null === "object"

这是语言早期实现留下的 bug,因为兼容性一直保留至今。判断「是不是 null」请直接用 value === null;判断数组请用 Array.isArray()。

模板字符串:把变量织进句子里

用反引号包裹的字符串叫模板字符串,它可以换行,也可以用 ${} 直接嵌入表达式。 拼接长句子时,它比一串加号清爽得多。

JS · 模板字符串
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")42number标准转换
Number("42px")NaNnumber整串必须合法
parseInt("42px", 10)42number从头开始解析,遇到非数字就停
String(42)"42"string转成文本
Boolean("")falseboolean空字符串为假
Boolean("0")trueboolean非空字符串都是真
"5" + 2"52"string加号遇到字符串就拼接
"5" - 23number减号会先把两边转成数字
JS · 显式优先,隐式谨慎
// 显式转换:把意图写在脸上
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
Live Preview
JS · 类型转换实验室
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() 一下。

03

运算符与表达式

算术 · 赋值 · === · 逻辑短路 · ?? · ?. · 三元 · 优先级

运算符是句子的动词。同样是「加」,对数字是求和,对字符串是拼接; 同样是「或者」,|| 和 ?? 的判断条件却不一样。 这一章把常用的符号一次讲清,顺便拆掉几个常见的坑。

算术运算符与赋值

运算符含义例子结果
+ - * /加减乘除7 / 23.5
%取余17 % 52
**幂运算2 ** 101024
+= -= *= /=运算后赋值x += 3等同于 x = x + 3
++ --自增 / 自减n++先返回再加一
JS · 算术与赋值
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

比较运算符:请优先使用 ===

=== 同时比较类型与值,== 会先做隐式转换。 另外要记住:对象之间的比较,比的是是不是同一个引用,而不是内容是否相同。

JS · 比较的三种结果
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 && ba 为假返回 a,否则返回 b条件成立才继续
a || ba 为假返回 b,否则返回 a兜底默认值
a ?? ba 是 null/undefined 时返回 b保留 0 与空字符串的默认值
obj?.propobj 为空时返回 undefined安全访问可能不存在的属性
JS · 短路、空值合并与可选链
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赋值 = +=
JS · 三元的正确用法
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);
Live Preview
JS · 一张会算账的小票
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 的数据,应该用 ??。

04

流程控制

if / else · switch · for · while · for...of / for...in · break / continue

程序真正开始「思考」,是从分支和循环开始的。 分支决定走哪条路,循环决定把同一件事做多少遍。这两件事组合起来,就能描述绝大多数业务逻辑。

if / else 与真假值

if 后面的括号里可以是任何值,JavaScript 会自动把它转成布尔值。 记住下面这几个 falsy 值,其余都是 truthy: false、0、-0、0n、""、 null、undefined、NaN。

JS · 分支与真假值
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,否则会继续往下执行。

JS · switch 与穿透
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。无论哪一种,都要确保条件最终会变成假,否则就是死循环。

JS · 三种循环
// 经典 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
JS · 取值、取键与跳出
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]);
}
Live Preview
JS · 用循环画一面 FizzBuzz 墙
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);
}
for...in 不要用来遍历数组

for...in 取的是键名,而且会沿原型链找到可枚举属性。数组上用它,不仅拿到的是字符串 "0"、"1",还可能遍历到额外属性。数组请用 for...of 或 forEach。

什么时候用 for...of,什么时候用 for...in?

遍历数组、字符串、Set、Map 这类「一组值」时,用 for...of,它直接给你每一项。遍历普通对象的键名时,用 for...in(更推荐 Object.keys() / Object.entries())。一句话:数组取值用 of,对象取键用 in。

05

函数与作用域

声明与表达式 · 箭头函数 · 参数 · 作用域链 · 闭包 · 递归

函数是把一段逻辑打包起来,并给它起个名字。它是 JavaScript 里最重要的零件: 回调、模块、组件、事件处理,最终都落在函数上。而理解函数,绕不开作用域与闭包。

函数声明与函数表达式

写法示例能否提前调用
函数声明function sum(a, b) {}可以,声明会被提升
函数表达式const sum = function (a, b) {}不可以,变量赋值之后才存在
箭头函数const sum = (a, b) => a + b不可以,且没有自己的 this
JS · 三种写法
// 函数声明:会被提升,可以在定义之前调用
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 的场景里,要谨慎使用。

JS · 箭头函数与 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 与返回值

JS · 参数与返回值
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("青禾"));

作用域与作用域链

变量不是在任何地方都能访问。函数内部可以读外部,外部读不到内部; 查找变量时,会从当前作用域开始,一层层往外找,直到全局,这条路径就是作用域链。

JS · 由内向外查找
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); // 报错

闭包:函数记住了它出生时的环境

当内层函数被返回到外部,它依然能访问当初定义它的那个作用域——这就是闭包。 闭包常用于封装私有状态,比如一个只能通过方法修改的计数器。

JS · 闭包与私有变量
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

递归则是函数调用自己。写递归必须有两样东西:终止条件, 以及每次都在向终止条件靠近,否则会栈溢出。

JS · 递归求阶乘
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
Live Preview
JS · 闭包计数器
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());
回调里用箭头函数

setTimeout、forEach、addEventListener 的回调里,如果要用外层的 this,优先写箭头函数,可以省掉 const self = this 这类旧写法。

闭包为什么能在函数执行完之后,继续访问内部变量?

因为内层函数被返回或保存到了外部,它仍然持有对定义时作用域的引用。只要这个函数还活着,它引用的变量就不会被回收。所以 count 一直存在,只是外部没法直接读写,只能通过返回的方法操作。

06

数组与对象

map / filter / find / reduce / sort · 解构 · 展开 · Object 遍历 · JSON

真实的数据几乎都长成数组与对象的样子:一页商品、一条用户信息、一组课程。 能熟练地筛选、变换与汇总它们,才算真正开始用 JavaScript 解决问题。

数组的五个高频方法

方法做什么返回是否改原数组
map把每项变换成新值新数组(长度不变)否
filter留下符合条件的项新数组(可能更短)否
find找到第一个符合条件的项那一项,或 undefined否
reduce把整个数组折叠成一个值任意值否
sort排序原数组的引用是
JS · 一条数据处理流水线
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 的两个坑

第一,sort 会直接修改原数组,想保留原数据请先 [...arr] 复制。第二,不传比较函数时,它会按字符串排序,[10, 2, 33].sort() 会得到 [10, 2, 33]("10" 排在 "2" 前面)。数字排序务必写 (a, b) => a - b。

解构与展开

解构是「按形状取值」,展开是「把里面的东西摊开」。 它们让取值和合并的代码短了一大截,也更接近数据的本来结构。

JS · 解构与展开
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);   // "苏州"

对象的遍历

JS · keys / values / entries
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 把字符串还原成对象。 发请求、写本地存储,都靠这一对方法。

JS · JSON 的进与出
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);
}
Live Preview
JS · 整理一份学习清单
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。

07

字符串、数字与 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 次生成分隔线
JS · 一把常用的字符串工具
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() 转回来。

JS · 数字处理
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 与随机数

JS · 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,而是二进制表示的固有局限。

JS · 与精度相处
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
Live Preview
JS · 今天练点什么
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 先统一精度。

08

DOM 操作:让页面听从指令

选取元素 · 内容与样式 · classList · 节点增删 · 表单取值

浏览器把 HTML 解析成一棵树,树上的每个节点都是一个对象。 DOM 操作的本质,就是找到某个节点,然后读它、改它、造一个新的、或者把它删掉。

选取元素

方法返回说明
querySelector(css)第一个匹配的元素或 null最常用,支持任意 CSS 选择器
querySelectorAll(css)NodeList(静态集合)需要用 forEach 或转数组
getElementById(id)元素或 null速度略快,但只能按 id
closest(css)最近的祖先(含自身)事件委托时非常好用
JS · 找到页面上的元素
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 解析。 前者安全,后者方便但危险——只要内容来自用户,就该用前者。

JS · 改文字、改样式、改属性
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 与 XSS

把用户输入直接拼进 innerHTML,就等于允许对方在你的页面里插入任意标签甚至脚本。展示用户内容请用 textContent;确实需要渲染一段 HTML 时,先确保它来自可信来源。

创建、插入与删除节点

JS · 用代码造一个节点
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(), 否则页面会刷新,脚本里的状态全部丢失。

JS · 表单取值与提交
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);
});
Live Preview
JS · 一面可以贴便签的墙
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。用户输入绝不能直接交给它。

09

事件与交互

addEventListener · 事件对象 · 冒泡与捕获 · 事件委托 · 节流防抖

页面从「静态」变成「可交互」的那一刻,就是事件发生的瞬间。 点击、输入、提交、滚动——用户做了什么,浏览器就发出一个事件, 我们只需要提前说清楚:发生这件事时,要执行哪段代码。

addEventListener:把函数交给事件

现代写法统一使用 addEventListener(类型, 处理函数, 选项)。 相比 onclick = ...,它不会覆盖之前的监听,还能注册多个、可以移除。

JS · 注册与移除监听
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"
JS · 读懂事件对象
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");
  }
});

冒泡、捕获与事件委托

事件发生时,会先从最外层往里「捕获」,到达目标后再从里往外「冒泡」。 默认的监听都在冒泡阶段触发。正因为会冒泡,我们才能在父元素上统一处理子元素的事件,这叫事件委托。

JS · 事件委托的标准写法
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 这类事件触发得非常频繁。 如果每次都执行较重的逻辑,页面就会卡。常见做法是防抖(停下来才执行) 与节流(固定间隔最多执行一次)。

JS · 防抖与节流
// 防抖:事件停下 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));
Live Preview
JS · 一个监听器管住整个列表
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 + " 条";
});
事件委托为什么能减少监听器数量?

因为事件会冒泡:子元素被点击后,事件会一层层向上传递。我们只要在共同的父元素上监听一次,再用 event.target.closest() 判断「实际点到的是哪一项」,就能处理所有子元素。动态新增的子元素也天然被覆盖。

10

异步与 Promise

setTimeout · 回调 · Promise · async / await · fetch 与错误处理

JavaScript 是单线程的,同一时刻只能做一件事。但网络请求、定时器、文件读取都需要等待, 如果傻等,页面就卡住了。异步要解决的正是这个问题: 先把等待交出去,等结果回来再继续。

setTimeout 与回调

setTimeout(fn, ms) 会在至少 ms 毫秒后把函数放进任务队列, 而不是立刻插队执行。下面这段代码的输出顺序,值得亲手跑一遍。

JS · 执行顺序
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(失败)。状态一旦改变就不会再变。 它把回调从「层层嵌套」变成了「链式调用」。

JS · 一个手写的 Promise
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,但读起来顺畅得多。

JS · 用 await 串起两步
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, 否则会把错误页当成正常数据解析。

JS · 一次完整的请求
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);
}
Live Preview
JS · 用 Promise 模拟一次加载
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();
fetch 不会因为 404 而 reject

只有网络中断、跨域被拒这类情况才会进入 catch。服务器返回 404 / 500 时,Promise 依然是成功状态。所以每次请求都要判断 response.ok,必要时再手动 throw。

async / await 和 Promise 是什么关系?

async / await 是建立在 Promise 之上的语法糖。async 函数一定返回 Promise,await 只是在等待 Promise 落定,并把结果取出来。它没有改变异步的本质,只是让链式调用看起来更像同步代码,配合 try / catch 处理错误更自然。

11

综合实战:待办清单

需求拆解 · 完整代码 · 逐段讲解 · localStorage · 扩展练习

现在把前面十章串起来,做一个真正能用的小工具。 它不复杂,却包含了状态、渲染、事件委托、表单处理与本地存储—— 几乎是所有前端应用的缩小版。

先拆需求,再写代码

需求用到的知识实现要点
添加任务表单 submit、数组 unshift阻止默认提交,清空输入框
标记完成事件委托、find、取反点击整行切换 done
删除任务事件委托、filter点 × 时按 id 过滤掉
筛选全部 / 未完成 / 已完成filter、classList保留一个 filter 状态
显示剩余数量reduce / filter、textContent每次渲染后同步更新
刷新后仍在localStorage、JSON读写都包在 try / catch 里

一个很重要的习惯:先定义数据,再写界面。 数据想清楚了,渲染只是「把数据翻译成 DOM」,事件只是「修改数据,然后重新渲染」。

第一步:定义状态与持久化

整个应用只有两个状态:todos 数组,和当前的筛选条件 filter。 每条任务长成 { id, text, done },id 用来在事件里定位它。

JS · 状态与 localStorage
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 注入。

JS · 渲染函数(节选)
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()。 界面永远由数据推导出来,不需要手动去改某一行的样式。

JS · 事件绑定(节选)
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 的作用。

Live Preview
JS · 待办清单完整脚本
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();
预览里的数据会保留

演示运行在与页面同源的 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 掉对应项,无论怎么筛选都不会删错。这也是真实项目里列表渲染的通用做法。

如果这个待办清单已经跑通,你已经走完了前端三件套的最后一程。 想立刻动手,就去 在线演练场 把这一章的代码默写一遍; 也可以回到 首页,挑一个综合项目继续拆解。

语法会被忘记,但「先想数据,再画界面」的顺序,会一直陪着你写下去。
—— 青禾手记