Wie kann man auf Befehlszeilenargumente zugreifen, die an ein Go-Programm übergeben wurden?

Question

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

Ein komplettes Programm, das möglicherweise durch die Verknüpfung mehrerer Pakete erstellt wurde, muss ein Paket namens main enthalten, mit einer Funktion

func main() { ... }

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

Answer 1

Sie können auf die Befehlszeilenargumente mit der Option os.Args variabel. Zum Beispiel,

package main

import (
    "fmt"
    "os"
)

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

Sie können auch die Flaggenpaket , das die Analyse von Befehlszeilenflags implementiert.

Answer 2

Flagge ist ein gutes Paket für diese Zwecke.

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())
}

Answer 3

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)
}

Test: $ 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

ANMERKUNG : os.Args ermöglicht den Zugriff auf rohe Befehlszeilenargumente. Beachten Sie, dass der erste Wert in diesem Slice der Pfad zum Programm ist, und os.Args[1:] hält die Argumentation Referenz

Answer 4

Befehlszeilenargumente finden Sie unter os.Args . In den meisten Fällen wird das Paket jedoch Flagge ist besser, weil es das Parsing der Argumente für Sie übernimmt.

Answer 5

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

Wenn Sie jedoch eine ähnliche Funktionalität wie unter UNIX suchen, können Sie die Go-Implementierung von docopt . Sie können es versuchen aquí .

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