In this article, we will be discussing and writing practical code on how to take or parse multiple inputs from users in Golang.
Different methods to parse multiple inputs from user
Golang is a procedural language, Reading a user's inputs requires variables assigning, processing it into the standard output such as a monitor. Golang provides standard libraries such as fmt and bufio packages, help us with various function in reading and displaying users inputs. In a nutshell, reading inputs involves:-
- using a standard package that has input and output functions.
- Declare a variable that holds the inputs to be displayed.i.e
var variableName datatype - Using a standard library like
fmt.Scan()to read and store input into variable defined.
The following are functions used to read users' inputs in Golang:-
fmt.Scanln()fmt.Scanf()bufio.NewReader()
Method 1:- fmt.Scanln()
Golang fmt package does not only provide us with the capability to format data into various forms and print the output on the terminal, Its robust in the way to lets users enter multiple values stored into a various variables to hold respective inputs of different types using fmt.Scanln(). It's one of the examples of vardiac functions used in golang. It accepts an ellipses of data interface, i.e func Scanln( val ...anyType)(return integerValue, error). It returns a response of integer and error types. All inputs are captured in a single sentence. The integer value represents the total number of inputs provided For example Reading user information into a struct.
package main
import (
"fmt"
)
type Person struct {
FullName string
TelephoneNo int64
Occupation string
Country_Of_Residence string
}
func main() {
fmt.Println("Kindly enter your data in following order: ")
var firstname, lastname, occupation, country string
var phoneNo int64
fmt.Println(" firstname, lastname, occupation, country, phoneNo")
totalInputs, errReading := fmt.Scanln(&firstname, &lastname, &country, &occupation, &phoneNo)
if errReading != nil {
fmt.Printf("Your input could not be read%v", errReading)
}
//fullname
fullname := fmt.Sprintf("%v %v", firstname, lastname)
// map values into struct
person := Person{
fullname,
phoneNo,
occupation,
country,
}
fmt.Printf(" you entered a total of %v items into scanln function", totalInputs)
fmt.Println("\n----------Your Data is as follows .........")
fmt.Println("\nFullName\tPhoneNo\tOccupation\tCountry of Residence ")
fmt.Println(person)
}
Output:
$ go run main.go
Kindly enter your data in the following order:
firstname, lastname, occupation, country, phoneNo
John Doe USA DataScientist 01233333
you entered a total of 5 items into scanln function
----------Your Data is as follows .........
FullName PhoneNo Occupation Country of Residence
{John Doe 341723 DataScientist USA}
Explanation:- In the above code, we declare variables to hold various input values. Reading is made by fmt.Scanln() function, which gets a pointer to the variable defined. It returns the total number of inputs made by the user. we can map the values into a struct and print out the results.
Method 2:- fmt.Scanf()
fmt.Scanf()is a function provided by the fmt package in Golang standard libraries. It reads users' inputs values in the standard input (stdin) and this values format i.e "%v, %s,%2f" is determined then stored in a variable. For example of multiple inputs:-
package main
import (
"fmt"
)
func areaTriangle(base, height float64) float64 {
return 0.5 * base * height
}
func main() {
var base, height float64
fmt.Println("Kindly enter the base and height values, separated by space to determine the area of a triangle")
_, err := fmt.Scanf("%2f %2f", &base, &height)
if err != nil {
fmt.Printf("Sorry an error occurred %v", err)
}
result := areaTriangle(base, height)
fmt.Printf("The area of the triangle is %v", result)
}
Output:
$ go run main.go
Kindly enter the base and height values, separated by space to determine the area of a triangle
3 4
The area of the triangle is 6
Explanation: In above code, we are reading data of type float64 and using "%2f" convert it to a specific float format, then the variable values are passed to areaTriangle() function to calculate the area , results displayed on the terminal.
Method 3:- bufio.NewReader()
Using golang standard library one can create a command line interface known as CLI. This tool is just an emulation of Terminal in macOS and Linux or PowerShell in windows operating systems. Here users can type a whole sentence or short sentences. Golang provides us with bufio.NewReader() which can read and store users' input into a variable. It Golang function that returns multiple values. For example :
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
func main() {
fmt.Println("Kindly Provide a brief Description of GolinuxCloud company: once done typing, kindly tap enter button to display your content.")
// using standard input in this case its the terminal
// once done
userData, err := bufio.NewReader(os.Stdin).ReadString('\n');
if err != nil {
_ = fmt.Errorf(" %v error", err)
return
}
// Display user's data stdout
results:= strings.TrimSuffix(userData, "\n")
fmt.Printf("Results you Provided: \n %v", results)
}
Output:-
$ go run main.go
Kindly Provide a brief Description of the GolinuxCloud company:
It's an online academic platform, It's enriched with numerous technology materials. DevOps, Web, IOS, and Android developer visit here for upskilling....
Results you Provided:
It's an online academic platform, It's enriched with numerous technology materials. DevOps, Web, IOS, and Android developer visit here for upskilling....
Explanation:- In the above code, we are making use of bufio.NewReader() function, from bufio package in golang standard library. It takes parameters implemented by io.Reader packages such as os.Stdin or StdEr etc. os.StdIn works as an interface and opens the file that points to standard inputs i.e command line interface or terminal. The last event of delimeter() known as '\n' refers to enter key which inserts a new line using the ReadString() function and returns data containing the delimiter. Here the sentence ends with the '\n' character and we have to remove it using string.TrimSuffix() method allows us to pass the data followed by the special character to remove. upon tapping enter key. we use the fmt.Printf() function to display the user's results content on the terminal.
Summary
In a nutshell, in this article, we have discussed a few ways we can read users' inputs from the standard input and display using standard output i.e terminal. Using golang you can develop different tools to interact with the command line interface. You can read more about cobra framework for developing CLI applications in golang. Flags and OS packages too can help you design a well-programmed CLI of your choice.
References
