Page Title

Tutorial 3

Go Language

Overview

Go also known as Golang is an open source, compiled and statically typed programming language having syntax similar to that of C, developed at Google in the year 2007 by Robert Griesemer, Rob Pike, and Ken Thompson.

Go is a general-purpose programming language with a simple syntax and is backed by a robust standard library.

Go can also be used to create command-line applications, desktop apps and even mobile applications.

Advantages of Go

Why would you choose Go as your server side programming language when there are tonnes of other languages such as python, ruby, nodejs... that do the same job.

Here are some of the pros

Simple syntax

The syntax is simple and concise and the language is not bloated with unnecessary features. This makes it easy to write code that is readable and maintainable.

Easy to write concurrent programs

Concurrency is an inherent part of the language. As a result, writing multithreaded programs is a piece of cake.

Compiled language

Go is a compiled language. The source code is compiled to a native binary. This is missing in interpreted languages such as JavaScript used in nodejs.

Fast compilation

The Go compiler is pretty amazing and it has been designed to be fast right from the beginning.

Garbage collection

Go uses garbage collection and hence memory management is pretty much taken care automatically and the developer doesn't need to worry about managing memory.

Open source

Go is an open source project. You can participate and contribute to the Go project.

Go Tooling

Go comes bundled with powerful tools that help developers write better code.

Few of the commonly used tools are,

gofmt : gofmt is used to automatically format go source code. It uses tabs for indentation and blanks for alignment.
vet : vet analyses the go source code and reports possible suspicious code.

Everything reported by vet is not a genuine problem but it has the capability to catch errors that are not reported by the compiler such as incorrect format specifiers when using Printf.
golint : golint is used to identify styling issues in the code

We will learn later about these tools in details.

Installation

Go can be installed on all the three platforms Mac, Windows, and Linux. You can download the binary for the corresponding platform from https://golang.org/dl/

Windows :

Download the MSI installer. Double tap to start the installation and follow the prompts. This will install Go in location c:\Go and will also add the directory c:\Go\bin to your path environment variable.

Linux :

Download the tar file and unzip it to /usr/local.

Add /usr/local/go/bin to the PATH environment variable. This will install Go in Linux.

Mac OS :

Download the Mac OS installer. Double tap to start the installation. Follow the prompts and this will have Golang installed in /usr/local/go and would have also added the folder /usr/local/go/bin to your PATH environment variable.

How to know that Go has been successfuly installed?

To verify that Go installed successfully, type the command go version in the terminal and it will output the installed Go version.

$ go version
go version go1.13.6 darwin/amd64

Your first Program "Hello SoloLearner"

Before write first program we have to setup the Go workspace

In the case of Mac or Linux, the GO workspace should be located in $HOME/go.

In the case of Windows, the workspace should be located in C:\Users\userName\go.

It is possible to use a different directory as the workspace by setting the GOPATH environment variable.

Note : All the source files for GO should be located in a directory named src inside the workspace.

Your first Program :

package main
import "fmt"

func main() {
    fmt.Println("Hello SoloLearner, I am going to introduce tutorial on GO Language. I hope you will enjoy. ")
}

Save the following program as hellosololearner.go in the the hello directory inside src

Running a GO program

There are a couple of different ways to run a go program

1 - Using go run command - Type go run workspacepath/src/hello/hellosololearner.go in the command prompt.

workspacepath can be replaced by the path of your work space (C:/Users/userName/go in windows and $HOME/go in linux or Mac)

2 - Using go install command - Run go install hello command followed by workspacepath/bin/hello to run the program.

When you type go install hello, the go tool searches for the hello package inside the workspace. Then it creates a binary named hello(hello.exe in the case of windows) inside the bin directory of the workspace.

You can run your first program here

Explaination :

package main - Every go file must start with the package name. Here package name is main.
import "fmt" - The fmt package is used inside the main function to print text to the standard output.
func main() - The main is a special function. The program execution starts from the main function. The main function should always reside in the main package. The { and } indicate the start and end of the main function.
Println - The Println function of the fmt package is used to write text to the standard output.

Variables

Variable is the name given to a memory location to store a value of a specific type. There are various syntaxes to declare variables in Go.

Declaring a single variable :

You can declare a variable using syntax var name type where var is used to declare variable, name is a variable name and type is used to define the data type of variable like int

package main
                            
import "fmt"
                                
