30 Golang programming examples for beginners
Golang which is also called Go programming language is an open-source programming language designed by Google in 2007. Version 1.0 of this language was released in 2012. It is a structured programming language like C and different types of applications such as networking services, cloud applications, web applications, etc. can be developed by Golang language. It contains many types of packages like Python. It is very easy to learn, which makes this language popular for new programmers. 30 Golang programming examples have been explained in this tutorial to learn Golang from the basics.
Pre-requisites:
Golang is supported by different types of operating systems. The way of installing Golang on Ubuntu has been shown in this part of the tutorial. Run the following commands to update the system and install the Golang on the system before practicing the examples in this tutorial.
$ sudo apt install golang-go
Run the following command to check the installed version of the Golang.
- Golang hello world
- Golang string variables
- Golang int to string
- Golang string to int
- Golang string concatenation
- Golang multiline string
- Golang split string
- Golang sprintf
- Golang enum
- Golang struct
- Golang array
- Golang set
- Golang for loop
- Golang for range
- Golang while loop
- Golang continue
- Golang switch case
- Golang random number
- Golang sleep
- Golang time
- Golang uuid
- Golang read file
- Golang read file line by line
- Golang write to file
- Golang check if file exists
- Golang csv
- Golang yaml
- Golang http request
- Golang command line arguments
- Golang error handling
Golang hello world
The main package of Golang contains all required packages for Golang programming and it is required to start the execution of the Golang script. The fmt package is required to import for printing the formatted string in the terminal. Create a Golang file with the following script. The string value, ‘Hello World.’ will be printed in the terminal after executing the script.
import "fmt"
//Define the main() function to start the execution
func main() {
//Print a simple message with the new line
fmt.Println("Hello World.")
}
Run the following command to execute the script. Here, the script has been saved in the example1, go file.
Run the following command to build the binary file of the Golang file.
Run the following command to run the executable file.
The following output will appear after executing the above commands,,
Golang string variables
The string variables can be used without defining the data type and with the data type in Golang. Create a Golang file with the following script that will print simple string data and the string data with the string variables. The uses of Printf() and Println() functions have been shown in the script.
//Import the fmt package to print the output
import "fmt"
//Define the main() function
func main() {
//Print a string value with a new line
fmt.Printf("Learn Golang from LinuxHint.com.\n")
//Define the first string variable
var str1 = "Golang Programming. "
//Print the variable without a newline
fmt.Printf("Learn %s", str1)
//Define the second string variable
var str2 = "easy to learn."
//Print the variable with a newline
fmt.Println("It is", str2)
}
The following output will appear after executing the above script. The output of the two concatenated strings are printed here.
Golang int to string
The strconv.Itoa() and strconv.FormatInt() functions can be used to convert the integer to a string value in Golang. The strconv.Itoa() is used to convert the integer value into a string of numbers. The strconv.FormatInt() function is used to convert decimal-based integer values into the string. Create a Golang file with the following script that shows the way of converting the integer to a string in Golang by using the functions mentioned above. A number will be taken from the user and the corresponding string value of the number will be printed as the output.
package main
//Import the fmt and strconv packages
import (
"fmt"
"strconv"
)
//Define the main function
func main() {
//Declare an integer variable
var n int
//Print a message
fmt.Printf("Enter a number: ")
//Take input from the user
fmt.Scan(&n)
//Convert integer to string using Itoa() function
convert1 := strconv.Itoa(n)
fmt.Printf("Converting integer to string using Itoa(): %s\n", convert1)
//Convert integer to string using FormatInt() function
convert2 := strconv.FormatInt(int64(n), 10)
fmt.Printf("Converting integer to string using FormatInt(): %s\n", convert2)
}
The following output will appear after executing the script. The number. 45 has been converted to the string. “45”.
Golang string to int
The strconv.Atoi() function is used to convert the string to an integer in Golang. It takes a string value that will be converted into an integer and returns two types of values. One value is the integer if the conversation is successful and another value is the error if the conversation is unsuccessful otherwise nil value will be returned. Create a Golang file with the following script that will convert a number of string values into an integer by using strconv.Atoi() function. The string value, “342” will be converted into 342 number and printed after the execution.
package main
//Import the fmt and strconv packages
import (
"fmt"
"strconv"
)
//Define the main function
func main() {
//Declare a string variable
str := "342"
//Convert string to integer using Atoi() function
price, err := strconv.Atoi(str)
//check for error
if err == nil {
//Print the converted value
fmt.Printf("The price of the book is %d\n", price)
}else{
//Print the error message
fmt.Println(err)
}
}
The following output will appear after executing the script. The string value, “342” has been converted to 342 here.
Golang string concatenation
Create a Golang file with the following script that will concatenate the strings with the ‘+’ operator by using the Printf() function. The Println() function has been used here to print the concatenated string value by using the ‘+’ operator and Printf() function has been used here to print the concatenated string value by using the ‘%s’ specifier. Two string variables have been declared in the script which are concatenated later.
package main
//Import the fmt package to print the output
import "fmt"
//Define the main function
func main() {
//Declare two string variables
var str1, str2 string
//Assign string values
str1 = " Golang"
str2 = " Programming"
//Concatenating string using '+' operator
fmt.Println("Concatenated string value using '+' operator:", str1 + str2)
//Concatenating string using '%s' specifier
fmt.Printf("Concatenated string value using format specifier: %s%s\n", str1, str2)
}
The following output will appear after executing the script.
Golang multi-line string
Three different ways have been shown in the following example to print the multi-line text by using the Golang script. The ‘\n’ character has been used in the first string variable to generate the multi-line text. The backticks (`) have been used in the second string to print the multi-line text. The backticks (`) with specifiers have been used in the third string to print multi-line text.
//Import the fmt package
import "fmt"
//Define the main function
func main() {
//Declare a multi-line string value with '\n' character
str1 := "Golang programming\is very easy\nto learn.\n\n"
fmt.Printf(str1)
//Declare a multi-line string value with backticks(`)
str2 := `Learn
Golang
from
LinuxHint
Blog.`
fmt.Printf("%s\n\n",str2)
//Declare two string values
language := "Golang"
developer := "Google"
//Declare a string value with variables and backticks
str3 := `%s
is
developed
by
%s.`
fmt.Printf(str3, language, developer)
//Add a new line
fmt.Println()
}
The following output will appear after executing the script. The output of the three string variables that contain multi-line string values has been printed here.
Golang split string
The strings.Split() function has been used to split the string data based on the separator. The following script will take a string value from the user and split the string value based on the colon(:). The total number of split values and the first two split values will be printed after the execution.
//Import the fmt and strings packages
import (
"fmt"
"strings"
)
//Define the main function
func main() {
//Declare a string variable
var str string
//Print a prompt message
fmt.Printf("Enter a string with colon(:)- ")
//Take input from the user
fmt.Scan(&str)
//Define the separator
separator := ":"
//Split the string value
split_value := strings.Split(str, separator)
//Count the number of split values
length := len(split_value)
//Print the number of split values
fmt.Printf("Total number of split values is %d\n", length)
//Print the split values
fmt.Println("The first split value is", split_value[0])
fmt.Println("The second split value is", split_value[1])
}
The following output will appear after executing the script. The input value, “golang:google” has been divided into two parts based on the colon(:).
Golang sprintf
The Sprintf() function is used in Golang to store the formatted string values into a variable like other standard programming languages. A string and an integer variable have been declared in the following script. The values of these variables have been formatted and stored into a variable by using the Sprintf() function.
//Import the fmt package
import "fmt"
//Define the main function
func main() {
//Declare two variables
var str string
var num int
//Assign string value
str = "Golang"
//Assign number value
num = 2012
//Store the combined string value in a variable
combined_str := fmt.Sprintf("The first version of %s is released in %d.", str, num)
//Print the variable
fmt.Printf("The output of the Sprintf(): \n%s\n", combined_str)
}
The following output will appear after executing the script.
Golang enum
The enum or enumerator has been used in Golang to declare a data type of a group of related constant values. The declaration of enum type in Golang is different from other programming languages. An enum type of 12 values has been declared and the numeric value of the particular enum value has been printed later.
//Import the fmt package
import "fmt"
//Declare the type to store the month value in number (1-12)
type Month int
//Declare constants for each month's value starting from 1
const (
Jan Month = iota + 1
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Oct
Nov
Dec
)
//Declare main function
func main() {
//Declare variable with a month value
var M_num = May
//Print the corresponding number value of the month
fmt.Println("The month value in number is ", M_num)
}
The following output will appear after executing the script. The corresponding numeric value of the May is 5.
Golang struct
The struct or structure is used in Golang to declare a type that contains different types of variables. It is useful for storing tabular data or multiple records. In the following script, a structure variable of four elements has been declared. Next, two records have been added by using the defined struct variable. The way of printing the values of the struct in different ways has been shown in the last part of the script.
//Import fmt package
import "fmt"
//Define a structure of four elements
type Product struct {
id string
name string
size string
price int
}
func main() {
//Declare the first structure variable
product1 := Product {"p-1209", "HDD", "5TB", 80}
//Declare the second structure variable
product2 := Product {"p-7342", "Mouse", "", 15}
//Print the structure variables
fmt.Println("First product: ", product1)
fmt.Println("Second product: ", product2)
//Print four values of the first structure variable separately
fmt.Println("First product details:")
fmt.Println("ID: ",product1.id)
fmt.Println("Name: ",product1.name)
fmt.Println("Size: ",product1.size)
fmt.Println("Price: ",product1.price)
}
The following output will appear after executing the script.
Golang array
The array variable is used in Golang to store multiple values of the particular data type like other standard programming languages. The way of declaring and accessing an array of string values and an array of numeric values has been shown in the script.
//Import fmt package
import "fmt"
func main() {
//Declare an array of string values
str_arr := [4] string {"google.com", "ask.com", "bing.com", "you.com"}
//Print the array of string
fmt.Println("String Array values are: ", str_arr)
//Print the 3rd element of the array
fmt.Println("The 3rd value of array is", str_arr[2])
//Declare an array of numeric values
int_arr := [6]int{65, 34, 12, 81, 52, 70}
//Print the array of integer
fmt.Println("Integer Array values are: ", int_arr)
//Print the 4th element of the array
fmt.Println("The 4th value of array is", int_arr[3])
}
The following output will appear after executing the script.
Golang set
The set is another data structure of Golang to store a collection of distinct values. It is used to store unique values in an object. Golang has no built-in set data structure like other programming languages. But this feature can be implemented by using empty struct{} and map. In the following script, a set variable of strings has been declared by using a map with the empty struct. Next, three values have been added, one value has been deleted, and one value has been added again in the set. The values of the set have been printed together and separately.
//Import fmt package
import "fmt"
func main() {
//Define a set of strings
lang := map[string]struct{}{}
//Insert three elements into the set using an empty struct
lang["Go"] = struct{}{}
lang["Bash"] = struct{}{}
lang["Python"] = struct{}{}
//Print the current existing elements of the set
fmt.Println(lang)
//Remove an element from the set
delete(lang, "Python")
//Add a new element to the set
lang["Java"] = struct{}{}
//Print the set values after removing and adding an element
fmt.Println(lang)
fmt.Printf("\nSet values are:\n")
//Print each element of the set separately
for l := range lang {
fmt.Println(l)
}
}
The following output will appear after executing the script.
Golang for loop
The for loop can be used in different ways and for different purposes in Golang. The use of three expressions for loop has been shown in the following script. The loop will be iterated 5 times to take 5 input values and the sum of these input values will be printed later.
//Import fmt package
import "fmt"
func main() {
//Declare an integer variable
var number int
//Declare a variable to store the sum value
var sum = 0
//Define a for loop
for n := 1; n <= 5; n++ {
//Print a prompt message
fmt.Printf("Enter a number:")
//Take input from the user
fmt.Scan(&number)
//Add the input number with the sum variable
sum = sum + number
}
//Print the summation result
fmt.Printf("The sum of five input values is %d\n", sum)
}
The following output will appear after executing the script. The sum of 6, 3, 4, 7, and 9 is 29.
Golang for range
The range is used with the for loop in the Golang to access string, array, and map. The way of accessing an array of strings by using a for loop with range has been shown in the following script. The first for loop will print the array values only and the second for loop will print the indexes and values of the array.
//Import fmt package
import "fmt"
func main() {
//Declare an array of string
flowers := [4] string {"Rose", "Lily", "Dalia", "Sun Flower"}
fmt.Println("Array values are:")
//Print the array values
for _, val := range flowers {
fmt.Println(val)
}
fmt.Println("Array indexes and values are:")
//Print the array values based on index
for in, val := range flowers {
fmt.Printf("%d := %s\n", in + 1, val)
}
}
The following output will appear after executing the script.
Golang while loop
Golang has no while loop like other programming languages. However, the feature of the while loop can be implemented in Golang by using the for loop. The way of implementing a while loop by using a for loop has been shown in the following script. The for loop will be iterated for 4 times and take four numbers. The sum of these numbers with the fractional value will be printed later.
//Import fmt package
import "fmt"
func main() {
counter := 1
sum := 0.0
var number float64
for counter <= 4 {
//Print a prompt message
fmt.Printf("Enter a number: ")
//Take input from the user
fmt.Scan(&number)
//Add the input number with the sum variable
sum = sum + number
//Increment the counter by 1
counter++
}
//Print the summation result
fmt.Printf("The sum of four input values is %0.2f\n", sum)
}
The following output will appear after executing the script. The sum of 6.8, 3.2, 8.5, and 4.9 is 23.40.
Golang continue
The continue statement is used in any loop to omit the particular statements based on a condition. In the following script, the for loop has been used to iterate the loop that will omit the values of the 2nd and the fourth values of the array by using the continue statement.
//Import fmt package
import "fmt"
func main() {
counter := 1
sum := 0.0
var number float64
for counter <= 4 {
//Print a prompt message
fmt.Printf("Enter a number: ")
//Take input from the user
fmt.Scan(&number)
//Add the input number with the sum variable
sum = sum + number
//Increment the counter by 1
counter++
}
//Print the summation result
fmt.Printf("The sum of four input values is %0.2f\n", sum)
}
The following output will appear after executing the script.
Golang switch case
The switch-case statement in Golang is similar to the other programming languages but no break statement is required with each case statement in Golang. The way of defining multiple case values inside the switch block has been shown in the following example.
//Import fmt package
import "fmt"
func main() {
var n int
//Print a prompt message
fmt.Printf("Enter the month value in number: ")
//Take input from the user
fmt.Scan(&n)
//Print message based on the matching case value
switch n {
case 1, 2, 3, 4:
fmt.Println("Winter semester.")
case 5, 6, 7, 8:
fmt.Println("Summer semester.")
case 9, 10, 11, 12:
fmt.Println("Fall Semester.")
default:
fmt.Println("Month value is out of range.")
}
}
The following output will appear after executing the script.
Golang random number
The math/rand package has been used in Golang to generate random numbers. The way of generating four types of random numbers has been shown in the following script. The rand.Int() function is used to generate a long integer random number. The rand.Intn(n) function is used to generate an integer random number of the particular range and the highest value will be passed as the argument value of the function. The 999 is set as the argument value in the script. The rand.Float32() function is used to generate a short fractional random number and the rand.Float64() function is used to generate a long fractional random number.
package main
//Import required modules
import (
"fmt"
"time"
"math/rand"
)
func main() {
//Set seed to generate a random number
rand.Seed(time.Now().UnixNano())
//Print generated random integer
fmt.Println("Random integer value: ", rand.Int())
//Print the random integer within 999
fmt.Println("Random integer value with range: ", rand.Intn(999))
//Print the random 32 bits float
fmt.Println("Random 32 bits float value: ", rand.Float32())
//Print the random 64 bits float
fmt.Println("Random 64 bits float value: ", rand.Float64())
}
The following output will appear after executing the script.
Golang sleep
The time.Sleep() function is used in Golang to pause the execution of the script for a certain period. The following script will calculate the average of three numbers and wait for 3 seconds before terminating the script.
package main
//Import required packages
import (
"fmt"
"time"
)
func main() {
fmt.Println("Start executing the script...")
//Define three variables
a := 40
b := 30
c := 29
//Print the variables
fmt.Printf("Three numbers are : %d, %d, %d\n", a, b, c)
fmt.Println("Calculating the average of three numbers...")
avg := (a + b + c)/3
//Delay for 3 seconds
time.Sleep(3 * time.Second)
//Print the results
fmt.Printf("The average value is %d\n", avg)
fmt.Println("Program terminated.")
}
The following output will appear after executing the script.
Golang time
The time package is used in Golang to read the current date and time. This package has many methods and properties to read the date and time in different ways. The date and time, ‘Mon Jan 2 15:04:05 -0700 MST 2006’ is used as the reference value in Golang to access the date and time. The uses of the time package have been shown in the following example.
//Import required packages
import (
"fmt"
"time"
)
func main() {
//Read the current date and time
today := time.Now()
//Print the current date
fmt.Printf("Today is %s.\n", today.Format("02-Jan-2006"))
//Print the current date and time
fmt.Printf("The current date and time is %s\n.", today.Format(time.RFC1123))
}
The following output will appear after executing the script.
Golang uuid
The UUID or Universally Unique Identifier can be generated by Golang script. It is a 128-bit unique value to identify the computer system. You have to download the uuid from the github.com/google/uuid before executing the following script.
Go to the home directory and run the following commands to download the required package to generate the uuid by Golang script.
$ go get github.com/google/uuid
In the following script, the first uuid is generated by using the uuid.New() function that returns a unique identifier. The second uuid is generated by the uuid.NewUUID() function that returns two values. The value contains the unique identifier and the second value contains the error message if it exists.
//Import required packages
import (
"fmt"
"github.com/google/uuid"
)
func main() {
//Generate a unique ID using New() function
newID := uuid.New()
fmt.Printf("Generated first UUID is %s.\n", newID)
//Generate a unique ID using NewUUID() function
newID, err := uuid.NewUUID()
//Check for error
if err == nil {
fmt.Printf("Generated second UUID is %s.\n", newID)
}else{
fmt.Println(err)
}
}
The following output will appear after executing the script.
Golang read file
The io/ioutil package of Golang is used to read the content of a file. The ReadFile() function of this package reads the whole content of a file. This function returns the full content of the file into a variable if the file exists otherwise an error message will be returned. The way of reading the full content of an existing text file has been shown in the following script.
package main
//Import required packages
import (
"io/ioutil"
"fmt"
"log"
)
func main() {
//Read a text file
text, err := ioutil.ReadFile("Languages.txt")
//Check for error
if err == nil {
fmt.Printf("Content of the file:\n\n")
fmt.Println(string(text))
}else{
log.Fatalf("File read error: %v", err)
}
}
The following output will appear after executing the script.
Golang read file line by line
The “bufio” package of Golang is used to read the content of a file line by line. In the following script, the bufio.NewScanner() has been used to create an object to read the file. Next, the Scan() function has been used with the loop to read and print each line of the file.
package main
//Import required packages
import (
"fmt"
"os"
"bufio"
)
func main() {
//Open a text file for reading
fh, err := os.Open("Languages.txt")
//Check for error
if err == nil {
//Scan the file content
read := bufio.NewScanner(fh)
//Read the file line by line
for read.Scan() {
fmt.Println(read.Text())
}
}else{
fmt.Println(err)
}
//Close the file
defer fh.Close()
}
The following output will appear after executing the script.
Golang write to file
The os package of the Golang is used to open a file for writing and the WriteString() function is used to write content into a file. The way of creating and writing a text file of three lines is by using the os package.
//Import required packages
import (
"fmt"
"os"
)
func main() {
//Open a file for writing
fh, err1 := os.Create("items.txt")
//Check for file creation error
if err1 == nil {
//Write into the file
_, err2 := fh.WriteString("Pen\nPencil\nRuler\n")
//Check for file writing error
if err2 != nil {
fmt.Println("File write error occurred.\n")
}
}else{
fmt.Println("File creation error occurred.\n")
}
//Close the file
defer fh.Close()
}
The following output will appear after executing the script. The output shows that the items.txt file has been created successfully.
Golang checks if file exists
The os package of the Golang can be used to check the existence of the file. In the following script, the file path will be taken from the script. If the path does not exist then the os.State() function will return an os.ErrNotExist error.
//Import required module
import (
"errors"
"fmt"
"os"
)
func main() {
var filepath string
fmt.Printf("Enter an existing filename: ")
//Take the file path from the user
fmt.Scan(&filepath)
//Check the file path
_, error := os.Stat(filepath)
//Check the output of the os.Stat
if !errors.Is(error, os.ErrNotExist) {
fmt.Println("File is found.")
} else {
fmt.Println("File is not found.")
}
}
The following output will appear after executing the script.
Golang csv
The “encoding/csv” package is used in Golang to read the content of the CSV file. The csv.NewReader() function is used to read the CSV file. Create a CSV file before executing the script of this example. Here, the customers.csv file has been used to show the way of reading the CSV file.
//Import required packages
import (
"encoding/csv"
"fmt"
"os"
)
func main() {
//Open a CSV file for reading
fh, err := os.Open("customers.csv")
//Check for the error
if err != nil {
fmt.Println(err)
}else{
//Create an object to read the CSV file
scanner := csv.NewReader(fh)
//Read all records of the CSV file
records, _ := scanner.ReadAll()
//Read the CSV file line by line
for _, r := range records {
for _, c := range r {
fmt.Printf("%s,", c)
}
fmt.Println()
}
}
//Close the file
defer fh.Close()
}
The following output will appear after executing the script.
Golang yaml
The yaml.Marshal() function is used in Golang to read the content of the yaml data. You have to download the yaml package to use the yaml.Marshal(). Go to the home directory and run the following command to download the yaml package.
In the following script, a structure variable of four elements has been declared that has been used later to define a yaml object with data. Next, the yaml.Marshal() function has been used to access the yaml data.
//Import required packages
import (
"fmt"
"gopkg.in/yaml.v2"
)
//Declare a structure of 4 elements
type Book struct {
Title string
Author string
Publication string
Price string
}
func main() {
//Create an object of the structure
book1 := Book{
Title: "Learning Go",
Author: "John Bodner",
Publication: "O'Relly",
Price: "$39",
}
//Read the yaml data based on the struct
y_data, err := yaml.Marshal(&book1)
//Checkk for the error
if err == nil {
//Print the yaml data
fmt.Println(string(y_data))
}else{
fmt.Printf("Error while Marshaling. %v", err)
}
}
The following output will appear after executing the script.
Golang http request
The net/http package of the Golang is used to send the http requests to a website. The http.Get() function is used to send the request. It returns the response from the site or the error message. The way of sending the http request to the website, https://example.com has been shown in the following script.
//Import required packages
import (
"fmt"
"net/http"
)
func main() {
//Send a GET request to a website
res, err := http.Get("https://example.com")
//Check for error
if err == nil {
//Print the response sent by the website
fmt.Println(res)
}else{
//Print the error message
fmt.Println(err)
}
}
The following output will appear after executing the script.
Golang command line arguments
The values that are passed at the time of the execution of the script are called command-line argument values. The os package is used to read the command line argument values in Golang. The argument values are stored in the Args[] array. The for loop with the range has been used in the script to print the argument values without the script name in each line.
//Imports required packages
import (
"fmt"
"os"
)
func main() {
fmt.Println("All argument values are:")
//Print all argument values with the script name
fmt.Println(os.Args)
fmt.Println("Argument values:")
//Print all argument values without a script name
for in, _ := range os.Args {
if in == 0 {
continue
}
fmt.Println(os.Args[in])
}
}
The following output will appear after executing the script.
Golang error handling
Golang has no try-catch block like other programming languages. However, the errors package can be used in Golang to handle errors in the script. In the following script, an integer number will be taken from the user. If the user takes a negative number then an error message will be printed. The errors.New() function has been used here to generate the error message.
//Import required packages
import (
"errors"
"fmt"
)
func main() {
var n int
fmt.Printf("Enter a number: ")
fmt.Scan(&n)
//Check the input value
result, err := Positive(n)
//Check for error
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("%d %s\n", n, result)
}
}
///Define function to check positive number
func Positive(num int) (string, error) {
if num < 0 {
return "", errors.New("Type a positive number.")
}else{
return "number is positive.", nil
}
}
The following output will appear after executing the script.
Conclusion:
Golang is a popular programming language now that has many useful packages like the Python programming language. Any novice user can learn Golang as a first programming language because it is very easy to learn. The basic 30 Golang examples have been explained in this tutorial to learn Golang from the beginning and the learners will be able to write programs in Golang. One of the major limitations of this language is that it does not contain the features of object-oriented programming but it is good for learning structured programming.
Source: linuxhint.com