Wie greife ich auf Befehlszeilenargumente zu, die an ein Go-Programm übergeben wurden?

88

Wie greife ich in Go auf Befehlszeilenargumente zu? Sie werden nicht als Argumente an übergeben main.

Ein vollständiges Programm, das möglicherweise durch Verknüpfen mehrerer Pakete erstellt wird, muss ein Paket namens main mit einer Funktion haben

func main() { ... }

definiert. Die Funktion main.main () akzeptiert keine Argumente und gibt keinen Wert zurück.

Oleg Razgulyaev
quelle
Ich würde mir das flageingebaute Golang-Modul ansehen. Es macht das Parsen os.Argsein bisschen einfacher
Matej
Beachten Sie außerdem, dass Sie "einen Wert zurückgeben" können os.Exit(), um einen bestimmten Exit-Code an den aufrufenden Prozess zurückzugeben.
Mark Reed

Antworten:

112

Sie können mit der os.ArgsVariablen auf die Befehlszeilenargumente zugreifen . Beispielsweise,

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println(len(os.Args), os.Args)
}

Sie können auch das Flag-Paket verwenden , das das Parsen von Befehlszeilen-Flags implementiert.

peterSO
quelle
11

Befehlszeilenargumente finden Sie in os.Args . In den meisten Fällen , obwohl das Paket Flagge ist besser , weil es das Argument für Sie Parsen der Fall ist.

Maurice Gilden
quelle
9

Flag ist dafür ein gutes Paket.

// [_Command-line flags_](http://en.wikipedia.org/wiki/Command-line_interface#Command-line_option)
// are a common way to specify options for command-line
// programs. For example, in `wc -l` the `-l` is a
// command-line flag.

package main

// Go provides a `flag` package supporting basic
// command-line flag parsing. We'll use this package to
// implement our example command-line program.
import "flag"
import "fmt"

func main() {

    // Basic flag declarations are available for string,
    // integer, and boolean options. Here we declare a
    // string flag `word` with a default value `"foo"`
    // and a short description. This `flag.String` function
    // returns a string pointer (not a string value);
    // we'll see how to use this pointer below.
    wordPtr := flag.String("word", "foo", "a string")

    // This declares `numb` and `fork` flags, using a
    // similar approach to the `word` flag.
    numbPtr := flag.Int("numb", 42, "an int")
    boolPtr := flag.Bool("fork", false, "a bool")

    // It's also possible to declare an option that uses an
    // existing var declared elsewhere in the program.
    // Note that we need to pass in a pointer to the flag
    // declaration function.
    var svar string
    flag.StringVar(&svar, "svar", "bar", "a string var")

    // Once all flags are declared, call `flag.Parse()`
    // to execute the command-line parsing.
    flag.Parse()

    // Here we'll just dump out the parsed options and
    // any trailing positional arguments. Note that we
    // need to dereference the pointers with e.g. `*wordPtr`
    // to get the actual option values.
    fmt.Println("word:", *wordPtr)
    fmt.Println("numb:", *numbPtr)
    fmt.Println("fork:", *boolPtr)
    fmt.Println("svar:", svar)
    fmt.Println("tail:", flag.Args())
}
BufBills
quelle
1
Sieht aus Kopie von Go von Beispielen
Grijesh Chauhan
7

Peters Antwort ist genau das, was Sie brauchen, wenn Sie nur eine Liste von Argumenten wollen.

Wenn Sie jedoch nach Funktionen suchen, die denen unter UNIX ähneln, können Sie die go-Implementierung von docopt verwenden . Sie können es hier versuchen .

docopt gibt JSON zurück, das Sie nach Herzenslust verarbeiten können.

Carl
quelle
1
Möglicherweise ist Bedürfnis ein zu starkes Wort. Empfehlen Sie "dann könnten Sie".
Matt Joiner
7

Schnelle Antwort:

package main

import ("fmt"
        "os"
)

func main() {
    argsWithProg := os.Args
    argsWithoutProg := os.Args[1:]
    arg := os.Args[3]
    fmt.Println(argsWithProg)
    fmt.Println(argsWithoutProg)
    fmt.Println(arg)
}

Prüfung: $ go run test.go 1 2 3 4 5

Aus:

[/tmp/go-build162373819/command-line-arguments/_obj/exe/modbus 1 2 3 4 5]
[1 2 3 4 5]
3

HINWEIS : Ermöglichtos.Args den Zugriff auf unformatierte Befehlszeilenargumente. Beachten Sie, dass der erste Wert in diesem Slice der Pfad zum Programm ist und os.Args[1:]die Argumente zum Programm enthält. Referenz

Benyamin Jafari
quelle