func main() {    
    var age int // variable declaration
    fmt.Println("My age is",  age)
}

If a variable is not assigned any value, Go automatically initializes it with the 0 value of the variable's type. In this case, age is assigned the value 0 which is a type of int

Output :

My age is 0

Note : A variable statement can be at package or function level.

Example :

package main

import "fmt"
                                
var c, python, java bool //package level variable
                                
func main() {
    var age int // function level variable
    fmt.Println(age, c, python, java)
}

In the above program declared variable c, python, java are at package level and variable age is at function level.

Assigning a variable :

A variable can be assigned to any value of its type.

package main

import "fmt"
                                
func main() {
    var age int // variable declaration

    fmt.Println("My age is",  age")
    
    var age = 32 //assignment
    fmt.Println("My age is",  age)
}

Output :

My age is 0
My age is 32

Declaring a variable with an initial value :

A variable can also be provided an initial value when it is declared under the syntax var name type = initialvalue

package main

import "fmt"
                                
func main() {
    var age int = 32 //variable declaration with initial value
    fmt.Println("My age is",  age)
}

Output :

My age is 32

Multiple variable declaration

Multiple variables can be declared using a single statement using syntax var name1, name2 type = initialvalue1, initialvalue2

package main

import "fmt"
                                
func main() {
    var age, height int = 32, 180 //declaring multiple variables
    fmt.Println("Age is",  age, "Height is", height)
}

Output :

Age is 32 Height is 180

The type can be removed if the variables have an initial value. Since the above program has initial values for variables, the int type can be removed.

Note : We can also declare different types of variables in a single statement. The syntax for thie

var (
    name1 = initialvalue1
    name2 = initialvalue2
)

The following program uses the above syntax to declare variables of different types.

package main

import "fmt"
                                
func main() {
    var (
        name   = "AJ"
        age    = 32
    )

    fmt.Println("My name is", name, ", age is", age)
}

Output :

My name is AJ , age is 32

Variable Declaration Omit Types

You can omit the variable type from the declaration, when you are assigning a value to a variable at the time of declaration. The type of the value assigned to the variable will be used as the type of that variable.

package main

import (
    "fmt"
    "reflect"
)
                            
func main() {
    var i = 10
    var s = "India"
                            
    fmt.Println(reflect.TypeOf(i))
    fmt.Println(reflect.TypeOf(s))
}

Output :

int
string

Short hand declaration

name := initialvalue is the short hand syntax to declare a variable.

package main

import "fmt"
                                
func main() {
    x := "Hello Sololearn"
    fmt.Println(x)
}

Output :

Hello Sololearn

It is also possible to declare multiple variables in a single line using short hand syntax.

package main

import "fmt"

func main() {
name, age := "AJ", 32 //short hand declaration

fmt.Println("My name is", name, ", age is", age)
}

Output :

My name is AJ , age is 32

Note : Short hand declaration requires initial values for all variables on the left-hand side of the assignment otherwise it will give error.

package main

import "fmt"

func main() {
name, age := "AJ" //error

fmt.Println("My name is", name, ", age is", age)
}

Output :

./prog.go:6:15: assignment mismatch: 2 variables but 1 values

Scope of the Variable

Golang uses lexical scoping based on code blocks to determine the scope of variables. Inner block can access its outer block defined variables, but outer block cannot access inner block defined variables.

package main

import "fmt"

var country = "India"

func main() {
name, age := "AJ", 32

fmt.Println("My name is", name, ", age is", age)

fmt.Println("My country is", country)
}

Output :

My name is AJ , age is 32
My country is India

Short variable declaration is allowed only for declaring local variables, variables declared within the function. When you declare variables outside the function, you must do so using the var keyword.

Without using var keyword, you will get this error syntax error: non-declaration statement outside function body

Outer block defined variables csn be access inside any function but inner block defined variables can not access in another function.

package main

import "fmt"

var country = "India"

func main() {
fmt.Println("My country is", country)

info()
}

func info() {
fmt.Println("My country is", country)
}

Output :

My country is India
My country is India

The info function now has access to the country variable but when you declare inside function and try to access in another function then it will give error.

package main

import "fmt"

func main() {
var country = "India"

fmt.Println("My country is", country)

info()
}

func info() {
fmt.Println("My country is", country)
}

Output :

./prog.go:14:30: undefined: country

How to Name a Variable

Naming a variable properly is an important part of software development.

These are the following rules for naming a Golang variable:

1. Names must start with a letter and may contain letters, numbers or the _ (underscore) symbol. (Example : anant32, aj_anant)
2. A variable name cannot contain spaces.

Example :
aj anant (❌)
ajAnant (✅)
3. If the name of a variable begins with a lower-case letter, it can only be accessed within the current package this is considered as unexported variables.
4. If the name of a variable begins with a capital letter, it can be accessed from packages outside the current package one this is considered as exported variables.
5. If a name consists of multiple words, each word after the first should be capitalized like this: empName, empAddress, etc. This is called as camelCase.
6. Variable names are case-sensitive (anant, Anant and ANANT are three different variables).

Basic Data types

The following are the basic types available in go

bool
string
Numeric Types
1. int8, int16, int32, int64, int
2. uint8, uint16, uint32, uint64, uint
3. float32, float64
4. complex64, complex128
5. byte
6. rune

The int, uint, and uintptr types are usually 32 bits wide on 32-bit systems and 64 bits wide on 64-bit systems. When you need an integer value you should use int unless you have a specific reason to use a sized or unsigned integer type.

bool

The Boolean data type (bool) can be one of two values, either true or false. Booleans are used in programming to make comparisons and to control the flow of the program.

The data type in Go for Boolean is bool, all lowercase. The values true and false will always be with a lowercase t and f respectively, as they are special values in Go.

package main

import "fmt"

func main() {
a := true
b := false

fmt.Println("a is ", a, ", b is", b)
}

Output :

a is true , b is false

string type

Strings are a collection of bytes in Go. Strings can be created by enclosing a set of characters inside double quotes " ".

Let's look at a simple example that creates a string and prints it.

package main

import "fmt"

func main() {
name := "AJ Anant"
fmt.Println(name)
}

The above program will print AJ Anant

Composite Data Types

Arrays

Arrays in go are values. They are fixed-length sequences of the same type. Since arrays in Go are values, that is why

1 - When you assign an array to another variable, it copies the entire array
2 - When you pass an array as an argument to a function, it makes an entire copy of the array instead of passing just the address

Declaring Arrays

We can declare aarays by specifying size and values both

newArray := [n]Type{val1, val2, val3}

Specifying size – No values. Values are set to default zero value of that type

newArray := [len]Type{}

Let’s see an example of array. Below example

Illustrates how to declare an array
Pass array as a function argument

package main

import "fmt"

func main() {
//Declare a array
sample := [3]string{"aj", "anant", "ay"}
print(sample)
}

func print(sample [3]string) {
fmt.Println(sample)
}

Output :

[aj anant ay]

Structs

In GO struct is named collection of fields. These fields can be of different types. Struct acts as a container of related data of heterogeneous data type.

For example, different attributes are used to represent and employee in an organization. Employee can have

Name of string type
Age of int type
DOB of time.Time type

.. and so on. A struct can be used to represent an employee

type employee struct {
name string
age int
dob time.Time
}

Slices

Slices are dynamically sized, reference into the elements of an array. As mentioned above arrays are of fixed size, so slices give a more flexible interface to arrays.

A slice is a reference type as it internally references an array. It is internally represented by three fields

1 - Address to the underlying array
2 - Length of the slice
3 - Capacity of the slice

Slices are typed by the type of the underlying array element, not by its length or capacity. Thus two slices will be of the same type if the type of the underlying array is same irrespective of its length and capacity.

The built in append function can be used to add more values to the underlying array.

The built in function len can you used to get the current length of the slice.

We can initialise a slice in two ways :

Using make – it helps you create a slice specifying the type of array, its length and capacity. Specifying length and capacity is optional. If length is specified and capacity is not, then capacity will be equal to length

name make([]TYPE, length, capacity)
Direct initialization.

p := []string{"aj", "anant", "ay"}

Note : Slices can be also be created from an array or from a different slice.

Example :

package main

import "fmt"

func main() {
//Declare a slice using make
s := make([]string, 2, 3)
fmt.Println(s)

//Direct intialization
p := []string{"aj", "anant", "ay"}
fmt.Println(p)

//Append function
p = append(p, "sp")
fmt.Println(p)

//Iterate over a slcie
for _, val := range p {
fmt.Println(val)
}
}

Output :

[ ]
[aj anant ay]
[aj anant ay sp]
aj
anant
ay
sp

Zero values

Variables declared without an explicit initial value are given their default value (or a zero-value).

The zero value is:

0 for numeric types,
false for the boolean type, and
"" (the empty string) for strings.

Let's take a example :

package main

import "fmt"

func main() {
var i int
var f float64
var b bool
var s string

fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

Output :

0 0 false ""

Golang Constants

A constant is a name or an identifier for a fixed value. The value of a variable can vary, but the value of a constant must remain constant.

Naming Conventions

Name of constants must follow the same rules as variable names, which means a valid constant name must starts with a letter or underscore, followed by any number of letters, numbers or underscores.

By convention, constant names are usually written in uppercase letters.

Declaring or Creating Constants

The keyword const is used for declaring constants followed by the desired name and the type of value the constant will hold.

Note : You must assign a value at the time of the constant declaration, you can't assign a value later as with variables.

package main

import "fmt"

const PRODUCT string = "Mobile"
const PRICE = 500 $

func main() {
fmt.Println(PRODUCT)
fmt.Println(PRICE)
}

You can also omit the type at the time the constant is declared.

The type of the value assigned to the constant will be used as the type of that variable.

Multilple Constants Declaration Block

Constants declaration can to be grouped together into blocks for greater readability and code quality.

package main

import "fmt"

const (
PRODUCT = "Mobile"
PRICE = 500
)

func main() {
fmt.Println(PRODUCT)
fmt.Println(PRICE)
}

Golang Operators

An operator is a symbol that tells the compiler to perform certain actions. The following lists describe the different operators used in Golang.

Arithmetic Operators
Assignment Operators
Comparison Operators
Logical Operators
Bitwise Operators

Arithmetic Operators

The arithmetic operators are used to perform common arithmetical operations, such as addition, subtraction, multiplication etc.

Operator	Description
+	Addition
-	Subtraction
*	Multiplication
/	Division
%	Modulus
++	Increment
--	Decrement

Example :

package main

import "fmt"

func main() {
var x, y = 100, 49

fmt.Printf("x + y = %d\n", x + y)
fmt.Printf("x - y = %d\n", x - y)
fmt.Printf("x * y = %d\n", x * y)
fmt.Printf("x / y = %d\n", x / y)
fmt.Printf("x mod y = %d\n", x % y)

x++
fmt.Printf("x++ = %d\n", x)

y--
fmt.Printf("y-- = %d\n", y)

}

You should see the following output when you run the above program −

Output :

x + y = 149
x - y = 51
x * y = 4900
x / y = 2
x mod y = 2
x++ = 101
y-- = 48

Assignment Operators

The assignment operators are used to assign values to variables

Assignment	Description
x = y	Assign
x += y	Add and assign
x -= y	Subtract and assign
*=	Multiply and assign
x /= y	Divide and assign quotient
x %= y	Divide and assign modulus

Example :

package main

import "fmt"

func main() {
var x, y = 15, 25
x = y
fmt.Println("= ", x)

x = 15
x += y
fmt.Println("+=", x)

x = 50
x -= y
fmt.Println("-=", x)

x = 2
x *= y
fmt.Println("*=", x)

x = 100
x /= y
fmt.Println("/=", x)

x = 40
x %= y
fmt.Println("%=", x)

}

You should see the following output when you run the above program −

Output :

= 25
+= 40
-= 25
*= 50
/= 4
%= 15

Comparison Operators

Comparison operators are used to compare two values.

Operator	Name
==	Equal
!=	Not equal
<	Less than
<=	Less than or equal to
>	Greater than
>=	Greater than or equal to

Example :

package main

import "fmt"

func main() {
var x, y = 15, 25

fmt.Println(x == y)
fmt.Println(x != y)
fmt.Println(x < y)
fmt.Println(x <= y)
fmt.Println(x > y)
fmt.Println(x >= y)
}

You should see the following output when you run the above program −

Output :

false
true
true
true
false
false

Logical Operators

Logical operators are used to determine the logic between variables or values.

Operator	Name	Description
&&	Logical And	Returns true if both statements are true
\|\|	Logical Or	Returns true if one of the statements is true
!	Logical Not	Reverse the result, returns false if the result is true

Example :

package main

import "fmt"

func main() {
var x, y, z = 10, 20, 30

fmt.Println(x < y && x > z)
fmt.Println(x < y || x > z)
fmt.Println(!(x == y && x > z))
}

You should see the following output when you run the above program −

Output :

false
true
true

Bitwise Operators

Bitwise operators are used to compare (binary) numbers.

Operator	Name	Description
&	AND	Sets each bit to 1 if both bits are 1
\|	OR	Sets each bit to 1 if one of two bits is 1
^	XOR	Sets each bit to 1 if only one of two bits is 1
<<	Zero fill left shift	Shift left by pushing zeros in from the right and let the leftmost bits fall off
>>	Signed right shift	Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off

Example :

package main

import "fmt"

func main() {
var x uint = 9 //0000 1001
var y uint = 65 //0100 0001
var z uint

z = x & y
fmt.Println("x & y =", z)

z = x | y
fmt.Println("x | y =", z)

z = x ^ y
fmt.Println("x ^ y =", z)

z = x << 1
fmt.Println("x << 1 =", z)

z = x >> 1
fmt.Println("x >> 1 =", z)
}

You should see the following output when you run the above program −

Output :

x & y = 1
x | y = 73
x ^ y = 72
x << 1 = 18
x >> 1 = 4

Golang Conditional Statements

Like most programming languages, Golang borrows several of its control flow syntax from the C-family of languages.

if Statement

The if statement is used to execute a block of code only if the specified condition evaluates to true.

Syntax

if condition {
// code to be executed if condition is true
}

Example :

package main

import "fmt"

func main() {
age := 12

if age < 13 {
fmt.Println("You are not elligible to use Sololearn")

} }

if...else Statement

The if....else statement allows you to execute one block of code if the specified condition is evaluates to true and another block of code if it is evaluates to false.

Syntax

if condition {
// code to be executed if condition is true
} else {
// code to be executed if condition is false
}

Example :

package main

import "fmt"

func main() {
age := 12

if age < 13 {
fmt.Println("You are not elligible to use Sololearn")
} else {
fmt.Println("Feel Happy to use Sololearn")
}
}

if...else if...else Statement

The if...else if...else statement allows to combine multiple if...else statements. It is called nexted if else statement.

Syntax

if condition-1 {
// code to be executed if condition is true
} else if condition-2 {
// code to be executed if condition-2 is true
} else {
// code to be executed if condition is false
}

Example :

package main

import "fmt"

func main() {
age := 12

if age < 13 {
fmt.Println("You are not elligible to use Sololearn")
} else if age > = 13 {
fmt.Println("You are still not elligible.")
}
else {
fmt.Println("Feel Happy to use Sololearn")
}
}

Best feature : if statement initialization

Go language has best feature. We can initialize value in if statement and compare the value.

Syntax

if var declaration; condition {
// code to be executed if condition is true
}

Example :

package main
import "fmt"

func main() {
    if age := 12; age < 13 {
        fmt.Println("You are not elligible to use Sololearn")
    }
}

Switch Statement

A switch statement is a shorter way to write a sequence of if - else statements. It runs the first case whose value is equal to the condition expression.

Go's switch is like the one in C, C++, Java, JavaScript, and PHP, except that Go only runs the selected case, not all the cases that follow.

Note : The break statement that is needed at the end of each case in those languages is provided automatically in Go. Means you no need to write break.

Another important difference is that Go's switch cases need not be constants, and the values involved need not be integers.

Switch evaluation order

Switch cases evaluate cases from top to bottom, stopping when a case succeeds.

Example :

package main
import "fmt"
      
func main() {
    switch time.Now().Weekday() {
        case time.Saturday:
            fmt.Println("Today is Saturday.")
        case time.Sunday:
            fmt.Println("Today is Sunday.")
        default:
            fmt.Println("Today is a weekday.")
    }
}

Switch with no condition

Switch without a condition is the same as switch true. This construct can be a clean way to write long if-then-else chains.

Example :

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Good morning!")
    case t.Hour() < 17:
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }
}

