Golang flag.String Function

The flag.String function in Go is used to define a string flag and return a pointer to the string variable that stores the flag’s value. This function is part of the flag package and is useful when you want to define a command-line flag and directly retrieve its value without binding it to a pre-declared variable.

Syntax

func String(name string, value string, usage string) *string

Parameters:

• name: The name of the command-line flag (e.g., -flagname).
• value: The default value of the flag if it is not provided by the user.
• usage: A short description of the flag’s purpose, which is shown in the help output.

Returns:

• *string: A pointer to a string variable that holds the value of the flag.

Example Usage

Basic Example

This example demonstrates how to use flag.String to define a string flag and retrieve its value.

package main

import (
	"flag"
	"fmt"
)

func main() {
	// Define the flag and get a pointer to the string variable
	name := flag.String("name", "World", "a name to say hello to")

	// Parse the command-line flags
	flag.Parse()

	// Use the flag value by dereferencing the pointer
	fmt.Printf("Hello, %s!\n", *name)
}

Output:

If the program is run with go run main.go -name=Gopher:

Hello, Gopher!

If the program is run without any flags:

Hello, World!

Explanation:

• The flag.String function defines a -name flag with a default value of "World" and returns a pointer to the string variable that stores the flag’s value.
• The flag.Parse function processes the command-line arguments and updates the value of the name variable if the flag is provided.
• The program then uses the flag value by dereferencing the pointer (*name).

Using Multiple Flags with flag.String

You can define multiple string flags using flag.String and retrieve their values through the returned pointers.

Example

package main

import (
	"flag"
	"fmt"
)

func main() {
	// Define multiple flags and get pointers to the string variables
	host := flag.String("host", "localhost", "hostname or IP address")
	port := flag.String("port", "8080", "port number")

	// Parse the command-line flags
	flag.Parse()

	// Use the flag values by dereferencing the pointers
	fmt.Printf("Connecting to %s:%s\n", *host, *port)
}

Output:

If the program is run with go run main.go -host=example.com -port=9090:

Connecting to example.com:9090

If the program is run without any flags:

Connecting to localhost:8080

Explanation:

• The flag.String function is used to define the -host and -port flags, returning pointers to the respective string variables.
• The flag.Parse function processes the command-line arguments, and the program uses the values by dereferencing the pointers.

Default Values and Usage Messages

The default values and usage messages provided in flag.String are shown when the user requests help (e.g., by using -h or --help).

Example

package main

import (
	"flag"
	"fmt"
)

func main() {
	// Define a string flag and get a pointer to the string variable
	logLevel := flag.String("loglevel", "info", "set the logging level (e.g., debug, info, warn, error)")

	// Parse the command-line flags
	flag.Parse()

	// Use the flag value by dereferencing the pointer
	fmt.Printf("Logging level set to %s\n", *logLevel)
}

If the program is run with go run main.go --help:

Output:

Usage of /tmp/go-build123456789/b001/exe/main:
  -loglevel string
        set the logging level (e.g., debug, info, warn, error) (default "info")

Explanation:

• The flag.String function defines a -loglevel flag with a default value of "info" and a usage description.
• When the user requests help, the usage message is displayed along with the default value.

Accessing Non-Flag Arguments

After calling flag.Parse, any command-line arguments that are not associated with flags can be accessed using the flag.Args function.

Example

package main

import (
	"flag"
	"fmt"
)

func main() {
	// Define a string flag and get a pointer to the string variable
	greeting := flag.String("greeting", "Hello", "greeting message")

	// Parse the command-line flags
	flag.Parse()

	// Access non-flag arguments
	nonFlagArgs := flag.Args()

	// Use the flag value and non-flag arguments
	fmt.Printf("%s, %v!\n", *greeting, nonFlagArgs)
}

Output:

If the program is run with go run main.go -greeting=Hi Gopher:

Hi, [Gopher]!

Explanation:

• The flag.Args function returns a slice of non-flag arguments provided on the command line.
• The program uses the flag value and the non-flag arguments to generate a greeting.

Conclusion

The flag.String function in Go is a convenient way to define string flags and retrieve their values directly through pointers. This approach simplifies the management of command-line arguments, allowing you to set default values, provide descriptive usage messages, and efficiently handle user input. By using flag.String, you can create flexible and user-friendly command-line interfaces in your Go applications.