🚀 Claude Code新人完全指南：5天完成6周工作量，8-9倍效率提升

// 问题代码
function calculateTotalWithCoupon(subtotal, coupon) {
  const discount = subtotal * (coupon.percentage / 100); // ❌ 浮点数运算
  const total = subtotal - discount;
  return total; // ❌ 没有处理精度
}

// 某些情况下的计算结果
// subtotal = 199.99
// coupon.percentage = 15
// discount = 29.99850000000000034 ← 浮点数误差！
// total = 169.99149999999999...

const Decimal = require('decimal.js');

function calculateTotalWithCoupon(subtotal, coupon) {
  const subtotalDecimal = new Decimal(subtotal);
  const discountPercent = new Decimal(coupon.percentage).div(100);
  const discount = subtotalDecimal.times(discountPercent);
  const total = subtotalDecimal.minus(discount);
  return total.toFixed(2); // 精确到2位小数
}

describe('priceCalculator', () => {
  test('应该正确处理浮点数精度问题', () => {
    const result = calculateTotalWithCoupon(199.99, { percentage: 15 });
    expect(result).toBe('169.99'); // 精确值
  });

  test('应该正确处理多重折扣', () => {
    const result = calculateTotalWithMultipleCoupons(99.99, [
      { percentage: 10 },
      { percentage: 5 }
    ]);
    expect(result).toBe('85.49');
  });

  test('应该处理极小金额', () => {
    const result = calculateTotalWithCoupon(0.01, { percentage: 50 });
    expect(result).toBe('0.01'); // 最小金额保护
  });

  test('应该处理100%折扣', () => {
    const result = calculateTotalWithCoupon(199.99, { percentage: 100 });
    expect(result).toBe('0.00');
  });
});

// 重构后的架构
payment-service/src/
├── strategies/
│   ├── PaymentStrategy.js      ← 抽象接口
│   ├── StripeStrategy.js       ← Stripe 实现
│   └── PayPalStrategy.js       ← PayPal 实现
├── factories/
│   └── PaymentStrategyFactory.js
├── services/
│   ├── PaymentValidator.js     ← 验证逻辑分离
│   ├── PaymentLogger.js        ← 日志逻辑分离
│   └── PaymentNotifier.js      ← 通知逻辑分离
└── controllers/
    └── paymentController.js    ← 简化为编排逻辑

// 提取前
async function processPayment(req, res) {
  // 验证逻辑（50行）
  if (!req.body.amount) { ... }
  if (!req.body.currency) { ... }
  if (!req.body.paymentMethod) { ... }
  // ... 更多验证

  // 支付逻辑（200行）
  // ...
}

// 提取后
class PaymentValidator {
  static validate(paymentData) {
    const errors = [];

    if (!paymentData.amount || paymentData.amount <= 0) {
      errors.push('Invalid amount');
    }

    if (!['USD', 'EUR', 'GBP', 'CNY'].includes(paymentData.currency)) {
      errors.push('Unsupported currency');
    }

    if (!['stripe', 'paypal'].includes(paymentData.paymentMethod)) {
      errors.push('Unsupported payment method');
    }

    return {
      isValid: errors.length === 0,
      errors
    };
  }
}

// 重构后的 controller
async function processPayment(req, res) {
  const { isValid, errors } = PaymentValidator.validate(req.body);
  if (!isValid) {
    return res.status(400).json({ errors });
  }

  // 核心逻辑更清晰...
}

// models/Promotion.js
const { DataTypes } = require('sequelize');

module.exports = (sequelize) => {
  const Promotion = sequelize.define('Promotion', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
      allowNull: false
    },
    type: {
      type: DataTypes.ENUM('threshold_discount', 'percentage'),
      allowNull: false
    },
    threshold: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    discountValue: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    startDate: {
      type: DataTypes.DATE,
      allowNull: false
    },
    endDate: {
      type: DataTypes.DATE,
      allowNull: false
    },
    isActive: {
      type: DataTypes.BOOLEAN,
      defaultValue: true
    }
  });

  return Promotion;
};

// controllers/promotionController.js
// ... (完整的 CRUD 实现)

// tests/promotion.test.js
// ... (完整的测试用例)

/**
 * 计算最优优惠组合
 * @param {number} subtotal - 订单原价
 * @param {Array} promotions - 可用的满减活动
 * @param {Array} coupons - 可用的优惠券
 * @returns {Object} 最优优惠方案
 */
function calculateOptimalDiscount(subtotal, promotions, coupons) {
  const Decimal = require('decimal.js');
  let bestDiscount = new Decimal(0);
  let bestCombination = null;

  // 筛选满足条件的满减活动
  const eligiblePromotions = promotions.filter(p =>
    new Decimal(subtotal).gte(p.threshold) && p.isActive
  );

  // 尝试所有组合（满减 + 优惠券）
  for (const promotion of eligiblePromotions) {
    for (const coupon of coupons) {
      const result = applyDiscounts(subtotal, promotion, coupon);
      if (result.totalDiscount.gt(bestDiscount)) {
        bestDiscount = result.totalDiscount;
        bestCombination = {
          promotion,
          coupon,
          finalPrice: result.finalPrice,
          breakdown: result.breakdown
        };
      }
    }
  }

  return bestCombination;
}

function applyDiscounts(subtotal, promotion, coupon) {
  const Decimal = require('decimal.js');
  let price = new Decimal(subtotal);
  const breakdown = [];

  // 1. 先应用满减
  if (promotion) {
    const promoDiscount = new Decimal(promotion.discountValue);
    price = price.minus(promoDiscount);
    breakdown.push({
      type: 'promotion',
      amount: promoDiscount.toFixed(2),
      description: `满${promotion.threshold}减${promotion.discountValue}`
    });
  }

  // 2. 再应用优惠券（基于满减后的价格）
  if (coupon) {
    const couponDiscount = price.times(coupon.percentage).div(100);
    price = price.minus(couponDiscount);
    breakdown.push({
      type: 'coupon',
      amount: couponDiscount.toFixed(2),
      description: `${coupon.percentage}% 折扣券`
    });
  }

  const totalDiscount = new Decimal(subtotal).minus(price);

  return {
    finalPrice: price.toFixed(2),
    totalDiscount,
    breakdown
  };
}