parsing命令行参数的最佳方法是什么？

在Scala中parsing命令行参数的最好方法是什么？ 我个人更喜欢轻量级，不需要外部的jar子。

有关：

• parsing命令行参数的Java库？
• C ++有哪些参数parsing器库？
• 在C＃中parsing命令行参数的最佳方法

Answer 1

对于大多数情况下，您不需要外部parsing器。 Scala的模式匹配允许以function样式消耗参数。 例如：

object MmlAlnApp { val usage = """ Usage: mmlaln [--min-size num] [--max-size num] filename """ def main(args: Array[String]) { if (args.length == 0) println(usage) val arglist = args.toList type OptionMap = Map[Symbol, Any] def nextOption(map : OptionMap, list: List[String]) : OptionMap = { def isSwitch(s : String) = (s(0) == '-') list match { case Nil => map case "--max-size" :: value :: tail => nextOption(map ++ Map('maxsize -> value.toInt), tail) case "--min-size" :: value :: tail => nextOption(map ++ Map('minsize -> value.toInt), tail) case string :: opt2 :: tail if isSwitch(opt2) => nextOption(map ++ Map('infile -> string), list.tail) case string :: Nil => nextOption(map ++ Map('infile -> string), list.tail) case option :: tail => println("Unknown option "+option) exit(1) } } val options = nextOption(Map(),arglist) println(options) } } 

