从"会写代码"到"写对代码"：7 个让我顿悟的工程师思维模式

用户输入
  └─ if (user)
       └─ if (input.email)
            └─ if (user.canEdit)
                 └─ 真正的业务逻辑  ← 读到这里眼睛已经累了

async function updateUserProfile(userId: string, input: ProfileInput) {
const user = await getUser(userId);
if (!user) thrownew NotFoundError('用户不存在');

if (!input.email) thrownew ValidationError('邮箱不能为空');

if (!user.canEditProfile) thrownew ForbiddenError('无权修改资料');

// 到这里，所有异常已经被清空，这一行就是全部重点
return saveProfile(user.id, input);
}

// JavaScript 版本
asyncfunction updateUserProfile(userId, input) {
const user = await getUser(userId);
if (!user) thrownewError('用户不存在');
if (!input.email) thrownewError('邮箱不能为空');
if (!user.canEditProfile) thrownewError('无权修改资料');

return saveProfile(user.id, input);
}

// 这段代码在干什么？
const result = await getData(id);
if (result.status === 'active') {
  await process(result);
}

const subscription = await getSubscription(subscriptionId);
if (subscription.isBillable) {
  await chargeSubscription(subscription);
}

// ❌ 外部结构直接泄漏进业务逻辑
const userName = response.data.user_name;
const isVip = response.data.member_level === 'VIP';
const expireAt = response.data.expire_ts * 1000; // 还要做单位转换

// ✅ 外部数据只在一处被消化
function mapMemberInfo(response: ThirdPartyMemberResponse): MemberInfo {
  return {
    name: response.data.user_name,
    isVip: response.data.member_level === 'VIP',
    expireAt: new Date(response.data.expire_ts * 1000),
  };
}

第三方 API 响应
      │
      ▼
┌─────────────┐
│  mapMember  │  ← 唯一知道外部格式的地方
│  Info()     │
└──────┬──────┘
       │
       ▼
  内部 MemberInfo
  ┌──────────────────┐
  │  业务逻辑         │
  │  UI 组件          │  ← 只认识你自己定义的类型
  │  数据库写入       │
  └──────────────────┘

type User = {
  id?: string;
  email?: string;
  role?: string;
  status?: string;
};

// 未保存的草稿用户
type DraftUser = {
  email: string;
  role: 'admin' | 'member';
};

// 已入库的用户
type SavedUser = {
  id: string;
  email: string;
  role: 'admin' | 'member';
  status: 'active' | 'disabled';
};

type Payment =
  | { state: 'pending'; id: string }
  | { state: 'authorized'; id: string; authCode: string }
  | { state: 'captured'; id: string; receiptNo: string }
  | { state: 'failed'; id: string; failReason: string };

// 发送收据只接受"已扣款"状态的支付，编译期就能保证
function sendReceipt(payment: Extract<Payment, { state: 'captured' }>) {
  return emailReceipt(payment.receiptNo);
}

async function refundOrder(orderId: string) {
const order = await getOrder(orderId);

if (order.status !== 'paid') thrownewError('订单未支付');
if (order.refundedAt) thrownewError('已退款');
if (order.amount <= 0) thrownewError('金额异常');

await paymentGateway.refund(order.paymentId);
await markOrderRefunded(order.id);
await sendRefundEmail(order.userId);
}

function getRefundEligibility(order: Order): RefundEligibility {
  if (order.status !== 'paid') return { allowed: false, reason: '订单未支付' };
  if (order.refundedAt) return { allowed: false, reason: '已退款，请勿重复操作' };
  if (order.amount <= 0) return { allowed: false, reason: '退款金额异常' };
  return { allowed: true };
}

决策层（纯函数，无副作用）
┌──────────────────────┐
│  getRefundEligibility│  ← 只做判断，不碰外部世界
│  (order) → allowed?  │  ← 随便测，不需要 mock 任何东西
└──────────┬───────────┘
           │ allowed: true
           ▼
执行层（有副作用）
┌──────────────────────┐
│  paymentGateway      │
│  markOrderRefunded   │  ← 只在决策通过后才触发
│  sendRefundEmail     │
└──────────────────────┘

async function refundOrder(orderId: string) {
const order = await getOrder(orderId);
const eligibility = getRefundEligibility(order);

if (!eligibility.allowed) thrownew ValidationError(eligibility.reason);

await paymentGateway.refund(order.paymentId);
await markOrderRefunded(order.id);
await sendRefundEmail(order.userId);
}

// ❌ 没有诊断价值的错误
throw new Error('操作失败');

// ✅ 有机器可读编码 + 人类可读描述 + 上下文信息
throw new BusinessError({
  code: 'ORDER_ALREADY_REFUNDED',
  message: '该订单已完成退款，如有疑问请联系客服',
  details: { orderId, refundedAt: order.refundedAt },
  requestId,
});

// ❌ 前端被迫解析字符串，脆得一碰就断
if (error.message.includes('已退款')) {
  showDuplicateRefundTip();
}

// ✅ 前端通过 code 判断，稳定可靠
if (error.code === 'ORDER_ALREADY_REFUNDED') {
  showDuplicateRefundTip();
}

logger.warn('退款资格校验未通过', {
  orderId,
  userId,
  reason: eligibility.reason,
  requestId,
});

feat: 完善支付流程

- 重构发票服务
- 重命名支付字段
- 修改退款逻辑
- 更新 Dashboard UI
- 新增 Webhook 处理
- 修复账户状态 Bug
- 更新单元测试

PR 1：重命名支付字段（纯重构，无行为变更）
PR 2：提取退款资格校验函数（+测试）
PR 3：将退款资格校验接入支付流程
PR 4：更新 Dashboard 展示退款原因
PR 5：新增 Webhook 重试机制

一个好的 PR diff 应该能回答三个问题：
┌──────────────────────────────────┐
│  改了什么？（What changed）       │
│  为什么改？（Why it changed）     │
│  现在行为有什么不同？（New behavior）│
└──────────────────────────────────┘