如何在Flutter/Dart中避免使用嵌套switch语句？

方案1：用映射表（Map）直接关联组合逻辑 #

把DayOfWeek和WeekOfMonth的组合作为键，对应的处理逻辑作为值，直接通过Map查找执行，完全避免嵌套结构。

示例代码：

enum DayOfWeek { sun, mon, tues, wed, thurs, fri, sat }
enum WeekOfMonth { first, second, third, fourth, fifth }

// 定义处理逻辑的函数类型
typedef Handler = void Function();

void main() {
  const day = DayOfWeek.sun;
  const week = WeekOfMonth.first;

  // 创建映射表，键是(DayOfWeek, WeekOfMonth)元组
  final handlerMap = <(DayOfWeek, WeekOfMonth), Handler>{
    (DayOfWeek.sun, WeekOfMonth.first): () => print("周日第一周处理逻辑"),
    (DayOfWeek.sun, WeekOfMonth.second): () => print("周日第二周处理逻辑"),
    (DayOfWeek.mon, WeekOfMonth.first): () => print("周一第一周处理逻辑"),
    // 按需补充其他组合
  };

  // 执行对应逻辑，可添加默认处理
  handlerMap[(day, week)]?.call() ?? print("默认处理逻辑");
}

如果部分组合逻辑相同，可以批量赋值，比如周日的第三、四、五周逻辑一致：

final commonSunHandler = () => print("周日第三/四/五周通用逻辑");
handlerMap.addAll({
  (DayOfWeek.sun, WeekOfMonth.third): commonSunHandler,
  (DayOfWeek.sun, WeekOfMonth.fourth): commonSunHandler,
  (DayOfWeek.sun, WeekOfMonth.fifth): commonSunHandler,
});

方案2：封装策略类拆分职责 #

针对每个DayOfWeek创建对应的策略类，类内部处理WeekOfMonth的分支逻辑，把嵌套的层级拆分成独立的类，符合单一职责原则。

示例代码：

enum DayOfWeek { sun, mon, tues, wed, thurs, fri, sat }
enum WeekOfMonth { first, second, third, fourth, fifth }

abstract class DayStrategy {
  void handleWeek(WeekOfMonth week);
}

class SundayStrategy implements DayStrategy {
  @override
  void handleWeek(WeekOfMonth week) {
    switch (week) {
      case WeekOfMonth.first:
        print("周日第一周处理");
        break;
      case WeekOfMonth.second:
        print("周日第二周处理");
        break;
      default:
        print("周日其他周通用处理");
    }
  }
}

class MondayStrategy implements DayStrategy {
  @override
  void handleWeek(WeekOfMonth week) {
    // 周一对应的周处理逻辑
  }
}

// 其他日期的策略类同理

void main() {
  const day = DayOfWeek.sun;
  const week = WeekOfMonth.first;

  // 映射日期到对应的策略类
  final strategyMap = <DayOfWeek, DayStrategy>{
    DayOfWeek.sun: SundayStrategy(),
    DayOfWeek.mon: MondayStrategy(),
    // 补充其他日期
  };

  strategyMap[day]?.handleWeek(week) ?? print("默认处理");
}

方案3：使用扩展方法分散逻辑 #

给DayOfWeek添加扩展方法，接收WeekOfMonth作为参数，把原本嵌套的逻辑分散到每个枚举值的扩展方法中，代码更直观。

示例代码：

enum DayOfWeek { sun, mon, tues, wed, thurs, fri, sat }
enum WeekOfMonth { first, second, third, fourth, fifth }

extension DayHandler on DayOfWeek {
  void handleWeek(WeekOfMonth week) {
    switch (this) {
      case DayOfWeek.sun:
        _handleSundayWeek(week);
        break;
      case DayOfWeek.mon:
        _handleMondayWeek(week);
        break;
      // 其他日期分支
      default:
        print("默认处理");
    }
  }

  void _handleSundayWeek(WeekOfMonth week) {
    switch (week) {
      case WeekOfMonth.first:
        print("周日第一周处理");
        break;
      case WeekOfMonth.second:
        print("周日第二周处理");
        break;
      default:
        print("周日通用处理");
    }
  }

  void _handleMondayWeek(WeekOfMonth week) {
    // 周一的周处理逻辑
  }
}

void main() {
  const day = DayOfWeek.sun;
  const week = WeekOfMonth.first;
  day.handleWeek(week);
}

选择建议 #

• 如果逻辑简单、组合较少，优先用映射表，代码最简洁；
• 如果逻辑复杂、每个日期的周处理差异大，用策略类，便于维护和扩展；
• 想保持枚举的内聚性，用扩展方法，逻辑和枚举绑定更紧密。

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