Beginners guide to Go
Tags: go, programming, beginners
Published: 2022-10-10 13:22:56

Go, is a statically typed, object-oriented, compiled language meant to replace C, and it's used to build high-performance server-side applications. Go was designed by Ken Thompson, Rob Pike, and Robert Greismer at Google, in 2007 and it first appeared on November 10, 2009; 12 years ago, version 1.0 was released in March 2012. Go is compiled to an executable binary and it runs quite fast, faster than your average JavaScript. Go is inspired by languages like C, Pascal, Modula, and Modula-2

It was created to address criticism of other languages, but keep their useful characteristics, which is why it is loved so much, Go combines;

* Static Typing and Runtime Efficiency.
* Readability and usability
* Multiprocessing and Networking.

Go is statically typed but doesn't feel like you're using a statically typed language, this is due to type inference. This gives a Go code a scripting feel and keeps the code concise and clean. Go is the language used to build several tools like 
- Docker
- Cockroach DB

Go is designed to be simple and efficient and we will briefly cover the following;

- Hello world program.
- Basic overview of the program and features of a Go program.
- Types
- Strings
- Maths
- Booleans
- Conditionals
- arrays and slices
- Loops
- Functions
- Maps
- Structs

To read more articles like this visit [Netcreed](https://blog.theNetcreed.com)

## Hello World

```go
package main

import "fmt"

func main() {
  fmt.Println("hello world")
}
```

Let's break down the code, The `package` main tells the Go compiler that the package should compile as an executable program instead of a shared library. The `main` function in the main package is the entry point of the program, it is where our code will begin execution. We also import the `fmt` library which handles formatted input/output. We use the `Println` Method to print a message to the standard output or console.

## Program Overview

Every Go package will have the following structure, 
* It will contain a package declaration.
* Import one or more libraries you need to use.
* main function that will serve as an entry point to our application.
* one or more declared variables.
* one or more functions

## Types In Go

Go is a statically typed language and requires that you specify variable types when they are declared. Go is also capable of type inference, the major types in Go are listed below;

* Strings are used to represent character sequence and are enclosed in double quotes.
* Integers are used for numbers, there are different types of integers in Go, `int`, `int8`, and `int32` amongst others. There is also `uint` which is used to represent unsigned integers.
* Floats are used for floating point numbers, e.g 2.3 `float32` and `float64`.
* Booleans which are represented by `bool`, store true or false in a single byte.
* Struct is used to define more complex data structures by composing one or more primitive types.
* Arrays which are used to store collection of data of similar types.
* Slices which are similar to arrays but they don't require a fixed length.

Let's explore how to explicitly set types and how to allow Go infer types.

```go
package main

import "fmt"

func main() {
  // explicit typing
  var message string = "hello world"
 // type inference
  age := 100
  fmt.Println(message);
}
```

## Strings

Strings are sequences of Unicode characters enclosed in double quotes. A string is a sequence of immutable bytes, which means once a string is created you cannot change that string.

```go
package main

import "fmt"

func main() {
  message := "hello world"
  fmt.Println(message);
}
```
To manipulate strings we can import the `strings` library which is built into Go.

```go
package main

import (
 "fmt"
 "strings"
)

func main() {
  message := "hello world"
  // convert text to lowercase
  fmt.Println(strings.ToLower(message))
 // convert text to uppercase
  fmt.Println(strings.ToUpper(message))
  // separate a string into an array
  fmt.Println(strings.Split(message, " "))
}
```

## Math & Numbers

The math library holds utility functions that provide some basic math functionality, allowing us to perform all types of arithmetic calculations. 

```go
package main

import (
"fmt"
"math"
)

func main() {
  num := 2.40 
  myNum := 2 * 3

  fmt.Println(math.ceil(num))
  fmt.Println(math.floor(num))
  fmt.Println(math.Sqrt(myNum))
  fmt.Println(math.Pi * math.ciel(num))
}
```
## Booleans
Booleans are  used to represent truthful or false values and are used in conjunction with conditional statements to enable our code to handle different branching situations.

```go
package main

import "fmt"

func main() {
  myAge := 39
  mumAge := 58
  isBool := myAge == mumAg
  isAdult := myAge > 18
  fmt.Println(isBool)
  fmt.Println(isAdult)
}
```

## Conditionals

These are statements that allow branching and decision-making in our code based on the results of an expression which is a boolean. We have the normal `if` Statement and the `switch` statements to handle conditionals.

```go
package main

import "fmt"

func main() {
  num := 16
  if num > 18 {
    fmt.Println("you're an adult")
  } else {
    fmt.Println("you're a child")
  }
}
```


Notice the lack of parenthesis enclosing the condition, this is a feature of Go's syntax. This makes our code cleaner and more readable let's check out the switch statement. Switch statements are used to compose multiple if statements in a readable format.

### Switch
```go
package main

import "fmt"

func main() {
  option := "Y"
  Switch option {
    case "Y":
       fmt.Println("continue")
       break;
    case "N":
       fmt.Println("stop")
       break;
    default:
       fmt.Println("invalid option")
       break;
  }
}
```

## Arrays & Slices

Arrays are fixed-length sequences used to store the collection of the same data type. Arrays in go are similar to arrays in other languages, however, they have a slightly different syntax. 

```go
package main

import "fmt"

func main() {
  nums := [3]int{1, 5, 7, 0};
  fmt.Println(len(nums))
  names := [2]string{"sam", "john"}
  fmt.Println(names[0])
  names[1] = "Bob"; 
  fmt.Println(names)
}
```
Slices are similar to arrays, the key difference between a slice and an array is the lack of a fixed length in the slice, when we declare a slice there's no need to explicitly define the length of the slice, allowing us to get a scripting-like feel. This behavior is found in languages like JavaScript and python.

```go
package main

import "fmt"

func main() {
  nums := []int{1, 5, 7, 0};
  fmt.Println(len(nums))
  names := []string{"Fred", "bob"}
  fmt.Println(names)
}
```
Arrays and slices begin at a zero index as is standard with most languages. Most of the time you'd be using slices due to the flexibility they provide. We can use the `append` function which is provided globally to add an item or another array/slice to the one we already do. Another method, `delete` which is also provided globally can be used to remove an item from a list.

```go
package main

import "fmt"

func main() {
  nums := []int{1, 5, 7, 0};
  
// add an item
  newNums = append(nums, 9) 
  fmt.Println(len(newNums))

// add a list item
  names := []string{"Fred", "bob"}
  nNames = append(names, {"sam", "pam"})
  fmt.Println(names)
  delete(names, 0)
  fmt.Println(len(nNames))
}
```

## Loops

Loops are fundamental to most programming languages and they are implemented in quite an interesting manner in Go. There is only a for loop in Go, so don't expect to see `while` or `do` as you'd find in most programming language.

```go
package main

import "fmt"

func main() {
  for i := 0; i < 5; i ++ {
    fmt.Println(i)
  }
}
```

Notice again the lack of parenthesis, we can shorten the loop expression by taking the variable declaration to a line above the for loop, then increment our counter inside the loop.

```go
package main

import "fmt"

func main() {
  i := 0
  for i; i < 5; {
    fmt.Println(i)
    i++;
  }
}
```
We can also loop over arrays and slices, there are two ways of doing this. We can use the standard method by utilizing the built `range` method or we use the `len` method, let's look at the latter first.

```go
package main

import "fmt"

func main() {

  nums := [3]int{1, 5, 7, 0};
  for i := 0; i < len(nums); {
    fmt.Println(nums[i])
    i++;
  }
}
```
The `range` Method is syntactically better than the `len` as we will see below;
 ```go
package main

import "fmt"

func main() {

  nums := [3]int{1, 5, 7, 0};
  for index, value := range nums {
    fmt.Println(index, value)
  }
}
```

## Functions

Functions are at the heart of all programming languages, functions in go are declared using the `func` keyword. Each parameter passed into the function should be of a specified type and if the function returns a value, ensure to specify it too, let's create a function.

```go
package main

import "fmt"

func getArea(r float64) float64 {
  return r * 2;
}

func main() {

  nums := []int{1, 5, 7, 0};
  area := getArea(nums[1])
   
  fmt.Println(area)
}
```

Go supports functional programming, there are higher-order functions, functions can be assigned to variables, passed as arguments to other functions, and we can also return functions from functions. Go also allows us to return multiple values from a function

```go
package main

import "fmt"

func getArea(r float64) float64 {
  return r * 2;
}

func getNums(n uint, p uint) (uint, uint, uint) {
  return n * p,  n + p,  p * 2
}

func isOdd(num float64) float64 {
  isOdd := num ℅ 2 == 0
  if isOdd {
    return true
  }
  return false
}

func main() {

  num := 3
  num := isOdd(getArea(num))
   
  fmt.Println(num)
  fmt.Println(getNums(4, 3))
}
```

## Maps

Maps are complex data structures used to store key-value pairs, a map allows you to associate a key that can be of any basic data type with a value that can be of another type. It's more like a dictionary in python. 

```go
package main

import "fmt"

func main() {
  var ages map[string]int

  ages["sam"] = 40
  ages["phill"] = 30
}
```
You can also loop through a map because it is a collection, we can use the range function with a for loop to achieve this.

```go
package main

import "fmt"

func main() {
  var ages map[string]int

  ages["sam"] = 40
  ages["phill"] = 30

  for key, value := range ages {
    fmt.Println(key, value)
  }
}
```

## Structs
A struct is a type that is used to describe more complex form of data that closely resembles real-world data. 

```go
package main

import "fmt"

type Person struct {
  name string
  age int
  hobbies [2]string
}

func main() {
  lily := Person{"Lily", 3,  {"singing", "dancing"}}
  fmt.Println(lily)
}
```


To read more articles like this visit [Netcreed](https://blog.theNetcreed.com)