Fallthrough

A fallthrough statement transfers control to the next case.
It may be used only as the final statement in a clause.

Example :

package main
import "fmt"

func main() {
    switch 2 {
    case 1:
        fmt.Println("Hello Sololearner")
        fallthrough
    case 2:
        fmt.Println("Let's")
        fallthrough
    case 3:
        fmt.Println("GO")
    }
}

Output :

Let's
GO

switch multiple cases Statement

The switch with multiple case line statement is used to select common block of code for many similar cases.

Example :

package main
                            
import (
    "fmt"
    "time"
)

func main() {
    today := time.Now()
    var t int = today.Day()
    
    switch t {
    case 5, 10, 15:
        fmt.Println("Learn Java.")
    case 25, 26, 27:
        fmt.Println("Learn GO.")
    case 31:
        fmt.Println("Learn Java.")
    default:
        fmt.Println("Take Rest")
    }
}

For loop

A ‘for loop’ is a golang statement which allows code to be repeatedly executed.

A for loop is classified as an iteration statement i.e. it is the repetition of a process within a go program.

The for statement consists of three parts: the initialization, the condition, and the increment

The initialization part is executed only once. The body of the for statement is executed when the condition is true. If the condition returns false, the for loop is terminated. After the statements in the block are executed, the for loop switches to the third part, where the counter is incremented. The cycle continues until the condition is not true anymore.

