basics

Contents

• basic-syntax
• variables
• packages
• functions
• go-conditionals
• type-casting
• type-inference
• for-loop
• structs
• arrays
• slices
• make
• range
• maps
• errors-panic-recover
• data-types

Roadmap info from roadmap website

Learn the Basics

Learn the common concepts of Go like variables, loops, conditional statements, functions, data types, and so on. A good starting point for go basics is its Go’s official docs.

Visit the following resources to learn more:

• officialOfficial Go Tutorial
• articleW3 Schools Go Tutorial
• feedExplore top posts about Golang

What is Go

• Go is a cross-platform, open source programming language
• Go can be used to create high-performance applications
• Go is a fast, statically typed, compiled language known for its simplicity and efficiency
• Go was developed at Google by Robert Griesemer, Rob Pike, and Ken Thompson in 2007
• Go’s syntax is similar to C++

What is Go Used For

• Web development (server-side)
• Developing network-based programs
• Developing cross-platform enterprise applications
• Cloud-native development

Why Use Go

• Go is fun and easy to learn
• Go has fast run time and compilation time
• Go supports concurrency
• Go has memory management
• Go works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc.)

Go Compared to Python and C++

Formatting Verbs for Printf()

Go offers several formatting verbs that can be used with the Printf() function. General Formatting Verbs. The following verbs can be used with the integer data type:

String Formatting Verbs

The following verbs can be used with the string data type:

Boolean Formatting Verbs

The following verb can be used with the boolean data type:

Float Formatting Verbs

The following verbs can be used with the float data type:

Memory Efficiency

When using slices, Go loads all the underlying elements into the memory. If the array is large and you need only a few elements, it is better to copy those elements using the copy() function. The copy() function creates a new underlying array with only the required elements for the slice. This will reduce the memory used for the program.

package main

import (
 "fmt"
)

func main() {
 // Suppose we have a large array
 largeArray := [1000000]int{}
 for i := 0; i < len(largeArray); i++ {
  largeArray[i] = i
 }

 // We only need a small slice of this large array
 smallSlice := largeArray[100:200]

 // This smallSlice still references the entire largeArray in memory
 fmt.Println("Length of smallSlice:", len(smallSlice))
 fmt.Println("Capacity of smallSlice:", cap(smallSlice)) // Large capacity indicates underlying array is still large

 // To optimize memory, create a new slice with a new underlying array using copy
 optimizedSlice := make([]int, len(smallSlice))
 copy(optimizedSlice, smallSlice)

 // Now, optimizedSlice is independent of largeArray and uses less memory
 fmt.Println("Length of optimizedSlice:", len(optimizedSlice))
 fmt.Println("Capacity of optimizedSlice:", cap(optimizedSlice)) // Capacity now matches the length, indicating efficient memory usage
}

Defer

Go’s defer statement schedules a function call (the deferred function) to be run immediately before the function executing the defer returns. It’s an unusual but effective way to deal with situations such as resources that must be released regardless of which path a function takes to return. The canonical examples are unlocking a mutex or closing a file.

Golang Types and Their Explanations

Interfaces

• An interface type is defined as a set of method signatures.
• A value of interface type can hold any value that implements those methods.