将打印，例如：

 Map('infile -> test/data/paml-aln1.phy, 'maxsize -> 4, 'minsize -> 2) 

这个版本只需要一个infile。 易于改进（通过使用列表）。

还要注意，这种方法允许连接多个命令行参数 – 甚至两个以上！

Answer 2

scopt / scopt

 val parser = new scopt.OptionParser[Config]("scopt") { head("scopt", "3.x") opt[Int]('f', "foo") action { (x, c) => c.copy(foo = x) } text("foo is an integer property") opt[File]('o', "out") required() valueName("<file>") action { (x, c) => c.copy(out = x) } text("out is a required file property") opt[(String, Int)]("max") action { case ((k, v), c) => c.copy(libName = k, maxCount = v) } validate { x => if (x._2 > 0) success else failure("Value <max> must be >0") } keyValueName("<libname>", "<max>") text("maximum count for <libname>") opt[Unit]("verbose") action { (_, c) => c.copy(verbose = true) } text("verbose is a flag") note("some notes.\n") help("help") text("prints this usage text") arg[File]("<file>...") unbounded() optional() action { (x, c) => c.copy(files = c.files :+ x) } text("optional unbounded args") cmd("update") action { (_, c) => c.copy(mode = "update") } text("update is a command.") children( opt[Unit]("not-keepalive") abbr("nk") action { (_, c) => c.copy(keepalive = false) } text("disable keepalive"), opt[Boolean]("xyz") action { (x, c) => c.copy(xyz = x) } text("xyz is a boolean property") ) } // parser.parse returns Option[C] parser.parse(args, Config()) map { config => // do stuff } getOrElse { // arguments are bad, usage message will have been displayed } 

以上生成以下用法文本：

 scopt 3.x Usage: scopt [update] [options] [<file>...] -f <value> | --foo <value> foo is an integer property -o <file> | --out <file> out is a required file property --max:<libname>=<max> maximum count for <libname> --verbose verbose is a flag some notes. --help prints this usage text <file>... optional unbounded args Command: update update is a command. -nk | --not-keepalive disable keepalive --xyz <value> xyz is a boolean property 

这是我目前使用的。 清洁使用，没有太多的行李。 （免责声明：我现在维护这个项目）

Answer 3

我意识到这个问题是前一段时间提出来的，但是我认为这可能会帮助一些像我一样使用Googlesearch的人，并且打开这个页面。

扇贝看起来也很有希望。

function（引用链接的github页面）：

• 标志，单值和多值选项
• POSIX风格的短选项名称（-a）与分组（-abc）
• GNU风格的长选项名称（–opt）
• 属性参数（-Dkey = value，-D key1 = value key2 = value）
• 选项和属性值的非stringtypes（使用可扩展的转换器）
• 尾随参数强大的匹配
• 子命令

和一些示例代码（也来自该Github页面）：

 import org.rogach.scallop._; object Conf extends ScallopConf(List("-c","3","-E","fruit=apple","7.2")) { // all options that are applicable to builder (like description, default, etc) // are applicable here as well val count:ScallopOption[Int] = opt[Int]("count", descr = "count the trees", required = true) .map(1+) // also here work all standard Option methods - // evaluation is deferred to after option construction val properties = props[String]('E') // types (:ScallopOption[Double]) can be omitted, here just for clarity val size:ScallopOption[Double] = trailArg[Double](required = false) } // that's it. Completely type-safe and convenient. Conf.count() should equal (4) Conf.properties("fruit") should equal (Some("apple")) Conf.size.get should equal (Some(7.2)) // passing into other functions def someInternalFunc(conf:Conf.type) { conf.count() should equal (4) } someInternalFunc(Conf) 

Answer 4

我喜欢滑过相对简单configuration的参数。

 var name = "" var port = 0 var ip = "" args.sliding(2, 2).toList.collect { case Array("--ip", argIP: String) => ip = argIP case Array("--port", argPort: String) => port = argPort.toInt case Array("--name", argName: String) => name = argName } 

Answer 5

这在很大程度上是我对同一主题的Java问题的回答无耻的克隆。 事实certificate，JewelCLI是Scala友好的，因为它不需要JavaBean风格的方法来获得自动参数命名。

JewelCLI是一个适用于命令行parsing的Scala友好的Java库，可以生成干净的代码 。 它使用configuration了批注的代理接口为您的命令行参数dynamic构buildtypes安全的API。

一个示例参数界面Person.scala ：

 import uk.co.flamingpenguin.jewel.cli.Option trait Person { @Option def name: String @Option def times: Int } 

参数接口Hello.scala一个示例用法：

 import uk.co.flamingpenguin.jewel.cli.CliFactory.parseArguments import uk.co.flamingpenguin.jewel.cli.ArgumentValidationException object Hello { def main(args: Array[String]) { try { val person = parseArguments(classOf[Person], args:_*) for (i <- 1 to (person times)) println("Hello " + (person name)) } catch { case e: ArgumentValidationException => println(e getMessage) } } } 

将上述文件的副本保存到一个目录中，并将JewelCLI 0.6 JAR下载到该目录中。

编译并运行在Linux / Mac OS X / Bash上的例子：

 scalac -cp jewelcli-0.6.jar:. Person.scala Hello.scala scala -cp jewelcli-0.6.jar:. Hello --name="John Doe" --times=3 

编译并运行Windows命令提示符下的示例：

 scalac -cp jewelcli-0.6.jar;. Person.scala Hello.scala scala -cp jewelcli-0.6.jar;. Hello --name="John Doe" --times=3 

运行该示例应该会产生以下输出：

 Hello John Doe Hello John Doe Hello John Doe 

Answer 6

命令行界面Scala Toolkit（CLIST）

这也是我的！ （虽然在比赛中有点晚了）

https://github.com/backuity/clist

与scopt相反，它完全是可变的，但是等等！ 这给了我们一个相当不错的语法：

 class Cat extends Command(description = "concatenate files and print on the standard output") { // type-safety: members are typed! so showAll is a Boolean var showAll = opt[Boolean](abbrev = "A", description = "equivalent to -vET") var numberNonblank = opt[Boolean](abbrev = "b", description = "number nonempty output lines, overrides -n") // files is a Seq[File] var files = args[Seq[File]](description = "files to concat") } 

一个简单的方法来运行它：

 Cli.parse(args).withCommand(new Cat) { case cat => println(cat.files) } 

当然，你可以做更多的事情（多命令，许多configuration选项，…），并没有依赖性。

我将完成一个独特的function，默认使用（通常忽略多命令）：

Answer 7

斯卡拉-optparse，应用性

我认为scala-optparse-applicative是Scala中function最强大的命令行parsing器库。

https://github.com/bmjames/scala-optparse-applicative

Answer 8

还有JCommander （免责声明：我创build了它）：

 object Main { object Args { @Parameter( names = Array("-f", "--file"), description = "File to load. Can be specified multiple times.") var file: java.util.List[String] = null } def main(args: Array[String]): Unit = { new JCommander(Args, args.toArray: _*) for (filename <- Args.file) { val f = new File(filename) printf("file: %s\n", f.getName) } } } 

Answer 9

我来自Java世界，我喜欢args4j，因为它的简单，规范更可读（感谢注释），并产生良好的格式化输出。

这是我的示例代码片段：

规范

 import org.kohsuke.args4j.{CmdLineException, CmdLineParser, Option} object CliArgs { @Option(name = "-list", required = true, usage = "List of Nutch Segment(s) Part(s)") var pathsList: String = null @Option(name = "-workdir", required = true, usage = "Work directory.") var workDir: String = null @Option(name = "-master", usage = "Spark master url") var masterUrl: String = "local[2]" } 

parsing

 //var args = "-listt in.txt -workdir out-2".split(" ") val parser = new CmdLineParser(CliArgs) try { parser.parseArgument(args.toList.asJava) } catch { case e: CmdLineException => print(s"Error:${e.getMessage}\n Usage:\n") parser.printUsage(System.out) System.exit(1) } println("workDir :" + CliArgs.workDir) println("listFile :" + CliArgs.pathsList) println("master :" + CliArgs.masterUrl) 

在无效的论点

 Error:Option "-list" is required Usage: -list VAL : List of Nutch Segment(s) Part(s) -master VAL : Spark master url (default: local[2]) -workdir VAL : Work directory. 

Answer 10

我喜欢joslinm的slide（）方法，而不是可变的variables;）所以这里有一个不可改变的方法：

 case class AppArgs( seed1: String, seed2: String, ip: String, port: Int ) object AppArgs { def empty = new AppArgs("", "", "", 0) } val args = Array[String]( "--seed1", "akka.tcp://seed1", "--seed2", "akka.tcp://seed2", "--nodeip", "192.167.1.1", "--nodeport", "2551" ) val argsInstance = args.sliding(2, 1).toList.foldLeft(AppArgs.empty) { case (accumArgs, currArgs) => currArgs match { case Array("--seed1", seed1) => accumArgs.copy(seed1 = seed1) case Array("--seed2", seed2) => accumArgs.copy(seed2 = seed2) case Array("--nodeip", ip) => accumArgs.copy(ip = ip) case Array("--nodeport", port) => accumArgs.copy(port = port.toInt) case unknownArg => accumArgs // Do whatever you want for this case } } 

Answer 11

我刚刚在scalac的scala.tools.cmd包中发现了一个广泛的命令行parsing库。

见http://www.assembla.com/code/scala-eclipse-toolchain/git/nodes/src/compiler/scala/tools/cmd?rev=f59940622e32384b1e08939effd24e924a8ba8db

Answer 12

我试图概括@pjotrp的解决scheme，通过获取所需的位置键符号列表，标志 – >键符号和默认选项的地图：

 def parseOptions(args: List[String], required: List[Symbol], optional: Map[String, Symbol], options: Map[Symbol, String]): Map[Symbol, String] = { args match { // Empty list case Nil => options // Keyword arguments case key :: value :: tail if optional.get(key) != None => parseOptions(tail, required, optional, options ++ Map(optional(key) -> value)) // Positional arguments case value :: tail if required != Nil => parseOptions(tail, required.tail, optional, options ++ Map(required.head -> value)) // Exit if an unknown argument is received case _ => printf("unknown argument(s): %s\n", args.mkString(", ")) sys.exit(1) } } def main(sysargs Array[String]) { // Required positional arguments by key in options val required = List('arg1, 'arg2) // Optional arguments by flag which map to a key in options val optional = Map("--flag1" -> 'flag1, "--flag2" -> 'flag2) // Default options that are passed in var defaultOptions = Map() // Parse options based on the command line args val options = parseOptions(sysargs.toList, required, optional, defaultOptions) } 

Answer 13

我把我的方法放在最重要的答案（来自dave4420），并试图通过使其更通用来改进它。

它返回所有命令行参数的Map[String,String]你可以查询这个你想要的特定参数（例如使用.contains ）或者将这些值转换成你想要的types（例如使用toInt ）。

 def argsToOptionMap(args:Array[String]):Map[String,String]= { def nextOption( argList:List[String], map:Map[String, String] ) : Map[String, String] = { val pattern = "--(\\w+)".r // Selects Arg from --Arg val patternSwitch = "-(\\w+)".r // Selects Arg from -Arg argList match { case Nil => map case pattern(opt) :: value :: tail => nextOption( tail, map ++ Map(opt->value) ) case patternSwitch(opt) :: tail => nextOption( tail, map ++ Map(opt->null) ) case string :: Nil => map ++ Map(string->null) case option :: tail => { println("Unknown option:"+option) sys.exit(1) } } } nextOption(args.toList,Map()) } 

例：

 val args=Array("--testing1","testing1","-a","-b","--c","d","test2") argsToOptionMap( args ) 

得到：

 res0: Map[String,String] = Map(testing1 -> testing1, a -> null, b -> null, c -> d, test2 -> null) 

Answer 14

另一个图书馆： 疤痕

Answer 15

这是一个易于使用的scala命令行parsing器 。 它自动格式化帮助文本，并将开关参数转换为您所需的types。 支持短的POSIX和长的GNU风格的开关。 支持所需参数，可选参数和多个值参数的开关。 您甚至可以为特定开关指定可接受值的有限列表。 为方便起见，可以在命令行上缩写长开关名称。 与Ruby标准库中的选项parsing器类似。

Answer 16

我只是创build了我的简单枚举

 val args: Array[String] = "-silent -samples 100 -silent".split(" +").toArray //> args : Array[String] = Array(-silent, -samples, 100, -silent) object Opts extends Enumeration { class OptVal extends Val { override def toString = "-" + super.toString } val nopar, silent = new OptVal() { // boolean options def apply(): Boolean = args.contains(toString) } val samples, maxgen = new OptVal() { // integer options def apply(default: Int) = { val i = args.indexOf(toString) ; if (i == -1) default else args(i+1).toInt} def apply(): Int = apply(-1) } } Opts.nopar() //> res0: Boolean = false Opts.silent() //> res1: Boolean = true Opts.samples() //> res2: Int = 100 Opts.maxgen() //> res3: Int = -1 

我知道这个解决scheme有两个可能让你分心的缺点：它消除了自由（即对其他库的依赖，你非常重视）和冗余（DRY原则，你只需要input一次选项名称，就像Scala程序variables和消除它第二次键入命令行文本）。

Answer 17

我build议使用http://docopt.org/ 。 有一个scala端口，但Java实现https://github.com/docopt/docopt.java工作得很好，似乎更好地维护。; 这是一个例子：

 import org.docopt.Docopt import scala.collection.JavaConversions._ import scala.collection.JavaConverters._ val doc = """ Usage: my_program [options] <input> Options: --sorted fancy sorting """.stripMargin.trim //def args = "--sorted test.dat".split(" ").toList var results = new Docopt(doc). parse(args()). map {case(key, value)=>key ->value.toString} val inputFile = new File(results("<input>")) val sorted = results("--sorted").toBoolean 

Answer 18

如何parsing没有外部依赖的参数。 好问题！ 您可能对picocli感兴趣。

Picocli是专门为解决问题中提出的问题而devise的：它是一个单一文件中的命令行parsing框架，因此您可以将其包含在源代码中 。 这使用户可以运行基于picocli的应用程序， 而无需将picocli作为外部依赖项 。

它通过注释字段来工作，所以你写的代码很less。 快速总结：

• 强types的一切 – 命令行选项以及位置参数
• 支持POSIX集群短选项（所以它处理<command> -xvfInputFile以及<command> -x -v -f InputFile ）
• 允许最小，最大和可变数量的参数（例如"1..*" ， "3..5"
• stream畅而紧凑的API可以最大限度地减less样板客户端代码
• 子命令
• ANSI颜色的用法帮助

使用帮助信息很容易通过注释进行定制（无需编程）。 例如：

（ 来源 ）

我忍不住再添加一张屏幕截图来显示哪种使用帮助信息是可能的。 使用帮助是你的应用程序的面貌，所以要有创意，玩得开心！

免责声明：我创build了picocli。 反馈或问题非常欢迎。 它是用java编写的，但是让我知道在scala中是否有任何问题，我会尽力解决它。

Answer 19

我喜欢这个代码的清晰外观…从这里的讨论中收集： http : //www.scala-lang.org/old/node/4380

 object ArgParser { val usage = """ Usage: parser [-v] [-f file] [-s sopt] ... Where: -v Run verbosely -f F Set input file to F -s S Set Show option to S """ var filename: String = "" var showme: String = "" var debug: Boolean = false val unknown = "(^-[^\\s])".r val pf: PartialFunction[List[String], List[String]] = { case "-v" :: tail => debug = true; tail case "-f" :: (arg: String) :: tail => filename = arg; tail case "-s" :: (arg: String) :: tail => showme = arg; tail case unknown(bad) :: tail => die("unknown argument " + bad + "\n" + usage) } def main(args: Array[String]) { // if there are required args: if (args.length == 0) die() val arglist = args.toList val remainingopts = parseArgs(arglist,pf) println("debug=" + debug) println("showme=" + showme) println("filename=" + filename) println("remainingopts=" + remainingopts) } def parseArgs(args: List[String], pf: PartialFunction[List[String], List[String]]): List[String] = args match { case Nil => Nil case _ => if (pf isDefinedAt args) parseArgs(pf(args),pf) else args.head :: parseArgs(args.tail,pf) } def die(msg: String = usage) = { println(msg) sys.exit(1) } } 

Answer 20

我从来没有喜欢ruby选项parsing器。 大多数使用它们的开发人员从来不会为脚本编写适当的手册页 ，而是由于parsing器不能正确组织正确的页面。

我总是倾向于用Perl的Getopt :: Long来做事情。

我正在研究它的一个scala实现。 早期的API看起来像这样：

 def print_version() = () => println("version is 0.2") def main(args: Array[String]) { val (options, remaining) = OptionParser.getOptions(args, Map( "-f|--flag" -> 'flag, "-s|--string=s" -> 'string, "-i|--int=i" -> 'int, "-f|--float=f" -> 'double, "-p|-procedure=p" -> { () => println("higher order function" } "-h=p" -> { () => print_synopsis() } "--help|--man=p" -> { () => launch_manpage() }, "--version=p" -> print_version, )) 

所以调用这样的script ：

 $ script hello -f --string=mystring -i 7 --float 3.14 --p --version world -- --nothing 

将打印：

 higher order function version is 0.2 

并返回：

 remaining = Array("hello", "world", "--nothing") options = Map('flag -> true, 'string -> "mystring", 'int -> 7, 'double -> 3.14) 

该项目托pipe在github scala-getoptions 。

Answer 21

大家都发布了自己的解决scheme，这是我的，因为我想要更容易为用户写： https : //gist.github.com/gwenzek/78355526e476e08bb34d

要点包含一个代码文件，再加上一个testing文件和一个简短的例子在这里复制：

 import ***.ArgsOps._ object Example { val parser = ArgsOpsParser("--someInt|-i" -> 4, "--someFlag|-f", "--someWord" -> "hello") def main(args: Array[String]){ val argsOps = parser <<| args val someInt : Int = argsOps("--someInt") val someFlag : Boolean = argsOps("--someFlag") val someWord : String = argsOps("--someWord") val otherArgs = argsOps.args foo(someWord, someInt, someFlag) } } 

有没有花哨的选项强迫一个variables在一定的范围内，因为我不觉得parsing器是最好的地方这样做。

注意：对于一个给定的variables，你可以拥有尽可能多的别名。

Answer 22

我要堆积 我用一行简单的代码解决了这个问题。 我的命令行参数是这样的：

 input--hdfs:/path/to/myData/part-00199.avro output--hdfs:/path/toWrite/Data fileFormat--avro option1--5 

这通过Scala的本地命令行function（从App或主要方法）创build一个数组：

 Array("input--hdfs:/path/to/myData/part-00199.avro", "output--hdfs:/path/toWrite/Data","fileFormat--avro","option1--5") 

然后我可以使用这一行来parsing出默认的args数组：

 val nArgs = args.map(x=>x.split("--")).map(y=>(y(0),y(1))).toMap 

其中创build一个名称与命令行值相关的映射：

 Map(input -> hdfs:/path/to/myData/part-00199.avro, output -> hdfs:/path/toWrite/Data, fileFormat -> avro, option1 -> 5) 

然后我可以在我的代码中访问命名参数的值，它们在命令行上出现的顺序不再相关。 我意识到这是相当简单的，没有上面提到的所有高级function，但在大多数情况下似乎是足够的，只需要一行代码，而不涉及外部依赖。

Answer 23

这是我的1class轮

  def optArg(prefix: String) = args.drop(3).find { _.startsWith(prefix) }.map{_.replaceFirst(prefix, "")} def optSpecified(prefix: String) = optArg(prefix) != None def optInt(prefix: String, default: Int) = optArg(prefix).map(_.toInt).getOrElse(default) 

它删除了3个强制性的参数，并给出了选项。 整数被指定为臭名昭着的-Xmx<size> java选项，连同前缀。 你可以像parsing一样简单地parsing二进制文件和整数

 val cacheEnabled = optSpecified("cacheOff") val memSize = optInt("-Xmx", 1000) 

无需导入任何东西。

Answer 24

这是我煮的。 它返回一个地图和列表的元组。 列表用于input，如input文件名称。 地图用于开关/选项。

 val args = "--sw1 1 input_1 --sw2 --sw3 2 input_2 --sw4".split(" ") val (options, inputs) = OptParser.parse(args) 

将返回

 options: Map[Symbol,Any] = Map('sw1 -> 1, 'sw2 -> true, 'sw3 -> 2, 'sw4 -> true) inputs: List[Symbol] = List('input_1, 'input_2) 

开关可以是“ – t”，其中x将被设置为真，或者“ – x 10”，其将x设置为“10”。 其他的一切都将在列表中结束。

 object OptParser { val map: Map[Symbol, Any] = Map() val list: List[Symbol] = List() def parse(args: Array[String]): (Map[Symbol, Any], List[Symbol]) = _parse(map, list, args.toList) private [this] def _parse(map: Map[Symbol, Any], list: List[Symbol], args: List[String]): (Map[Symbol, Any], List[Symbol]) = { args match { case Nil => (map, list) case arg :: value :: tail if (arg.startsWith("--") && !value.startsWith("--")) => _parse(map ++ Map(Symbol(arg.substring(2)) -> value), list, tail) case arg :: tail if (arg.startsWith("--")) => _parse(map ++ Map(Symbol(arg.substring(2)) -> true), list, tail) case opt :: tail => _parse(map, list :+ Symbol(opt), tail) } } } 

Answer 25

freecli

  import java.io.File import pavlosgi.freecli.core.all._ import pavlosgi.freecli.config.all._ import pavlosgi.freecli.command.all._ object Git extends App { case class CommitConfig(all: Boolean, message: String) val commitCommand = cmd("commit") { takesG[CommitConfig] { O.help --"help" :: flag --"all" -'a' -~ des("Add changes from all known files") :: O.string -'m' -~ req -~ des("Commit message") } :: runs[CommitConfig] { config => if (config.all) { println(s"Commited all ${config.message}!") } else { println(s"Commited ${config.message}!") } } } val rmCommand = cmd("rm") { takesG[File] { O.help --"help" :: file -~ des("File to remove from git") } :: runs[File] { f => println(s"Removed file ${f.getAbsolutePath} from git") } } val remoteCommand = cmd("remote") { takes(O.help --"help") :: cmd("add") { takesT { O.help --"help" :: string -~ des("Remote name") :: string -~ des("Remote url") } :: runs[(String, String)] { case (s, u) => println(s"Remote $s $u added") } } :: cmd("rm") { takesG[String] { O.help --"help" :: string -~ des("Remote name") } :: runs[String] { s => println(s"Remote $s removed") } } } val git = cmd("git", des("Version control system")) { takes(help --"help" :: version --"version" -~ value("v1.0")) :: commitCommand :: rmCommand :: remoteCommand } val res = parseCommandOrFail(args)(git).run } 

这将产生以下用法：

用法

Answer 26

穷人的快速和肮脏的单线程来parsing键=值对：

 def main(args: Array[String]) { val cli = args.map(_.split("=") match { case Array(k, v) => k->v } ).toMap val saveAs = cli("saveAs") println(saveAs) }