The basic syntax is:

for initialization; condition; post { 
    // run commands till condition is true
}

A for loop is also used as an infinite loop by removing all the three expressions from the for loop.

Infinite for loop syntax:

for i:=0; ; i++

or

for { 
    // run forever
}

Example 1 :

package main
import "fmt"

func main() {
    sum := 0

    for i := 0; i < 10; i++ {
        sum += i
    }
    
    fmt.Println("Sum is ", sum)                            
}

Output :

Sum is 45

Example 2 :

package main
import "fmt"

func main() {
    for { 
        fmt.Println("Run forever !")
    }                              
}

for range Statement

The for statement supports one additional form that uses the keyword range to iterate over an expression that evaluates to an array, slice, map, string, or channel

Example :

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

    sum := 0
    
    for _, num := range nums {
        sum += num
    }
    
    fmt.Println("Sum is ", sum)                            
}

Output :

Sum is 45

range loop over string

The for loop iterate over each character of string.

Example :

package main
import "fmt"

func main() {
    for range "Anant" {
        fmt.Println("AJ")
    }
}

The above program will print "AJ" 5 times.

Output :

AJ
AJ
AJ
AJ
AJ

Notes :

Parentheses are not used around the three statements of a for loop.

The curly braces are mandatory in for loop.

The opening brace should be in the same line in which post statement exists.

