Table of Contents
- Introduction
- Prerequisites
- Setup
- Reading Command Line Arguments
- Executing External Commands
- Writing Output to the Command Line
- Conclusion
Introduction
In this tutorial, we will explore how to interact with the command line in Go. We will learn how to read command line arguments, execute external commands, and write output to the command line. By the end of this tutorial, you will be able to build command line tools and scripts in Go.
Prerequisites
Before starting this tutorial, you should have a basic understanding of Go programming language syntax and fundamentals. You should have Go installed on your machine and be familiar with the command line interface.
Setup
To follow along with this tutorial, make sure you have Go installed on your machine. You can download and install Go from the official website: https://golang.org/dl
Once Go is installed, open a terminal or command prompt and verify the installation by running the following command:
go version
This command should display the installed Go version, confirming that Go is properly installed on your machine.
Reading Command Line Arguments
Often, command line tools and scripts require input from the user. Go provides the os.Args variable to access the command line arguments.
package main
import (
"fmt"
"os"
)
func main() {
args := os.Args[1:]
for i, arg := range args {
fmt.Printf("Argument %d: %s\n", i, arg)
}
}
In the above example, os.Args is a slice containing all the command line arguments, including the program name itself. We use a for loop to iterate over the arguments and print them to the command line.
Save the above code in a file named main.go, and then run the following command in the terminal:
go run main.go hello world
This will output:
Argument 0: hello
Argument 1: world
You can pass any number of arguments when running the program.
Executing External Commands
Go allows you to execute external commands directly from your program using the os/exec package. Let’s see an example of executing the ls command to list files and directories in the current directory.
package main
import (
"fmt"
"os/exec"
)
func main() {
cmd := exec.Command("ls")
output, err := cmd.Output()
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println(string(output))
}
In the above code, we create a new Command struct with the command name as “ls”. We then use the Output() method to execute the command and capture the output. Finally, we print the output to the command line.
Save the above code in a file named main.go, and then run the following command in the terminal:
go run main.go
This will list the files and directories in the current directory.
You can also provide arguments to the external command. Let’s modify the previous example to use the -l flag for a detailed file listing.
package main
import (
"fmt"
"os/exec"
)
func main() {
cmd := exec.Command("ls", "-l")
output, err := cmd.Output()
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println(string(output))
}
Save the above code in a file named main.go, and then run the following command in the terminal:
go run main.go
This will list the files and directories in the current directory with detailed information.
Writing Output to the Command Line
To write output to the command line, Go provides the fmt package. You can use fmt.Println() to write a line of text, or fmt.Printf() to format and print text.
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Save the above code in a file named main.go, and then run the following command in the terminal:
go run main.go
This will output:
Hello, World!
You can also format the output using placeholders. For example:
package main
import "fmt"
func main() {
name := "John"
age := 30
fmt.Printf("My name is %s and I'm %d years old.\n", name, age)
}
Save the above code in a file named main.go, and then run the following command in the terminal:
go run main.go
This will output:
My name is John and I'm 30 years old.
Conclusion
In this tutorial, we learned how to interact with the command line in Go. We explored reading command line arguments, executing external commands, and writing output to the command line. With this knowledge, you can now build your own command line tools and scripts in Go.
Remember to experiment with different examples and explore the Go documentation for more advanced features and possibilities. Happy coding!