稍候片刻,月出文自明。
this 绑定。遍历数组优先用 for...of,调用数组方法前先确认会不会改原数组;错误别吞,Promise 要等,执行顺序先看同步代码,再看微任务和下一个任务。新代码优先用 ESM。遇到「明明写对了却不生效」,先问类型、作用域和同步异步,再用控制台或断点验证。<script src="app.js"></script> <!-- 阻塞解析,下载完立刻执行,DOM 可能还没建完 -->
<script src="app.js" defer></script> <!-- 解析完再按顺序执行,DOMContentLoaded 之前 -->
<script src="app.js" async></script> <!-- 下载完就执行,多个脚本之间顺序不保证 -->
<script type="module" src="app.js"></script> <!-- 默认 defer,模块作用域,自动严格模式 -->typeof undefined // "undefined"
typeof null // "object" —— 早期实现遗留的 bug,判断 null 要写 x === null
typeof 1n // "bigint"
typeof Symbol() // "symbol"
typeof function () {} // "function",函数是对象,但 typeof 给它单独的名字
typeof [] // "object",数组请用 Array.isArray([])
typeof NaN // "number",NaN 是 number 类型里的「非数」
typeof notDeclared // "undefined",对未声明的变量 typeof 不会抛错const a = { n: 1 };
const b = a;
b.n = 2;
a.n; // 2 —— a 和 b 是同一个对象
const shallow = { ...a }; // 浅拷贝:第一层独立,嵌套对象仍共享
const deep = structuredClone(a); // 深拷贝:支持 Map、Set、Date 和循环引用,但不能克隆函数和 DOM 节点1 == '1' // true,字符串转成数字再比
0 == '' // true,'' 转成 0
'' == '0' // false,两边都是字符串,不转换,直接比
null == undefined // true,规范里唯一被特批的一对
null == 0 // false,null 只和 undefined 相等
[] == false // true,两边都转成 0
NaN === NaN // false,NaN 是唯一不等于自己的值
Object.is(NaN, NaN) // true
Object.is(-0, 0) // false,=== 认为它们相等console.log(a); // undefined:var 的声明被提升,赋值没跟上
var a = 1;
console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 1;
function f() {
if (true) {
var x = '函数级';
let y = '块级';
}
console.log(x); // '函数级',var 泄漏到了函数作用域
console.log(y); // ReferenceError
}const user = { name: 'Ann' };
user.name = 'Bob'; // 可以,改的是对象内容
user = {}; // TypeError: Assignment to constant variable
Object.freeze(user);
user.name = 'Cara'; // 静默失败(严格模式下抛 TypeError)switch (status) {
case 'loading':
case 'idle': // 故意合并:两个状态走同一段逻辑
renderSpinner();
break;
default:
renderContent();
}const arr = ['a', 'b'];
for (const v of arr) console.log(v); // 'a' 'b'
for (const [i, v] of arr.entries()) console.log(i, v); // 0 'a' / 1 'b'
for (const k in arr) console.log(k); // '0' '1',是字符串索引,不是值
// 嵌套循环想一次跳出两层,用标签(少用,但确实比设 flag 干净)
outer: for (const row of matrix) {
for (const cell of row) {
if (cell === 0) break outer;
}
}// 1. 函数声明:整体提升,可以在定义之前调用
sayHi();
function sayHi() { console.log('hi'); }
// 2. 函数表达式:赋值之后才可用
const fn = function () {};
// 3. 箭头函数:没有自己的 this、arguments 和 prototype
const add = (a, b) => a + b;
const makeUser = (name) => ({ name }); // 返回对象字面量要套一层括号function createUser(name, age = 18, ...rest) {
return { name, age, rest }; // rest 是真数组,arguments 不是
}
createUser('Ann'); // { name: 'Ann', age: 18, rest: [] }
createUser('Ann', undefined, 1); // 默认值生效,rest 为 [1]
function render({ id, title = '无标题', tags = [] } = {}) { /* 解构参数,给整体一个空对象兜底 */ }function counter() {
let n = 0; // 外部拿不到,只能通过返回的方法读写
return { inc: () => ++n, get: () => n };
}
const c = counter();
c.inc(); c.inc();
c.get(); // 2const obj = { name: 'Ann', hi() { console.log(this.name); } };
const fn = obj.hi;
fn(); // undefined —— 方法被「摘」下来了
setTimeout(obj.hi, 0); // 同上,定时器里的回调是独立调用
[1].forEach(obj.hi); // 同上,回调也是独立调用
const safe = obj.hi.bind(obj); // 修法一:提前绑定
[1].forEach(() => obj.hi()); // 修法二:箭头函数包一层const key = 'role';
const user = {
name: 'Ann',
[key]: 'admin', // 计算属性名
greet() { return `hi, ${this.name}`; } // 方法简写
};
const { name, role: r = 'guest', ...others } = user; // 重命名、默认值、剩余
user?.profile?.city ?? '未知'; // 可选链 + 空值合并,链断了也不会抛错
Object.keys(user); // ['name', 'role']
Object.entries(user); // [['name', 'Ann'], ['role', 'admin']]
const copy = { ...user }; // 浅拷贝,也是合并的常用写法
delete user.name; // 删属性;数组别用 delete,会留下空洞,用 spliceclass Animal {
#name; // 私有字段,只能在类内部读写
static count = 0; // 静态字段,挂在类本身
constructor(name) {
this.#name = name;
Animal.count += 1;
}
get name() { return this.#name; }
speak() { return `${this.#name} 叫了一声`; }
}
class Dog extends Animal {
speak() { return `${super.speak()},是汪汪`; } // super 调父类同名方法
}[10, 9, 1].sort(); // [1, 10, 9] —— 默认按字符串的 UTF-16 顺序比
[10, 9, 1].sort((a, b) => a - b); // [1, 9, 10]
const sorted = nums.toSorted((a, b) => a - b); // 不改原数组
const sum = [1, 2, 3].reduce((acc, n) => acc + n, 0);
const grouped = list.reduce((acc, item) => {
(acc[item.type] ??= []).push(item); // ??= 只在缺失时初始化
return acc;
}, {});
Array.from({ length: 3 }, (_, i) => i); // [0, 1, 2],比 new Array(3) 可靠const name = 'Ann';
`hello, ${name}`; // 插值,支持换行
'abcdef'.slice(-2); // 'ef',负数从末尾数
'abcdef'.substring(-2); // 'abcdef',负数当 0,start 大于 end 时会自动交换
'abcdef'.substr(1, 2); // 'bc',第二个参数是长度,已废弃
'Hello'.replaceAll('l', 'L'); // 'HeLLo',ES2021;replace 只换第一个
'7'.padStart(3, '0'); // '007'
'abc'.at(-1); // 'c',比 charAt 好用,因为它接受负索引
'a,b,c'.split(','); // ['a', 'b', 'c'],和 join 互为逆操作0.1 + 0.2; // 0.30000000000000004
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON; // true,浮点比较要留误差
(1.005).toFixed(2); // '1.00',因为它实际存的是 1.00499999...
(1.55).toFixed(1); // '1.6',且返回的是字符串
Number('12px'); // NaN,整串必须是合法数字
parseInt('12px', 10); // 12,从头开始解析,永远传基数
isNaN('abc'); // true,会先做类型转换
Number.isNaN('abc'); // false,只判断「是不是 NaN」
Math.floor(Math.random() * 6) + 1; // 1–6 的随机整数,random 本身只给 [0, 1)
1n + 1n; // 2n,BigInt 之间可以算
1n + 1; // TypeError,BigInt 和 Number 不能混算
1n < 2; // true,比较是允许的function parseAge(input) {
const n = Number(input);
if (!Number.isInteger(n) || n < 0) {
throw new RangeError(`年龄不合法:${input}`);
}
return n;
}
try {
parseAge('abc');
} catch (err) {
console.error(err.name, err.message); // RangeError 年龄不合法:abc
} finally {
closeConnection(); // 无论成功失败都会执行
}class ApiError extends Error {
constructor(message, { status, cause } = {}) {
super(message, { cause }); // cause 保留原始错误,ES2022
this.name = 'ApiError';
this.status = status;
}
}
try {
await fetchUser(id);
} catch (err) {
if (err instanceof ApiError && err.status === 404) return null;
throw err; // 认不出的错误原样往上抛,别改写成「请求失败」
}console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');
// 输出:1 4 3 2
// 同步的先跑完,微任务在本轮末尾清空,定时器排到下一个宏任务// 串行:两个请求一共等两次
const user = await getUser();
const orders = await getOrders(user.id);
// 并行:先同时发起,再一起等
const [u, o] = await Promise.all([getUser(), getOrders()]);
// 循环里默认是串行,想并发就把每个任务先变成 Promise 再 all
const results = await Promise.all(ids.map((id) => fetchItem(id)));async function loadList() {
const res = await fetch('/api/list', { signal: AbortSignal.timeout(3000) });
if (!res.ok) throw new Error(`HTTP ${res.status}`); // fetch 只在网络层失败时 reject,404 不会
const data = await res.json(); // 响应体也要 await
return data;
}// utils.js
export const PI = 3.14159;
export function sum(a, b) { return a + b; }
export default function log(msg) { console.log(msg); }
// main.js
import log, { PI, sum } from './utils.js'; // 默认导出和命名导出可以一起取
import * as utils from './utils.js'; // 整体引入,访问 utils.PI
// 动态导入:返回 Promise,适合按需加载大模块
const { default: chart } = await import('./chart.js');
JavaScript 基础入门:把语言规则挂回七个问题
我的 JavaScript 笔记曾经也是一堆碎片:===、this、Promise、for...of,每个词都能单独讲,但真写起代码还是会出现「点了按钮没反应」「循环里打印的都是最后一个数」这类问题。这一篇按七个问题重新归档(函数与 this 归在「变量存在哪」下面,因为闭包和 this 本质都是作用域问题):值是什么类型、变量存在哪、逻辑怎么走、数据怎么组织、出错怎么收、先后怎么保证、代码怎么拆。挂不上去的知识点,多半是我还没弄懂它解决的是什么问题。
读完后你会拿到:八种内置类型与相等判定的判断链;作用域、闭包与 this 的四种绑定;数组方法哪些改原数组、哪些返回新的;事件循环里宏任务与微任务的执行顺序;模块的两种写法;以及一节自查清单,专门收那些「看起来能跑、其实不对」的代码。所有示例都能直接粘进浏览器控制台或 Node 里跑,不需要构建工具和框架。
01|先跑起来:两个宿主、四种引入方式与调试入口
JavaScript 本身只是一套语言规则,真正让它跑起来的宿主有两个:浏览器(提供 DOM、fetch、localStorage)和 Node(提供文件系统、网络、进程)。同一个语言,两边的 API 完全不同,所以看到「浏览器里能用、Node 里报错」时,先想想这句代码依赖的是语言还是宿主。
页面里引入脚本的四种写法,差别只在执行时机:
调试入口有三个,各有各的用处:控制台适合验证一行表达式的返回值;debugger 语句和 Sources 面板的断点适合看清调用栈和每一帧的局部变量;console.table() 适合看数组和对象,console.time() 适合量一段代码的耗时。养成「先验证再下结论」的习惯,比记住结论更有用——语言里很多「玄学」用一行 typeof 就能问清楚。
02|值:八种类型、原始与引用、怎么判断相等
规范里只有八种内置类型,其中七种是原始值,剩下一种叫对象。所有复杂结构——数组、函数、日期、Map、正则——本质上都是对象。
判断类型时,typeof 有几个必须记住的例外:
第二条分界线是原始值和引用值。原始值按值传递、按值比较;对象传递的是引用,两个变量可以指向同一个对象。
很多项目还在用 JSON.parse(JSON.stringify(obj)) 做深拷贝,它有三个已知缺口:undefined、函数、Symbol 会在序列化时消失;Date 变成字符串;循环引用直接抛错。structuredClone 在主流浏览器和 Node 17 以上都已可用,能用就别绕路。
相等判定是入门阶段最容易含糊的一段。=== 要求类型和值都相同,不做转换;== 会先做类型转换,规则可以简写成下面这几条。
结论很简单:一律用 ===,唯一值得保留的例外是 x == null,它可以同时覆盖 null 和 undefined 两种情况。另外记住假值一共八种:false、0、-0、0n、''、null、undefined、NaN;空数组和空对象都是真值,这一条经常被当成 bug 报上来。
03|变量:作用域、提升与 const 的边界
三种声明方式的区别集中在三点:作用域、是否提升、能否重复声明。var 是函数作用域且会被提升并初始化为 undefined;let 和 const 是块级作用域,声明也会被提升,但在初始化之前处于暂时性死区(TDZ),访问会直接抛 ReferenceError。
const 约束的是绑定,不是值:重新赋值会抛 TypeError,但对象内部照样能改。想要真正锁住内容,得用 Object.freeze(),而且它只冻结第一层。
三个实践约定:默认用 const,需要重新赋值时才换 let,var 只出现在维护老代码的时候;const 必须带初始值(for...of 的循环变量除外);变量名用驼峰,布尔量以 is、has、can 开头,读代码时不用再猜类型。
04|流程控制:分支、循环与可迭代
分支部分没有难点,只有一个容易忘的细节:switch 的 case 比较用的是严格相等,所以 case '1' 匹配不到数字 1。每个分支记得 break 或 return,否则会继续往下执行(fallthrough,偶尔故意用来合并条件)。
循环的选择只看一件事:你要的是值还是键,以及能不能中途退出。
三元运算符适合「二选一赋值」,超过一层嵌套就该改回 if。逻辑上还有三个常用工具:&& 和 || 会短路求值,?? 只在左侧是 null 或 undefined 时才取右侧——这正好补上 || 把 0 和 '' 也当成假值的坑。
05|函数:写法、参数、闭包与 this
三种写法在语法上等价,在行为上不等价:
箭头函数的差异值得单列,因为它是 this 出问题的根源之一:它不创建自己的 this,而是沿用定义位置外层的 this;它没有 arguments(用 ...rest 代替);它不能用 new 调用,也没有 prototype。所以「需要动态 this 的方法」和「构造函数」都不要写成箭头函数。
参数部分有三件常用的事:默认值、剩余参数、解构。默认值只在传 undefined(或不传)时生效,显式传 null 不会触发,这一点常被误当成 bug。
闭包是「函数记住了它出生时所在的作用域」这件事的自然结果。它的用途比定义更重要:私有状态、防抖节流、缓存、模块化之前的命名空间,全靠它。
代价也要知道:闭包会一直持有外层变量,只要这个函数还被引用(挂在全局、留在定时器或事件监听里),这些变量就不会被回收。不再需要时把引用置空,比事后猜「内存怎么涨了」有用。
this 只有四种绑定方式,优先级从低到高是:默认绑定、隐式绑定、显式绑定、new 绑定。箭头函数不参与这套规则,它直接沿用词法作用域的 this。
最后补一句递归:写递归先写终止条件,再写规模缩小的一步。规范里写过尾调用优化,但主流引擎都没有实现,递归几千层照样会栈溢出,处理树结构时深度不可控的话,改成显式栈更稳妥。
06|对象与数组:存取、遍历与方法的「变与不变」
对象是所有复杂数据的底座。字面量里能写计算属性名和方法简写,解构能一次取出多个属性并顺手重命名、给默认值、收剩下的。
class 只是原型继承的语法糖,但把三件容易写错的事收进了语法:私有字段用 # 前缀(类外访问是语法错误,不是运行时错误)、静态成员挂在类本身、extends 和 super 处理继承链。
原型链一句话就能说清:属性查找先看对象自己,没有就沿着内部原型往上找,一直到 Object.prototype,再往上就是 null。Object.getPrototypeOf() 看原型,hasOwnProperty() 看是不是自有属性,Object.create(null) 造一个没有原型的纯字典型对象。
数组的方法按「改不改原数组」分成两组,混淆这一组是线上事故的常见来源:
最后一条容易被忽略:new Array(3) 造的是三个空槽,不是三个 undefined,map 和 forEach 会跳过空槽,所以 new Array(3).map(() => 'x') 拿到的还是空数组。要初始化就用 Array.from、fill 或展开语法。
07|字符串与数字:不可变、浮点与精度边界
字符串不可变,所有方法都返回新字符串,所以 str.replace() 不改原值——忘了接返回值,是「替换没生效」的头号原因。模板字符串负责拼接,标签模板则是把字符串片段和插值分开交给函数处理(styled-components 之类的库就建立在这上面)。
数字这块只有一个核心事实:JavaScript 的 number 是 IEEE 754 双精度浮点,用二进制存十进制小数,0.1 和 0.2 都存不准,相加后就是 0.30000000000000004。所以金额别用浮点算,用「分」为单位的整数,或者交给 BigInt 与专门的定点库。
数值边界还有两个常量值得记住:Number.MAX_SAFE_INTEGER 是 9007199254740991,超过它的整数运算可能悄悄丢精度;Number.EPSILON 是两个可表示浮点数之间的最小间隔,比较浮点数时以它为容忍度。toFixed 返回字符串,别拿它直接参与后续计算。
08|错误:怎么抛、怎么接、怎么不吞掉
错误处理的目标不是「让程序不报错」,而是「让出错的位置和原因一眼可见」。所以第一原则是早抛:参数不合法就在函数入口 throw,别让它带着脏数据往下跑三层才炸。
几个必须分清的点:SyntaxError 发生在解析阶段,try/catch 抓不到;finally 里如果有 return,会覆盖 try 里的返回值,除非确有必要,别在 finally 里返回;catch 的参数可以省略(ES2019),但省略后你就失去了排查线索。
异步代码里的错误还有一条额外规则:Promise 内部抛出的异常不会同步冒出来,必须 await 或 .catch() 才能接住;忘了接的 rejection 会变成 unhandledrejection,在控制台里表现为一条迟到很久的红字。空 catch {} 是最常见的反模式——要么处理,要么记日志后重抛,二选一。
09|异步:事件循环、Promise 与 async/await
JavaScript 只有一个执行线程,异步不是「同时做」,而是「排好队再做」。理解顺序只需要记住一条流水线:先跑完同步代码(调用栈清空),然后清空微任务队列,需要时渲染一帧,再取下一个宏任务。
Promise 只有三种状态:pending、fulfilled、rejected。状态一旦改变就不可逆,then 永远返回一个新的 Promise,所以链式调用不会互相污染。四个组合器的分工要记牢,选错了就是白等或者白炸:
async 函数返回的一定是 Promise,await 只是「等这个 Promise 落定并把值取出来」,它不会阻塞线程。错误处理用 try/catch 包住 await 即可,和同步代码写法一致——这也是 async/await 比裸 then 好读的原因。
三个容易踩的细节:fetch 遇到 4xx/5xx 不会 reject,必须自己检查 res.ok;setTimeout(fn, 0) 不是立刻执行,嵌套几层后最小延迟会被抬到约 4ms;做动画别用定时器,用 requestAnimationFrame,它和渲染节奏对齐。
10|模块:ESM 与 CommonJS 的分工
现代写法统一用 ES Module。它的结构是静态的——导入导出写在顶层、不能塞进 if 里——所以打包工具能在编译期做 tree-shaking;导出的绑定是活的,模块内部的值变了,导入方看到的值也会变。
CommonJS 是 Node 的老方案:require 同步加载、运行时执行、可以写在条件分支里,导出用 module.exports 或 exports.xxx。两者的差别可以浓缩成一句:CommonJS 导出的是当时的值,ESM 导出的是持续有效的引用。同一个项目里混用要看 package.json 的 type 字段,"module" 表示 .js 按 ESM 解析,需要 CJS 时把后缀改成 .cjs。
还有两条实践提醒:顶层 await 只在 ESM 里可用,正好用来在模块加载时初始化配置;用 file:// 直接打开页面时模块会被 CORS 拦下,必须起一个本地服务器,并且相对路径要写全 .js 后缀。
11|高频坑自查清单
下面这些不是知识点,是写代码时的停顿点。每一条背后都有人线上排查过半天。
把这张清单和自己的项目对一遍,再挑一个真实的小需求练手——一个带本地存储的待办清单,或一个用 fetch 拉数据并渲染列表的页面。写完之后再回头读这一篇,你会发现大部分条目都变成了「我踩过」而不是「我背过」。
参考资料