If the array, string, slice, or map is nil or empty then the number of iterations of the for loop is zero.

Loop Control Statements

Loop control statements in the Go language are used to change the execution of the program.

The Go language supports 3 types of loop control statements:

Break
Goto
Continue

Break Statement

The break statement is used to terminate the loop or statement in which it presents. After that, the control will pass to the statements that present after the break statement, if available.

Example :

package main
import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println("AJ")
        
        if i == 3 { 
            break; 
        }
    }
}

The above program will print "AJ" till the i is less than 3..

Output :

AJ
AJ
AJ
AJ

Goto Statement

This statement is used to transfer control to the labeled statement in the program. The label is the valid identifier and placed just before the statement from where the control is transferred.

Example :

package main
import "fmt"

func main() {
    var x int = 0 
     
    // for loop work as a while loop 
    Lable1: for x < 8 { 
        if x == 5 { 
            // using goto statement 
            x = x + 1; 
            goto Lable1 
        } 
        fmt.Printf("value is: %d\n", x); 
        x++;      
    }
}

Output :

value is: 0
value is: 1
value is: 2
value is: 3
value is: 4
value is: 6
value is: 7

Continue Statement

This statement is used to skip over the execution part of the loop on a certain condition. After that, it transfers the control to the beginning of the loop.

