多变量组合判断场景下嵌套Switch语句的优化方案咨询

嵌套Switch语句的弊端 #

直接说核心问题：

• 可读性差：多层嵌套会让逻辑变得晦涩，阅读者需要逐层跟踪分支，才能理清不同变量组合对应的结果，规则复杂时很容易看懵。
• 维护成本高：新增或修改规则时，得钻进嵌套层级里找对应的代码，稍不注意就会漏改或误改其他分支；规则越多，代码越臃肿，后期排查问题难度翻倍。
• 扩展性弱：如果以后要加新的判断维度（比如生产年份、车漆类型），嵌套层级会进一步加深，代码结构会越来越混乱，完全不符合“对扩展开放、对修改封闭”的设计原则。
• 冗余代码多：大量default分支返回相同结果，重复代码不仅增加了代码量，还可能出现不一致的错误（比如某个分支不小心写错返回值）。

更高效优雅的替代方案 #

方案1：配置对象映射（推荐） #

把所有规则用结构化的对象存储，将规则和业务逻辑分离，维护时只需要修改配置对象即可：

// 定义规则配置，清晰列出每个厂商的判断逻辑
const defectRules = {
  FORD: {
    validModels: ['puma', 'ranger', 'escape'],
    getResult: (color: string) => ['red', 'yellow'].includes(color) ? 'full paint defect' : 'no paint defect'
  },
  BMW: {
    validModels: ['x3', 'x7'],
    getResult: (color: string) => ['red', 'yellow'].includes(color) ? 'full paint defect' : 'no paint defect'
  },
  RENAULT: {
    modelResults: {
      clio: 'full paint defect',
      megane: 'partial paint defect',
      default: 'no paint defect'
    }
  },
  SEAT: {
    modelResults: {
      ibiza: 'full paint defect',
      default: 'no paint defect'
    }
  },
  AUDI: {
    getResult: (color: string) => color === 'blue' ? 'full paint defect' : 'no paint defect'
  },
  default: 'no paint defect'
};

function getPaintDefectSeverity(manufacturer: string, model: string, color: string): string {
  const manufRule = defectRules[manufacturer as keyof typeof defectRules] || defectRules.default;
  
  // 厂商直接对应固定结果的情况
  if (typeof manufRule === 'string') {
    return manufRule;
  }

  // 需判断车型+颜色的情况（FORD/BMW）
  if ('validModels' in manufRule && 'getResult' in manufRule) {
    return manufRule.validModels.includes(model) ? manufRule.getResult(color) : 'no paint defect';
  }

  // 只需判断车型的情况（RENAULT/SEAT）
  if ('modelResults' in manufRule) {
    return manufRule.modelResults[model as keyof typeof manufRule.modelResults] || manufRule.modelResults.default;
  }

  // 只需判断颜色的情况（AUDI）
  if ('getResult' in manufRule) {
    return manufRule.getResult(color);
  }

  return defectRules.default;
}

优势：规则一目了然，新增或修改规则只需调整defectRules，无需改动函数逻辑；代码结构清晰，可读性和维护性大幅提升。

方案2：策略模式 #

将每个厂商的判断逻辑封装为独立的策略函数，通过映射表关联厂商和对应的策略：

// 定义策略函数类型
type DefectStrategy = (model: string, color: string) => string;

// 每个厂商对应独立的策略函数
const strategies: Record<string, DefectStrategy> = {
  FORD: (model, color) => {
    const validModels = ['puma', 'ranger', 'escape'];
    return validModels.includes(model) && ['red', 'yellow'].includes(color) 
      ? 'full paint defect' 
      : 'no paint defect';
  },
  BMW: (model, color) => {
    const validModels = ['x3', 'x7'];
    return validModels.includes(model) && ['red', 'yellow'].includes(color) 
      ? 'full paint defect' 
      : 'no paint defect';
  },
  RENAULT: (model) => {
    switch(model) {
      case 'clio': return 'full paint defect';
      case 'megane': return 'partial paint defect';
      default: return 'no paint defect';
    }
  },
  SEAT: (model) => model === 'ibiza' ? 'full paint defect' : 'no paint defect',
  AUDI: (_, color) => color === 'blue' ? 'full paint defect' : 'no paint defect'
};

function getPaintDefectSeverity(manufacturer: string, model: string, color: string): string {
  // 匹配对应策略，没有则返回默认结果
  return strategies[manufacturer]?.(model, color) || 'no paint defect';
}

优势：每个厂商的逻辑完全解耦，修改单个厂商规则不会影响其他厂商；适合规则差异较大、需要独立维护的场景。

方案3：函数式规则匹配 #

把所有规则整理成数组，依次匹配第一个符合条件的规则并返回结果：

function getPaintDefectSeverity(manufacturer: string, model: string, color: string): string {
  const rules = [
    // FORD/BMW 车型+颜色匹配
    {
      isMatch: () => ['FORD', 'BMW'].includes(manufacturer) && 
                     ['puma', 'ranger', 'escape', 'x3', 'x7'].includes(model) && 
                     ['red', 'yellow'].includes(color),
      result: 'full paint defect'
    },
    // RENAULT/SEAT 指定车型匹配
    {
      isMatch: () => ['RENAULT', 'SEAT'].includes(manufacturer) && ['clio', 'ibiza'].includes(model),
      result: 'full paint defect'
    },
    // RENAULT Megane 特殊匹配
    {
      isMatch: () => manufacturer === 'RENAULT' && model === 'megane',
      result: 'partial paint defect'
    },
    // AUDI 颜色匹配
    {
      isMatch: () => manufacturer === 'AUDI' && color === 'blue',
      result: 'full paint defect'
    },
    // 默认规则
    {
      isMatch: () => true,
      result: 'no paint defect'
    }
  ];

  return rules.find(rule => rule.isMatch())?.result || 'no paint defect';
}

优势：所有规则按顺序排列，逻辑直观；新增规则只需在数组中添加一项，无需修改现有逻辑，适合规则数量较少的场景。

内容的提问来源于stack exchange，提问作者J145