A Guide to Handling Stdin and Stdout in Go

Introduction
Prerequisites
Setup
Reading from Stdin
Writing to Stdout
Example: Reversing a String
Conclusion

Introduction

Welcome to this tutorial on handling Stdin and Stdout in Go! In this tutorial, we will learn how to read input from the standard input (Stdin) and write output to the standard output (Stdout). By the end of this tutorial, you will be able to write Go programs that can interact with the user through the command line.

Prerequisites

Before starting this tutorial, you should have a basic understanding of the Go programming language and its syntax. Familiarity with command-line interfaces (CLI) will also be beneficial.

Setup

To follow along with this tutorial, you need to have Go installed on your machine. You can download and install Go from the official website: https://golang.org/dl/

Once Go is installed, you can verify the installation by opening a terminal and running the following command:

go version

If Go is properly installed, it will display the installed Go version.

Reading from Stdin

In Go, we can read input from the Stdin using the bufio package. The bufio package provides buffered I/O operations for efficient reading of characters, strings, and lines from the input.

To read from the Stdin, follow these steps:

Import the bufio package:
```
 import (
 	"bufio"
 	"os"
 )
```
Create a Scanner object using bufio.NewScanner and pass os.Stdin as the input:
```
 scanner := bufio.NewScanner(os.Stdin)
```
Use the Scan method of the Scanner object to read the input line by line:
```
 for scanner.Scan() {
     input := scanner.Text()
     // Process the input
 }
```
The Scan method reads the next line from the Stdin and returns true if a line is read successfully, or false if there is no more input left. The accessed line can be retrieved using scanner.Text().

Let’s see an example that reads and prints each line from the Stdin:
```
 package main
    
 import (
 	"bufio"
 	"fmt"
 	"os"
 )
    
 func main() {
 	scanner := bufio.NewScanner(os.Stdin)
    
 	for scanner.Scan() {
 		input := scanner.Text()
 		fmt.Println(input)
 	}
    
 	if err := scanner.Err(); err != nil {
 		fmt.Fprintln(os.Stderr, "error:", err)
 		os.Exit(1)
 	}
 }
```
Save the program in a file like stdin_example.go and compile and run it using the following command:
```
 go run stdin_example.go
```
Now, you can enter multiple lines of text in the command-line interface, and the program will print each line.

Writing to Stdout

Writing to the Stdout in Go is straightforward. We can use the fmt package to print data to the standard output.

The fmt package provides a variety of functions like Print, Println, Printf, etc., to format and output data. We can use these functions to write text or formatted values to the Stdout.

To write to the Stdout, follow these steps:

Import the fmt package:
```
 import "fmt"
```
Use the Println function to write a line to the Stdout:
```
 fmt.Println("Hello, World!")
```
The Println function writes the provided text followed by a newline character to the Stdout.

Here’s an example that writes some text to the Stdout:
```
 package main
    
 import "fmt"
    
 func main() {
 	fmt.Println("Hello, World!")
 }
```
Save the program in a file like stdout_example.go and compile and run it using the following command:
```
 go run stdout_example.go
```
The program will print the text “Hello, World!” to the command-line interface.

Example: Reversing a String

Let’s now put our Stdin and Stdout knowledge together and create an example program that reverses a string. This program will read a string from the Stdin and print its reversed version to the Stdout.

Here’s the example program:

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	fmt.Print("Enter a string: ")
	scanner.Scan()
	input := scanner.Text()

	reversed := reverseString(input)
	fmt.Println("Reversed string:", reversed)
}

func reverseString(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

Save the program in a file like reverse_string.go and compile and run it using the following command:

go run reverse_string.go

The program will prompt you to enter a string. After entering the string, it will print the reversed version of the string.

Conclusion

In this tutorial, we learned how to handle Stdin and Stdout in Go. We explored how to read input from the Stdin using the bufio package and how to write output to the Stdout using the fmt package. We also created an example program that reversed a string using Stdin and Stdout.

By understanding these concepts, you can build powerful command-line programs that can interact with the user and process inputs from the command-line interface. Take this knowledge and apply it to your own Go projects to enhance the user experience and enable interactive applications.

Remember, practice makes perfect. Keep exploring and experimenting with Go’s Stdin and Stdout capabilities to become more proficient in handling user input and producing meaningful output.

Happy coding!

Published: 5 September 2022