গো প্রোগ্রামে পাস হওয়া কমান্ড-লাইন আর্গুমেন্টগুলি কীভাবে অ্যাক্সেস করবেন?

Question 1

আমি কীভাবে কমান্ড-লাইন যুক্তিতে অ্যাক্সেস করব? তারা যুক্তি হিসাবে পাস করা হয় না main।

একটি সম্পূর্ণ প্রোগ্রাম, সম্ভবত একাধিক প্যাকেজ যুক্ত করে তৈরি করা হয়েছে, একটি ফাংশন সহ একটি মূল প্যাকেজ থাকতে হবে called
func main() { ... }
সংজ্ঞায়িত ফাংশন মেইন.মাইন () কোনও আর্গুমেন্ট নেয় না এবং কোনও মান দেয় না।

Question 2

আপনি os.Argsভেরিয়েবলটি ব্যবহার করে কমান্ড-লাইন আর্গুমেন্ট অ্যাক্সেস করতে পারেন । উদাহরণ স্বরূপ,

package main

import (
    "fmt"
    "os"
)

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

আপনি পতাকা প্যাকেজও ব্যবহার করতে পারেন যা কমান্ড-লাইন পতাকা পার্সিং কার্যকর করে।

Question 3

কমান্ড লাইন আর্গুমেন্টগুলি os.Args এ পাওয়া যাবে । বেশিরভাগ ক্ষেত্রে প্যাকেজ ফ্ল্যাগটি আরও ভাল কারণ এটি আপনার পক্ষে যুক্তিটি বিশ্লেষণ করে।

Question 4

পতাকা এটি জন্য একটি ভাল প্যাকেজ।

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

Question 5

আপনি যদি কেবল যুক্তিগুলির তালিকা চান তবে পিটারের উত্তরটি আপনার ঠিক কী প্রয়োজন।

যাইহোক, আপনি UNIX- এর উপর বর্তমান অনুরূপ কার্যকারিতা খুঁজছেন, তাহলে আপনি ব্যবহার করতে পারে যেতে যেতে বাস্তবায়ন এর docopt । আপনি এটি এখানে চেষ্টা করতে পারেন ।

ডকপ্টটি জেএসএনকে ফিরিয়ে দেবে যা আপনি তখন আপনার হৃদয়ের সামগ্রীতে প্রসেস করতে পারেন।

Question 6

দ্রুত উত্তর:

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:]পক্ষে যুক্তিগুলি হোল্ড করে। রেফারেন্স

Question 7

আপনি উদাহরণস্বরূপ গোলং পতাকা প্যাকেজটি ব্যবহার করতে পারেন,

package main

import (
    "flag"
    "fmt"
)

func main() {

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

}

ক্লাইমে কল করুন

 go run main.go -word=hello

আউটপুট

word: hello