Basically, it skips its following statements and continues with the next iteration of the loop.

Example :

package main
import "fmt"

func main() {
    var x int = 0 
     
    // for loop work as a while loop 
    for x < 8 { 
        if x == 5 { 
            // skip two iterations 
            x = x + 2; 
            continue; 
        } 
        
        fmt.Printf("value is: %d\n", x);
        x++;      
    }   
}

Output :

value is: 0
value is: 1
value is: 2
value is: 3
value is: 4
value is: 7

While Loop in Go

The while loop executes a block of code while a boolean expression evaluates to true. It terminates as soon as the expression evaluates to false. The boolean expression is evaluated before each iteration.

Since there is no do-while loop in Go, we can use the 'for' keyword with only a Boolean expression.

Syntax

if  booleanExpression {
    // code to be executed if condition is true
}

Because the boolean expression is evaluated before each iteration, the block of code executes ONLY if the booleanExpression evaluates to true.

booleanExpression results in either a true or false output. It is created using comparing operators (==, >, =, statement.

Example :

package main
import "fmt"

func main() {
    x := 0 
    
    for x < 10 { 
        fmt.Println(x) //prints x until x < 10 evaluates to false
        x++ 
    }
}

Functions

A function is a group of statements that exist within a program for the purpose of performing a specific task. It is used to reduce the repetition of multiple lines of code.

Function allows you to extract commonly used block of code into a single component.

Syntax

//parameters passed in are optional, depending on the functionality of the function
//the return variable name is also optional
//the return type is optional if there is no value returned

func functionNamefunc(paramName dataType) (returnVarName returnType) {
    //code to execute
    returnVarName = value
    return value //if no return variable name specified but returnType specified
    return //if return variables are assigned in the function
}

//calling a function
variable := functionName(params)

Function without Parameter

A declaration begins with the func keyword, followed by the name you want the function to have, a pair of parentheses (), and then a block containing the function's code.

The following example has a function with the name SimpleFunction without parameter and no return values.

package main
import "fmt"

func SimpleFunction() {
    fmt.Println("Hello, I am a function without parameter")
}

func main() {
    SimpleFunction()
}

When the above code is compiled and executed, it produces the following result −

Output :

Hello, I am a function without parameter

Function with Parameters

Information can be passed to functions through arguments. An argument is just like a variable.

Arguments are specified after the function name, inside the parentheses.

Note : You can add as many arguments as you want, just separate them with a comma.

The following example has a function with two arguments of int type.

package main
import "fmt"

func mult(x int, y int) {
    result := 0
    result = x * y
    fmt.Println(result)
}

func main() {
    mult(8, 6)
}

Output :

Function with Return Type

In this example, the mult() function takes input of two integer numbers and returns an integer value with a name of result.

package main
import "fmt"

func mult(x int, y int) int {
    result := 0
    result = x * y
    return result
}

func main() {
    mult := mult(8, 6)
    fmt.Println(mult)
}

Output :

Note : The types of input and return value must match with function signature. If we will modify the above program and pass some string value like "AJ" in argument then program will throw an exception "cannot use "AJ" (type string) as type int in argument to mult".

Let's see the example.

package main
import "fmt"

func mult(x int, y int) int {
    result := 0
    result = x * y
    return result
}

func main() {
    mult := mult("AJ", 6)
    fmt.Println(mult)
}

The above program will give an error as we have passed a string value "AJ" which does not match with function signature.

Output :

./prog.go:11:18: cannot use "AJ" (type untyped string) as type int in argument to mult

Named return values

In Go return parameters may be named and used as regular variables. When the function returns, they are used as return values.

Note : Named return parameters are initialized to their zero values.

The names are not mandatory but can make for good documentation. Correctly used, named return parameters can also help clarify and clean up the code.

Declaration :

To declare the named result or return parameters, just use the return type part of the function signature.

Syntax

func function_name(Parameter-list)(Return_type){
    // function body.....
}

Here, the Return_Type is optional and it contains the types of values that function returns. If you are using Return_Type in your function, then it is necessary to use a return statement in your function.

Syntax to declare a function with named return arguments:

func function_name(Parameter-list)(result_parameter1 data-_type, result_parameter2 data_type, ….){
    // function body.....
    return
}

Here, (result_parameter1 data-_type, result_parameter2 data_type, ....) is the named return argument list along with their type. You can declare n number of named return parameters.

Example :

package main
import "fmt"

func rectangle(length int, breadth int) (area int, parameter int) {
    parameter = 2 * (length + breadth)
    area = length * breadth
    return // Return statement without specify variable name
}

func main() {
    // calling the function, here 
    // function returns two values 
    parameter, area := rectangle(20, 30) 
	
    fmt.Println("Parameter: ", parameter)
    fmt.Println("Area: ", area)
}

Output :

Parameter: 600
Area: 100

Note : The above program also shows that you can return multiple values too. This is the best part of Go language.

Points to remember

A name must begin with a letter, and can have any number of additional letters and numbers.
A function name cannot start with a number.
A function name cannot contain spaces.
If the functions with names that start with an uppercase letter will be exported to other packages. If the function name starts with a lowercase letter, it won't be exported to other packages, but you can call this function within the same package.
If a name consists of multiple words, each word after the first should be capitalized like this: empName, EmpAddress, etc.
function names are case-sensitive (anant, Anant and ANANT are three different functions).

Passing pointers to functions

Go programming language allows you to pass a pointer to a function. To do so, simply declare the function parameter as a pointer type.

Example :

package main
import "fmt"

func swap(x *int, y *int)
    var temp int
    temp    = *x    /* save the value at address x */
    *x      = *y      /* put y into x */
    *y      = temp
}

