跳到正文
零到全栈 · 卷 2 · 浏览器三件套

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`。

下一步

语言基础齐了,但页面还是死的。下一章把这三个函数接到真界面上:渲染列表、处理提交、用事件委托管理标签过滤。

→ 卷2-05-DOM与事件.md