Bagaimana cara mengakses argumen baris perintah yang diteruskan ke program Go?

Bagaimana cara mengakses argumen baris perintah di Go? Mereka tidak diberikan sebagai argumen main.

Sebuah program lengkap, mungkin dibuat dengan menghubungkan beberapa paket, harus memiliki satu paket yang disebut main, dengan sebuah fungsi

func main() { ... }

ditentukan. Fungsi main.main () tidak menggunakan argumen dan tidak mengembalikan nilai.

Anda dapat mengakses argumen baris perintah menggunakan os.Argsvariabel. Sebagai contoh,

package main

import (
    "fmt"
    "os"
)

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

Anda juga dapat menggunakan paket flag , yang mengimplementasikan penguraian flag baris perintah.

Argumen baris perintah dapat ditemukan di os.Args . Dalam kebanyakan kasus, flag paket lebih baik karena melakukan parsing argumen untuk Anda.

Bendera adalah paket yang bagus untuk itu.

// [_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())
}

Jawaban Peter adalah apa yang Anda butuhkan jika Anda hanya menginginkan daftar argumen.

Namun, jika Anda sedang mencari fungsionalitas mirip dengan yang ada pada UNIX, maka Anda bisa menggunakan implementasi pergi dari docopt . Anda bisa mencobanya di sini .

docopt akan mengembalikan JSON yang kemudian dapat Anda proses sesuka hati.

Jawaban cepat:

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

Uji: $ go run test.go 1 2 3 4 5

Di luar:

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

CATATAN : os.Argsmenyediakan akses ke argumen baris perintah mentah. Perhatikan bahwa nilai pertama dalam potongan ini adalah jalur ke program, dan os.Args[1:]menyimpan argumen ke program. Referensi

Anda dapat menggunakan paket bendera Golang misalnya,

package main

import (
    "flag"
    "fmt"
)

func main() {

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

}

menelepon dengan cli

 go run main.go -word=hello
 
 

keluaran

word: hello