如何减少字符串条件判断中的else if语句？以货币转换终端程序为例

针对终端程序中大量字符串条件判断的问题，有几种更易维护的实现方式，核心思路是将命令与处理逻辑解耦，避免修改主循环的判断代码：

1. 哈希表（字典）映射命令到处理函数 #

这是最直接高效的方案，将命令字符串作为键，对应的处理函数作为值存入哈希表，新增命令仅需添加映射条目，无需修改循环逻辑。

C++ 示例 #

#include <unordered_map>
#include <string>
#include <sstream>
#include <iostream>

// 定义命令处理函数类型
using CommandHandler = void(*)(const std::string&);

// 具体命令处理逻辑
void convertCurrency(const std::string& args) {
    std::cout << "执行货币转换，参数：" << args << std::endl;
}

void listCurrencies(const std::string& args) {
    std::cout << "列出所有支持的货币" << std::endl;
}

void showHelp(const std::string& args) {
    std::cout << "可用命令：convert [源货币] [目标货币] [金额]、list、help" << std::endl;
}

int main() {
    // 初始化命令映射表
    std::unordered_map<std::string, CommandHandler> commandMap = {
        {"convert", convertCurrency},
        {"list", listCurrencies},
        {"help", showHelp}
    };

    std::string input;
    while (std::getline(std::cin, input)) {
        std::istringstream iss(input);
        std::string cmd;
        iss >> cmd;

        // 查找并执行命令
        auto it = commandMap.find(cmd);
        if (it != commandMap.end()) {
            std::string args;
            std::getline(iss >> std::ws, args); // 读取命令参数
            it->second(args);
        } else {
            std::cout << "未知命令，请输入help查看帮助" << std::endl;
        }
    }
    return 0;
}

Python 示例 #

def convert_currency(args):
    print(f"执行货币转换，参数：{args}")

def list_currencies(args):
    print("列出所有支持的货币：USD、EUR、CNY、JPY")

def show_help(args):
    print("可用命令：convert [源货币] [目标货币] [金额]、list、help")

# 命令映射字典
command_map = {
    "convert": convert_currency,
    "list": list_currencies,
    "help": show_help
}

while True:
    input_cmd = input("> ").strip()
    if not input_cmd:
        continue
    # 拆分命令与参数
    cmd_parts = input_cmd.split(maxsplit=1)
    cmd = cmd_parts[0]
    args = cmd_parts[1] if len(cmd_parts) > 1 else ""

    handler = command_map.get(cmd)
    if handler:
        handler(args)
    else:
        print("未知命令，请输入help查看帮助")

2. 命令模式（适用于复杂命令场景） #

如果每个命令需要维护独立状态或有复杂的初始化逻辑，可将命令封装为实现统一接口的类，扩展性更强。

C++ 示例 #

#include <unordered_map>
#include <memory>
#include <string>

// 命令接口
class Command {
public:
    virtual ~Command() = default;
    virtual void execute(const std::string& args) = 0;
};

// 具体命令类
class ConvertCommand : public Command {
public:
    void execute(const std::string& args) override {
        // 实现货币转换逻辑，可维护内部状态
        std::cout << "执行货币转换，参数：" << args << std::endl;
    }
};

class ListCommand : public Command {
public:
    void execute(const std::string& args) override {
        std::cout << "列出所有支持的货币" << std::endl;
    }
};

int main() {
    std::unordered_map<std::string, std::unique_ptr<Command>> commandMap;
    commandMap["convert"] = std::make_unique<ConvertCommand>();
    commandMap["list"] = std::make_unique<ListCommand>();

    // 主循环逻辑同哈希表方案，调用时执行command->execute(args)
    return 0;
}

3. 字符串转枚举后用switch（适用于固定命令集） #

若命令集相对固定，可先将输入字符串转换为枚举值，再用switch判断，可读性优于大量else if，但新增命令仍需修改转换函数和switch分支。

C++ 示例 #

enum class CommandType {
    Convert,
    List,
    Help,
    Unknown
};

CommandType getCommandType(const std::string& cmd) {
    if (cmd == "convert") return CommandType::Convert;
    if (cmd == "list") return CommandType::List;
    if (cmd == "help") return CommandType::Help;
    return CommandType::Unknown;
}

// 主循环中
std::string cmd;
// 读取cmd后
switch (getCommandType(cmd)) {
    case CommandType::Convert:
        convertCurrency(args);
        break;
    case CommandType::List:
        listCurrencies(args);
        break;
    case CommandType::Help:
        showHelp(args);
        break;
    default:
        std::cout << "未知命令" << std::endl;
}

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