func main() {
    var a int = 100
    var b int = 200

    fmt.Printf("Before swap, value of a : %d\n", a )
    fmt.Printf("Before swap, value of b : %d\n", b )

    /* calling a function to swap the values.
    * &a indicates pointer to a ie. address of variable a and 
    * &b indicates pointer to b ie. address of variable b.
    */
    swap(&a, &b);

    fmt.Printf("After swap, value of a : %d\n", a )
    fmt.Printf("After swap, value of b : %d\n", b )
}

In the above example, we pass two pointers to a function and change the value inside the function which reflects back in the calling function. The output will be after executing the program : -

Output :

Before swap, value of a : 100
Before swap, value of b : 200
After swap, value of a : 200
After swap, value of b : 100

Anonymous Functions

An anonymous function is a function that was declared without any named identifier to refer to it.

Example :

package main
import "fmt"

var (
    area = func(l int, b int) int {
        return l * b
    }
)

func main() {
    fmt.Println(area(20, 30))
}

We can also pass the arguments like :

Example :

package main
import "fmt"

func main() {
    func(l int, b int) {
        fmt.Println(l * b)
    }(20, 30)
}

Closures Functions

A closure is anonymous function that references variables declared outside its own declaration

Example :

package main
import "fmt"

func main() {
    i := 0

    foo := func() int {
        i += 10
        return i
    }

    fmt.Println(foo())  // Prints 10
    fmt.Println(foo())  // Prints 20
}

