Swift：如何用switch-case处理嵌套枚举？

嘿，我明白你现在遇到的问题了——嵌套枚举想用switch-case处理，但手里只有父、子两个整数变量，试了方法还跑不起来。我来给你两种可行的思路，你可以根据自己的场景选：

思路一：扁平化枚举结构（更适合switch-case） #

如果你的核心需求是通过两个整数快速匹配到Iron这类具体值并处理，把所有具体枚举值扁平化到一个枚举类里会是最省心的方案。我们可以给每个具体值绑定分类信息和自定义的编码，这样只需要一次switch就能搞定。

举个Java的例子（其他语言逻辑类似）：

// 扁平化的枚举，包含所有具体矿物，同时附带分类
enum Mineral {
    IRON(1, MineralCategory.METAL),
    COPPER(2, MineralCategory.METAL),
    GOLD(3, MineralCategory.METAL),
    CARBON(4, MineralCategory.NON_METAL),
    SULFUR(5, MineralCategory.NON_METAL);

    private final int code; // 每个具体值的唯一编码
    private final MineralCategory category; // 所属分类

    Mineral(int code, MineralCategory category) {
        this.code = code;
        this.category = category;
    }

    // 根据编码获取对应的枚举值（替代直接用ordinal，避免顺序变动出问题）
    public static Mineral fromCode(int code) {
        for (Mineral mineral : values()) {
            if (mineral.code == code) return mineral;
        }
        throw new IllegalArgumentException("无效的矿物编码: " + code);
    }

    // 单独的分类枚举，用来做逻辑分组
    enum MineralCategory {
        METAL, NON_METAL
    }
}

接下来你只需要把两个整数转换成对应的Mineral枚举值（比如写个工具方法，根据分类码和子分类码映射到唯一的矿物编码），然后直接switch：

// 假设你拿到的两个整数：categoryInt对应分类，subCategoryInt对应子分类
int categoryInt = 0; // 0对应METAL
int subCategoryInt = 0; // 0对应IRON

// 先把两个整数转成Mineral枚举（这里的映射逻辑你可以根据自己的编码规则调整）
Mineral targetMineral = mapCodesToMineral(categoryInt, subCategoryInt);

// 直接switch处理
switch(targetMineral) {
    case IRON:
        // 处理Iron的逻辑
        System.out.println("处理铁矿石");
        break;
    case COPPER:
        System.out.println("处理铜矿");
        break;
    case CARBON:
        System.out.println("处理碳");
        break;
    // 其他case...
}

这种方式的好处是代码简洁，switch逻辑清晰，不需要嵌套，而且枚举的扩展性也不错。

思路二：保留嵌套枚举，用嵌套switch处理 #

如果你一定要保留嵌套的枚举结构（比如分类逻辑需要独立维护），那可以先把两个整数分别转换成父枚举和对应的子枚举，再用嵌套的switch-case处理。

先给嵌套枚举加上自定义编码和转换方法（别依赖枚举的ordinal，不然枚举顺序一变就炸）：

enum MineralCategory {
    METAL(0), NON_METAL(1);

    private final int code;

    MineralCategory(int code) {
        this.code = code;
    }

    // 根据编码获取父枚举
    public static MineralCategory fromCode(int code) {
        for (MineralCategory category : values()) {
            if (category.code == code) return category;
        }
        throw new IllegalArgumentException("无效的分类编码: " + code);
    }

    // 嵌套的金属枚举
    enum Metal {
        IRON(0), COPPER(1), GOLD(2);

        private final int code;

        Metal(int code) {
            this.code = code;
        }

        public static Metal fromCode(int code) {
            for (Metal metal : values()) {
                if (metal.code == code) return metal;
            }
            throw new IllegalArgumentException("无效的金属编码: " + code);
        }
    }

    // 嵌套的非金属枚举
    enum NonMetal {
        CARBON(0), SULFUR(1);

        private final int code;

        NonMetal(int code) {
            this.code = code;
        }

        public static NonMetal fromCode(int code) {
            for (NonMetal nonMetal : values()) {
                if (nonMetal.code == code) return nonMetal;
            }
            throw new IllegalArgumentException("无效的非金属编码: " + code);
        }
    }
}

然后用嵌套switch处理：

int categoryInt = 0;
int subCategoryInt = 0;

try {
    // 先转成父枚举
    MineralCategory category = MineralCategory.fromCode(categoryInt);
    switch(category) {
        case METAL:
            // 转成金属子枚举，再switch
            MineralCategory.Metal metal = MineralCategory.Metal.fromCode(subCategoryInt);
            switch(metal) {
                case IRON:
                    System.out.println("处理Iron");
                    break;
                case COPPER:
                    System.out.println("处理Copper");
                    break;
            }
            break;
        case NON_METAL:
            // 转成非金属子枚举，再switch
            MineralCategory.NonMetal nonMetal = MineralCategory.NonMetal.fromCode(subCategoryInt);
            switch(nonMetal) {
                case CARBON:
                    System.out.println("处理Carbon");
                    break;
            }
            break;
    }
} catch (IllegalArgumentException e) {
    // 处理无效编码的情况
    System.out.println("编码无效，请检查输入");
}

这种方式适合分类逻辑比较独立的场景，但代码会多一层嵌套，维护起来需要注意父、子枚举的对应关系。

总结一下：如果只是为了方便switch-case处理具体值，优先选扁平化的枚举；如果分类逻辑需要单独管理，再考虑嵌套枚举加嵌套switch的方案。

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