Início / coding / Perguntas / 79319395
Accepted
Eldigan of Nordion
Asked: 2024-12-31 15:19:32 +0800 CST

Analisando argumentos de linha de comando como um Array[String] no Scala 3?

  • 772

Certo, então eu estava tentando aprender Scala em um livro didático, mas ele foi escrito antes do Scala 3 ser lançado, então grande parte do código de exemplo não compila.

Veja como o livro apresenta argumentos de linha de comando:

println(args(0).toDouble+args(1).toDouble)

e minha melhor tentativa de converter isso em algo compatível com Scala 3:

@main def main(args: Array[String]) = {  
  println(args(0).toDouble+args(1).toDouble)
}

e aqui está o que o compilador me diz:

[error] ./add.scala:1:1
[error] No given instance of type scala.util.CommandLineParser.FromString[Array[String]] was found for parameter fs of method parseArgument in object CommandLineParser
[error] @main def main(args: Array[String]) = {
[error] ^

Como eu conserto isso? Há outra pergunta como essa já postada, mas as respostas parecem estar todas escritas em versões anteriores do Scala. Quanto ao guia de lançamento oficial, ele recomenda usar algo a ver com CLP, o que eu não entendo.

scala

3 respostas

  1. @mainpassará todos os argumentos não analisados ​​para um String*parâmetro, se houver um. No caso de não haver argumentos analisados, isso significa:

    @main def main(args: String*) = {  
  println(args(0).toDouble+args(1).toDouble)
}
    • 3
  2. Best Answer

    Se você estiver usando apenas Scala 3, a @mainanotação é o caminho a seguir, mas os parâmetros devem ser definidos como parâmetros de método regulares:

    // ❌ Instead of:
@main def main(args: Array[String])

// ✅ Do:
@main def main(arg0: Double, arg1: Double)

    Uma coisa a notar é que os parâmetros podem ser digitados, eles não precisam Stringmais ser somente s. A conversão é tratada para você automaticamente*.

    Você pode escrever assim:

    @main def main(arg0: Double, arg1: Double) = { 
  println(arg0 + arg1) 
}

    *: somente tipos simples são suportados por padrão, mas isso pode ser estendido fornecendo instâncias descala.util.CommandLineParser.FromString . Note que este é o erro que você estava recebendo inicialmente: o compilador estava dizendo "Não sei como converter de Stringpara Array[String]"

    EDIT : como CoreyOConnor menciona em outra resposta, também é possível obter todos os parâmetros restantes como String*(varargs) se você não digitar explicitamente alguns parâmetros.

    Se você estiver compilando para Scala 2 ou simplesmente preferir o método Scala 2, mais próximo do Java, remova a @mainanotação e certifique-se de incluir o método em um object.

    object MyProgram {
  def main(args: Array[String]) = ???
}

    Documentação: https://docs.scala-lang.org/scala3/book/methods-main-methods.html

    • 2

  3. Gosto da solução GAel, mas para criar algo diferente, se você está começando a usar o Scala 3, use o método main tradicional (def main(args: Array[String]): Unit) ou use a abordagem mais simples @main com argumentos explícitos (@main def addNumbers(arg1: String, arg2: String): Unit).

    Se você quiser acessar args como Array[String], você deve definir o método principal sem a anotação @main:

    object AddNumbers {
  def main(args: Array[String]): Unit = {
    if (args.length < 2) {
      println("Please provide two numbers as arguments.")
    } else {
      println(args(0).toDouble + args(1).toDouble)
    }
  }
}

    Você pode executar este programa com argumentos de linha de comando, e args conterá todos os argumentos em uma matriz.

    • 0

relate perguntas