Variadic Functions

A variadic function is a function that accepts a variable number of arguments.

In Golang, it is possible to pass a varying number of arguments of the same type as referenced in the function signature.

To declare a variadic function, the type of the final parameter is preceded by an ellipsis, "...", which shows that the function may be called with any number of arguments of this type.

When to use Variadic function:

Variadic function is used when you want to pass a slice in a function.
Variadic function is used when we don’t know the quantity of parameters.
Variadic function increase the readability of your program.

Syntax of Variadic function :

func helloSolo(s ...string) {  
}

In the above function, the parameter s is variadic since it's prefixed by ellipsis and it can accept any number of arguments. This function can be called by using the syntax.

Example :

package main
import "fmt"

func main() {
    helloSolo("aj", "anant", "ajanant")
}

func helloSolo(s ...string) {
    fmt.Println(s[0])
    fmt.Println(s[2])
}

Output :

aj
ajanant

Note : In the above program if you try to access invalid index of value then it will give error panic: runtime error: index out of range [3] with length 3

It is also possible to pass zero arguments to a variadic function.

helloSolo(1)

Normal function parameter with variadic function parameter :

We can also use normal parameter with variadic function parameter.

Example :

package main
import "fmt"

func main() {
    helloSolo(12345, "aj", "anant", "ajanant")
}

func helloSolo(id int, s ...string) {
    fmt.Println(id)
    fmt.Println(s[0])
    fmt.Println(s[2])
}

Note : If you try to make first parameter as a variadic then it will give error after compilation syntax error: cannot use ... with non-final parameter .....

Example :

package main
import "fmt"

func main() {
    helloSolo("aj", "anant", "ajanant", 32)
}

func helloSolo(s ...string, id int) {
    fmt.Println(id)
    fmt.Println(s[0])
    fmt.Println(s[2])
}

In the above example s is a variadic function which is passed as first parameter but it will give an error. Hence variadic parameters can only be present at the last in the function definition.

Defer

In Go language, defer statements delay the execution of the function or method or an anonymous method until the nearby functions returns.

Defer is used to ensure that a function call is performed later in a program's execution, usually for purposes of cleanup.

Example :

package main
import "fmt"

func first() {
    fmt.Println("First")
}

func second() {
    fmt.Println("Second")
}

func main() {
    defer second()
    first()
}

This program prints First followed by Second.

A defer statement is often used with paired operations like open and close, connect and disconnect, or lock and unlock to ensure that resources are released in all cases, no matter how complex the control flow.

You can put multiple functions on the "deferred list", like this example.

Example :

package main
import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i)
    }
}

Tutorial 3 - Go Language (Golang)