Go 프로그램에 전달 된 명령 줄 인수에 액세스하는 방법은 무엇입니까?

Go에서 명령 줄 인수에 액세스하려면 어떻게해야합니까? 에 인수로 전달되지 않습니다 main.

여러 패키지를 연결하여 생성 될 수있는 완전한 프로그램에는 함수가있는 main이라는 패키지가 하나 있어야합니다.

func main() { ... }

한정된. main.main () 함수는 인수를 취하지 않고 값을 반환하지 않습니다.

os.Args변수를 사용하여 명령 줄 인수에 액세스 할 수 있습니다 . 예를 들면

package main

import (
    "fmt"
    "os"
)

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

명령 줄 플래그 구문 분석을 구현 하는 flag package를 사용할 수도 있습니다 .

명령 줄 인수는 os.Args 에서 찾을 수 있습니다 . 대부분의 경우 패키지 플래그 는 인수 구문 분석을 수행하기 때문에 더 좋습니다.

플래그는 좋은 패키지입니다.

// [_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의 대답은 인수 목록을 원할 경우 정확히 필요한 것입니다.

그러나 UNIX에있는 것과 유사한 기능을 찾고 있다면 docopt 의 go 구현 을 사용할 수 있습니다 . 여기에서 시도해 볼 수 있습니다 .

docopt는 마음껏 처리 할 수있는 JSON을 반환합니다.

빠른 답변 :

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

테스트: $ go run test.go 1 2 3 4 5

밖:

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

참고 : os.Args원시 명령 줄 인수에 대한 액세스를 제공합니다. 이 슬라이스의 첫 번째 값은 프로그램에 대한 경로이며 프로그램에 os.Args[1:]대한 인수를 보유합니다. 참고

예를 들어 Golang 플래그 패키지를 사용할 수 있습니다.

package main

import (
    "flag"
    "fmt"
)

func main() {

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

}

CLI로 전화

 go run main.go -word=hello
 
 

산출

word: hello