一、模块系统 —— require + 解构赋值
导包（两步法）
// 第一步：导入模块
const module = require('@/path')
// 第二步：解构提取需要的内容
const { funcName, ClassName } = require('@/path')
// 一步完成
const { funcA, funcB, ClassC } = require('@/path')特点：
- 需要两步（导入 + 解构），和 Python 的
from X import Y不同 @/是路径别名，避免写../../../_prefix表示”私不应该外部调用”（约定俗成）
二、异步处理 —— async/await 的核心概念
同步 vs 异步
// ❌ 同步：阻塞整个线程
const data = fetchData() // 线程卡住等待
// ✅ 异步：只暂停函数
async function handle() {
const data = await fetchData() // 只暂停这个函数
// 其他代码继续运行
}关键区别：
await= 等待 Promise 完成后才继续执行这个函数- Node.js 是单线程 + 事件循环，异步任务由事件循环调度
- 不能在非 async 函数中使用
await
三、语法糖 —— 扩展运算符和箭头函数
扩展运算符 ...
// 展开对象属性
const baseConfig = { a: 1, b: 2 }
const newConfig = {
...baseConfig, // 展开 a: 1, b: 2
c: 3 // 新增属性
}
// 结果: { a: 1, b: 2, c: 3 }
// 配合解构提取剩余属性
const { x, ...rest } = { x: 1, y: 2, z: 3 }
// x = 1, rest = { y: 2, z: 3 }箭头函数 =>
// 传统函数
array.map(function(item) {
return item * 2
})
// 箭头函数（简写）
array.map(item => item * 2)
// 完整形式（多行）
array.map(item => {
const result = item * 2
return result
})注意：箭头函数 不绑定 this，普通函数才会绑定
四、数组方法 —— map、filter、includes
includes — 检查是否存在
const options = ['public', 'private']
const userInput = 'public'
if (options.includes(userInput)) {
// userInput 在 options 中存在
}map — 转换数组
// 示例：转换每个元素
const items = [{ id: 1 }, { id: 2 }]
const newItems = items.map(item => ({
...item,
updated: true
}))filter — 筛选数组
// 示例：筛选满足条件的元素
const records = collection.filter(record => record.status === 'ENABLED')五、Koa 框架 —— 控制器模式
关键特点：没有 return，通过修改 ctx
// 控制器函数签名
async function handleRequest(ctx) {
// ctx.request — 读取请求信息
// ctx.body — 设置响应体（最终返回给客户端）
// ctx.status — 设置 HTTP 状态码
// 业务逻辑
const data = await fetchData()
// 设置响应（注意：没有 return！）
ctx.body = { result: data }
ctx.status = 200
}模式对比：
- Express：
res.send(data)或res.json(data) - Koa：
ctx.body = data并返回 - FastAPI：
return data
六、对象操作 —— 动态属性和条件赋值
动态属性访问
const obj = {}
const key = 'dynamicKey'
obj[key] = 'value' // 动态设置属性
console.log(obj.dynamicKey) // 'value'条件赋值
// 逻辑 OR（||）— 默认值
user.nickname ||= 'anonymous' // 如果 nickname 为空，设为 'anonymous'
// 三元运算符
const status = isActive ? 'active' : 'inactive'七、错误处理 —— try-catch 和断言
try-catch 捕获异步错误
async function safeOperation(ctx) {
try {
const result = await riskyOperation()
ctx.body = result
ctx.status = 200
} catch (err) {
ctx.body = { error: err.message }
ctx.status = 500
}
}断言（框架内置）
// Koa 框架提供的断言
ctx.assert(user, 404, 'User not found')
// 如果 user 为假，返回 404 和错误信息八、并发控制 —— Promise.all
并行执行多个异步任务
// 三个异步操作同时运行
const [user, posts, comments] = await Promise.all([
fetchUser(),
fetchPosts(),
fetchComments()
])优点：比顺序执行快，因为三个任务并行进行
九、数据库查询 —— Prisma 的 select 模式
声明式查询
// 定义需要返回的字段
const userSelect = {
id: true,
name: true,
email: true,
profile: { select: { avatar: true } } // 嵌套查询
}
// 查询时使用
const user = await db.user.findUnique({
where: { id: userId },
select: userSelect
})特点：
- 在构造查询前定义常量避免重复
_前缀表示内部使用的常量- 可以条件地添加字段（if 判断）
十、Node.js vs 其他语言
| 特性 | Node.js | Python | Go |
|---|---|---|---|
| 线程模型 | 单线程 + 事件循环 | 多线程（GIL 限制） | 多协程 |
| 包管理 | npm + package.json | pip + requirements.txt | go mod |
| 导入语法 | require() + 解构 | from X import Y | import |
| 异步 | async-await + Promise | async-await | goroutine + channel |
| this 绑定 | 函数类型决定 | 无 this 概念 | 无 this 概念 |
| 面向对象 | 原型链（类是语法糖） | 基于类 | 基于接口 |
十一、常见陷阱速查表
1. this 的陷阱
const obj = {
name: 'obj',
print: function() {
console.log(this.name) // ✅ 'obj'
},
arrowPrint: () => {
console.log(this.name) // ❌ undefined
}
}记住：只有普通函数 function() 绑定 this，箭头函数 => 不绑定
2. 闭包和作用域
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 0)
}
// 输出：3, 3, 3 ❌
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 0)
}
// 输出：0, 1, 2 ✅
// 使用 let 创建块级作用域3. 回调地狱（要用 async-await）
// ❌ 回调地狱
fetchUser(id, (err, user) => {
fetchPosts(user.id, (err, posts) => {
// 嵌套地狱...
})
})
// ✅ 用 async-await
const user = await fetchUser(id)
const posts = await fetchPosts(user.id)4. 类型松散
'5' + 3 // '53' ❌
'5' - 3 // 2 ✅
null == undefined // true ❌
null === undefined // false ✅
// 始终用 === 替代 ==十二、快速参考 —— 常用 API
// 数组方法
array.map(item => ...) // 转换
array.filter(item => ...) // 筛选
array.find(item => ...) // 查找单个
array.includes(item) // 检查存在
// 对象方法
Object.keys(obj) // 获取所有键
Object.entries(obj) // 获取 [key, value] 对
Object.assign(target, ...src) // 合并对象
// 字符串方法
str.includes(substring) // 检查包含
str.toUpperCase() // 大写
str.split(delimiter) // 分割
// 日期
new Date() // 当前时间
date.toISOString() // ISO 格式
// 异步
Promise.all([...]) // 并行执行
Promise.race([...]) // 竞速
await promise // 等待 Promise总结
| 概念 | 关键点 |
|---|---|
| 导包 | require() + 解构 = 两步法 |
| 异步 | async-await 暂停函数，不阻塞线程 |
| 语法糖 | ... 展开，=> 箭头函数 |
| 框架 | Koa 通过修改 ctx 返回结果 |
| 错误 | 用 try-catch 捕获 async 错误 |
| 并发 | Promise.all() 并行执行 |
最重要：理解异步和事件循环是 Node.js 的核心，其余大部分是语法糖。