Bir Go programına iletilen komut satırı argümanlarına nasıl erişilir?

Go'da komut satırı bağımsız değişkenlerine nasıl erişirim? Argüman olarak aktarılmazlar main.

Muhtemelen birden fazla paketin birbirine bağlanmasıyla oluşturulmuş eksiksiz bir programın, main adlı bir işlevi olan

func main() { ... }

tanımlı. Main.main () işlevi bağımsız değişken almaz ve değer döndürmez.

os.ArgsDeğişkeni kullanarak komut satırı argümanlarına erişebilirsiniz . Örneğin,

package main

import (
    "fmt"
    "os"
)

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

Ayrıca , komut satırı bayrağı ayrıştırmasını uygulayan bayrak paketini de kullanabilirsiniz .

Komut satırı argümanları os.Args'de bulunabilir . Çoğu durumda paket bayrağı daha iyidir çünkü argümanı sizin için ayrıştırır.

Bayrak bunun için iyi bir 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())
}

Peter'ın cevabı, sadece bir argüman listesi istiyorsanız tam olarak ihtiyacınız olan şeydir.

Ancak, UNIX'de mevcut olana benzer bir işlevsellik arıyorsanız , docopt'un go uygulamasını kullanabilirsiniz . Burada deneyebilirsiniz .

docopt, daha sonra işleyebileceğiniz JSON'u istediğiniz gibi döndürecektir.

Hızlı cevap:

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

Ölçek: $ go run test.go 1 2 3 4 5

Dışarı:

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

NOT : os.Argsham komut satırı bağımsız değişkenlerine erişim sağlar. Bu dilimdeki ilk değerin programa giden yol olduğuna ve programa os.Args[1:]giden değişkenleri tuttuğuna dikkat edin. Referans

örneğin Golang bayrak paketini kullanabilirsiniz,

package main

import (
    "flag"
    "fmt"
)

func main() {

    wordPtr := flag.String("word", "default value", "a string for description")
    flag.Parse()
    fmt.Println("word:", *wordPtr)

}

cli ile ara

 go run main.go -word=hello
 
 

çıktı

word: hello