How to specify positional arguments with the flag package in Golang?

Sometimes I want to pass an argument on the command line with no name, say a command like wc, which takes a filename as input:

wc filename.txt

With the flag package, it looks like every flag has to be given a name, with a default value if unspecified.

filename := flag.String("filename", "foo.txt", "Which file to count the words for")

However I don't want a default value, I want the program to exit with an error code if an argument is not specified. How would I add a required argument to a Go binary?

I would also like to be able to parse arguments with type information, so just checking the Args() directly doesn't quite do it.

You just have to check flag.NArg().

From https://golang.org/pkg/flag/#NArg:

> NArg is the number of arguments remaining after flags have been processed.

flag.Parse()
if flag.NArg() == 0 { 
    flag.Usage()
    os.Exit(1)
}

You can also use the flag.Narg() function to ensure you have the required number of positional arguments, though I don't know what it gives you over len(flag.Args())

if flag.NArg() < minArgs { 
    // do something
    ...
}

In case anyone is unsatisfied with the standard flag package behavior of stopping the parse as soon as it sees the first positional arg, you can use these small library functions to parse flags in a way that flags can come before or after positional args.

// ParseFlags parses the command line args, allowing flags to be
// specified after positional args.
func ParseFlags() error {
	return ParseFlagSet(flag.CommandLine, os.Args[1:])
}

// ParseFlagSet works like flagset.Parse(), except positional arguments are not
// required to come after flag arguments.
func ParseFlagSet(flagset *flag.FlagSet, args []string) error {
	var positionalArgs []string
	for {
		if err := flagset.Parse(args); err != nil {
			return err
		}
		// Consume all the flags that were parsed as flags.
		args = args[len(args)-flagset.NArg():]
		if len(args) == 0 {
			break
		}
		// There's at least one flag remaining and it must be a positional arg since
		// we consumed all args that were parsed as flags. Consume just the first
		// one, and retry parsing, since subsequent args may be flags.
		positionalArgs = append(positionalArgs, args[0])
		args = args[1:]
	}
	// Parse just the positional args so that flagset.Args()/flagset.NArgs()
	// return the expected value.
	// Note: This should never return an error.
	return flagset.Parse(positionalArgs)
}