代码审查清单模板：先看行为，再看风格

// ❌ 坏做法：直接取嵌套属性，不做任何防御
function ProductDetail({ data }: { data: ApiResponse }) {
  const name = data.items[0].name
  return <h1>{name}</h1>
}
 
// ✅ 好做法：先判断数据是否存在，空数据给兜底
function ProductDetail({ data }: { data: ApiResponse }) {
  const firstItem = data.items?.[0]
  if (!firstItem) {
    return <EmptyState text="该分类下暂无商品" />
  }
  return <h1>{firstItem.name}</h1>
}

// ❌ 坏做法：只在路由层做权限判断，接口不校验
// app/admin/orders/[id]/route.ts
export async function DELETE(req: Request) {
  const session = await getSession()
  if (!session) return Response.json({ error: '未登录' }, { status: 401 })
 
  // 直接删除，没有检查角色和归属
  await db.order.delete({ where: { id: params.id } })
  return new Response(null, { status: 204 })
}
 
// ✅ 好做法：接口层独立校验角色和资源归属
export async function DELETE(
  req: Request,
  { params }: { params: { id: string } }
) {
  const session = await getSession()
  if (!session) return Response.json({ error: '未登录' }, { status: 401 })
 
  // 角色校验：只有管理员能操作
  if (session.role !== 'admin') {
    return Response.json({ error: '无权限' }, { status: 403 })
  }
 
  const order = await db.order.findUnique({ where: { id: params.id } })
  if (!order) {
    return Response.json({ error: '订单不存在' }, { status: 404 })
  }
 
  await db.order.delete({ where: { id: params.id } })
  return new Response(null, { status: 204 })
}

// ❌ 坏做法：字符串拼接 SQL
async function searchOrders(keyword: string) {
  const sql = `SELECT * FROM orders WHERE description LIKE '%${keyword}%'`
  return db.$queryRawUnsafe(sql)
}

// ✅ 好做法：参数化查询，数据库驱动自动转义
async function searchOrders(keyword: string) {
  return db.$queryRaw`
    SELECT * FROM orders
    WHERE description LIKE ${`%${keyword}%`}
  `
}

// ❌ 坏做法：吞掉异常，外层无法感知失败
async function syncUserData(userId: string) {
  try {
    const data = await fetchUserFromExternal(userId)
    await db.user.update({ data })
  } catch (e) {
    console.log('同步失败')
    // 异常被吞没，调用方不知道失败了
    // 日志只有一句话，没有 userId、没有堆栈
  }
}
 
// ✅ 好做法：向上传播错误，日志包含上下文
async function syncUserData(userId: string) {
  try {
    const data = await fetchUserFromExternal(userId)
    await db.user.update({ data })
  } catch (error) {
    // 日志包含关键上下文，方便排查
    logger.error('同步用户数据失败', {
      userId,
      error: error instanceof Error ? error.message : String(error),
      stack: error instanceof Error ? error.stack : undefined,
    })
    // 向上抛出，让调用方决定如何处理
    throw new SyncError(`用户 ${userId} 数据同步失败`, { cause: error })
  }
}

// ❌ 坏做法：N+1 查询，每个订单单独查用户信息
async function getOrderList() {
  const orders = await db.order.findMany()
  return Promise.all(
    orders.map(async (order) => {
      const user = await db.user.findUnique({
        where: { id: order.userId },
      })
      return { ...order, userName: user?.name }
    })
  )
}
 
// ✅ 好做法：用 include 一次查出关联数据
async function getOrderList() {
  const orders = await db.order.findMany({
    include: {
      user: { select: { name: true } },
    },
  })
  return orders.map((order) => ({
    ...order,
    userName: order.user.name,
  }))
}

// ❌ 坏做法：日志里打印完整 token 和密码
function handleLogin(email: string, password: string, token: string) {
  logger.info('用户登录', { email, password, token })
  // token 和密码都进了日志系统，可能被任何人看到
}
 
// ✅ 好做法：只记录必要信息，敏感字段脱敏
function handleLogin(email: string, password: string, token: string) {
  logger.info('用户登录', {
    email: maskEmail(email),       // a***@example.com
    password: '[REDACTED]',
    token: token.slice(0, 8) + '...', // 只保留前8位
  })
}

// ❌ 坏做法：在渲染函数里直接修改外部状态
let requestCount = 0
 
function Dashboard() {
  requestCount++
  // 每次渲染都会 +1，包括 React StrictMode 下的双重渲染
  // 在并发模式下更不可预测
  const data = useQuery(['stats'], () => fetchStats(requestCount))
  return <div>请求次数：{requestCount}</div>
}
 
// ✅ 好做法：用 ref 跟踪副作用，不污染渲染
function Dashboard() {
  const countRef = useRef(0)
 
  const data = useQuery(['stats'], () => {
    countRef.current++
    return fetchStats(countRef.current)
  })
 
  return <div>请求次数：{countRef.current}</div>
}