Exploring the dynamics of Golang

Golang is syntactically similar to the C language and like C it is concise, clean and efficient. If you are familiar with C concepts it is easy, to begin with, the basics of golang. In this article, we will learn the basic concepts of golang.

Golang is referred to as a “simple” programming language. Anyone familiar with basic programming fundamentals can learn the basics in a few hours. Because of its simplicity, the entire language specification fits in just a few pages.

Let us now explore the dynamics.

Variable Declaration 

The var statement declares a list of variables. In golang variable name comes first following with the data type. We can either declare a variable or a list of variables. 

 var(name,age,location) =       ”Peter”, 20, ”London”
   Initialisation 
var( name = ”Peter”,
              age = 20
              Location = ”London”)

We can also declare variables by an implicit conversion using := shorthand.

Example:

a := 42 // a as int
name := “Genny” // name as string.
NOTE
A variable can be any type including functions :
actions := func() {
           Statement
                           }
actions() // variable called as a function 

Constants
The const keyword is used to make variables constant. 
Features - 
> No := is used to declare const keywords.
> An untyped const takes the type needed by its context. 
Examples
const pi = 3.14
const(
           X = 10
	  Y = 20.08
	  Str = ”Ninja” )

Print in go

We can use these 3 functions in golang for printing constant, variables and messages. They are present in the ‘fmt’ package.

print – To print in the same line
println – To print in the new line
printf – To print one or more than one values in a specified manner

Example:

blog banner 1
package main
import "fmt"
func main() {
	name := "Harry"
         age := 6 
		fmt.Printf("%s is %d years old", name, age) 
                   // Printing  variables within the string
                  // Output - Harry is 6 years old
}

FUNCTIONS:

Golang has a unique way of dealing with functions. It has a main() function by default from where the execution begins. The func keyword is used to declare functions.

Synatax:

func function-name(parameter-list)  return-type(if any){
   		statement(s)
}

Characteristics of Golang

  • The function can return one or multiple values.
  • The first function name is declared then the type of function.
  • In case there are multiple values to be returned, declare the variables and at the end of the code, we simply write ‘return’ or we can return values separated by ‘,’.
  • It is best practice to use named return parameters because they often cause more confusion than they save time or help clarify your code.

Example:

Returning a single parameter 
package main
import "fmt"
// Function definition that returns sum of two numbers 
func add(x, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13)) // Adds two numbers 
}

Returning multiple parameters
package main
import “fmt”
// function return addition and subtraction of two numbers 
func do_it(x,y int) (add,mul int){
	add := x+y
	mul := x*y 
	return add,mul // multiple values returned 
}

Func main(){
	addition, multi:= do_it(30,20)
	// addition holds the add value and multi holds mul 
}

POINTERS
A pointer is a variable that is used to store the memory address of another variable. Go has pointers like C but no pointer arithmetic. By default, arguments are passed by value in functions.

Declaring a pointer -
var pointer-name *data-type
Example
var s *string // Pointer of type string that stores the memory address of string variables

Initialisation -
// Normal variable declaration
var a = 45
// Initialisation of variable s with a memory address of variable a
var s *int = &a

MAPS
Maps in golang are similar to “dictionaries” and “hashmaps” in other languages. It is popular because it provides fast lookups and values that can retrieve, update or delete with the help of keys.

Simple: In this method, the map can be created directly by the following.
Syntax:

// An Empty map
map[Key_Type]Value_Type{}

// Map with key-value pair
map[Key_Type]Value_Type{key1: value1, ..., keyN: valueN}

Example - var mymap map[int]string

By default a map is nil.

Initialising map using map literals: Using this method we initialise a map with : separated key-value pairs. 

Example:

package main 
import "fmt"
func main() { 
	// creating and initializing a map
	var map_1 map[int]int
	// nil means empty map
	if map_1 == nil { 
		fmt.Println("True") 
	} else { 
		fmt.Println("False") 
	} 
	
	map_2 := map[int]string { 
			90: "Dog", 
			91: "Cat", 
			92: "Cow", 
			93: "Bird", 
			94: "Rabbit", 
	} 
	fmt.Println("Map-2: ", map_2) 
} 
 

Using make function: The inbuilt function make() can also be used to create a map. Pass the key type, value type and initial capacity(optional) of the map.

Syntax:

make(map[Key_Type]Value_Type, initial_Capacity)
make(map[Key_Type]Value_Type)
Example
package main 
import "fmt"
func main() { 
	// Creating and initializing the empty map  Using var keyword 
	var map_1 map[int]int
	if map_1 == nil { 
	
		fmt.Println("True") 
	} else { 
	
		fmt.Println("False") 
	} 

	// Creating and initializing a map and Using shorthand declaration 
	map_2 := map[int]string{ 
			90: "Dog", 
			91: "Cat", 
			92: "Cow", 
			93: "Bird", 
			94: "Rabbit", 
	} 
	
	fmt.Println("Map-2: ", map_2) 
} 

SLICES
Slices take over arrays to give a more general, powerful, and convenient interface to sequences of data. For this reason, most programming in Go is done with slices rather than simple arrays. If you assign one slice to another, they will point to the same slice because slices hold references to an underlying array. If a slice is passed to a function the changes made to slice inside the function will reflect in the original slice too.

Slices can be resized.

Example:

package main
import "fmt"
 
func main() {
    m_slice := []int{2, 3, 5, 7, 15, 13} // Declaring a slice 
    fmt.Println(m_slice)  // [2 3 5 7 15 13]
}
 
 
Slicing the slice -
You will understand slicing with the help of this example.
package main
import "fmt"
func main() {
	m_slice := []int{2, 3, 5, 7, 15, 13}
	fmt.Println(m_slice) // [2 3 5 7 15 13]
         // Takes the element indexed from 1 to 3 ie, leaving 4th index
	fmt.Println(m_slice[1:4]) // [3 5 7]
	// missing low index implies 0
	fmt.Println(m_slice[:3]) // [2 3 5]
	// missing high index implies len(s)
	fmt.Println(m_slice[4:]) // [15 13]
}

Structure

It is a user defined data type that contains multiple types (data members and member functions) into a single type.

Example:

package main 
import "fmt"
// Defining a struct type 
type Address struct { 
	Name string 
	city string 
	Pincode int
} 
 
func main() {  
	// All the struct fields are initialized  with their zero value 
	var a Address  // The variable a is struct type here
	fmt.Println(a) 
	// Declaring and initializing a struct using a struct literal 
	a1 := Address{"Akshay", "Dehradun", 3623572} 
	fmt.Println("Address1: ", a1) 
	// Fields are named while initializing a struct
	a2 := Address{Name: "Anikaa", city: "Ballia", Pincode: 277001} 
	fmt.Println("Address2: ", a2) 
	// Uninitialized fields have zero-value 
	a3 := Address{Name: "Delhi"} 
	fmt.Println("Address3: ", a3) 
} 

This was all about the basics of go. The loops, conditional statements and switch work similar to C language. The only difference is a switch in Golang as one case can handle multiple values. Concurrent programming is a large topic but has most of its own benefits. Concurrency in Golang has the ability for functions to run independently of each other.

To explore more articles, click here.

Mansi Agarwal