Scala无Union类型时，多参数类型函数的最优实现方案

嘿，针对你遇到的Scala里三个参数类型不同但逻辑完全一致的函数重复问题，我给你整理了几个靠谱的优化方案，你可以根据自己的代码风格和场景选择：

方案1：借助隐式转换简化实现 #

因为你的三个函数核心都是调用ProcessBuilder的!!方法，而String和Seq[String]本身就可以被Scala隐式转换成ProcessBuilder，所以我们只需要保留一个处理ProcessBuilder的核心函数，再补上对应的隐式转换即可：

import scala.sys.process._

// 唯一的核心函数，处理ProcessBuilder类型
def runCommand(command: ProcessBuilder): String = {
  // 这里放你原来的业务逻辑
  command.!!
}

// 让String自动转为ProcessBuilder的隐式转换
implicit def stringToProcessBuilder(cmd: String): ProcessBuilder = cmd
// 让Seq[String]自动转为ProcessBuilder的隐式转换
implicit def seqStringToProcessBuilder(cmd: Seq[String]): ProcessBuilder = cmd

之后你直接调用runCommand("echo hello")或者runCommand(Seq("echo", "hello"))都能正常工作，完全不用写三个重复的函数啦。

方案2：提取公共逻辑+函数重载 #

如果你觉得隐式转换有点“魔法”，不想依赖它，那可以把重复的逻辑抽成一个私有函数，然后用函数重载来对外暴露不同参数类型的接口：

import scala.sys.process._

// 私有函数，封装所有公共逻辑
private def executeCoreCommand(builder: ProcessBuilder): String = {
  // 这里放你原来的业务逻辑
  builder.!!
}

// 对外的重载函数，都调用核心逻辑
def runCommand(command: String): String = executeCoreCommand(command)
def runCommand(command: Seq[String]): String = executeCoreCommand(command)
def runCommand(command: ProcessBuilder): String = executeCoreCommand(command)

这种方式非常直观，代码可读性拉满，团队里的其他小伙伴一看就懂。

方案3：用类型类实现高扩展性 #

如果想更贴合Scala的函数式风格，并且希望以后能轻松支持更多命令类型，那类型类（Type Class）是个不错的选择：

import scala.sys.process._

// 定义类型类，抽象出执行命令的行为
trait CommandExecutor[T] {
  def execute(cmd: T): String
}

// 为String实现类型类实例
implicit val stringExecutor: CommandExecutor[String] = 
  (cmd: String) => cmd.!!

// 为Seq[String]实现类型类实例
implicit val seqStringExecutor: CommandExecutor[Seq[String]] = 
  (cmd: Seq[String]) => cmd.!!

// 为ProcessBuilder实现类型类实例
implicit val processBuilderExecutor: CommandExecutor[ProcessBuilder] = 
  (cmd: ProcessBuilder) => cmd.!!

// 对外统一的调用入口
def runCommand[T](command: T)(implicit executor: CommandExecutor[T]): String = {
  executor.execute(command)
}

这种方式的好处是扩展性极强——以后如果要支持新的命令输入类型，只需要新增一个对应的CommandExecutor实例就行，完全不用修改原有的runCommand函数。

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