Go Basic Zero To Hero
Tags: go, programming, learning, tutorial
Published: 2019-12-17 16:56:51

---
title: Go Basic Zero To Hero
published: true
description: Go is an open-source programming language that makes it easy to build simple, reliable, and efficient software.
tags: #go #programming #learning #tutorial
---



## Setup Environment

- 1. Download [Go SDK](https://golang.org/dl/)
- 2. Now [Code Editor](https://code.visualstudio.com/Download)
- 3. Hit below command to check SDK installed or not

Or,

- 🔰 We also use an [online editor](https://tour.golang.org/welcome/1)


```bash
go version
```


👏 Great! Our Environment Ready. Let's begin.


### 🔰 Create a Frist Application

Create a workspace directory and then create `workspace/hello.go` file, with including below code blocks,


```go
package main

import "fmt"

func main() {
  fmt.Println("Hello! From Go");
}
```

`Note: Here, the main() method is the starting point of the application, So remember it main package is only imported where we want to start your application`

Now Run your first go code. using below commands, open terminal then


```bash
go hello.go
```

✅ Successfully we can run your go application. Let's go deeper.


###🔰 Let's learn Go Basic types

- Strings
- Numbers
- Arrays [Arrays have a fixed size.]
- Slices [Slices have a dynamic size, unlike arrays.]
- [Type conversions](https://tour.golang.org/basics/13)
- [Pointers](https://tour.golang.org/moretypes/1)


Play with Go Different Types:-


```go
package main

import "fmt"

func main() {
  // Variable declaration
  var msg1 string
  msg1 = "Hello"

  // Short form of above
  msg2 := "Hello"

  // multiline text
  message_str := `Multiline
  text`

  // Define Constants
  const PI = 1.618

  // Number
  int_num := 34            // int
  float_num := 34.0        // float64
  byte_num := byte('a')    // byte or uint8

  // Other types
  var u unsigned_int = 3   // uint (unsigned)
  var p float32 = 34.0     // 32-bit float

  // array = arrays are fixed in size
  var numbers [5]int
  int_numbers := [...]int{0, 0, 0, 0, 0}

  // slice are dynamic array = size are dynamic
  slice1 := []int{2, 3, 4}
  slice2 := []string{'ABC', 'BCD', 'DEF'}
  slice2 := []byte("Hello")

  // type conversions
  int_type := 2
  float_type := float64(int_type)
  unsigned_int_type := uint(int_type)
}
```


Let's do a little bit deeper, explore pointers and functions


```go
package main

import "fmt"

func main() {
  b := *getPointerRefFunc(2)
  fmt.Println("Value is", b)
  
  v1, v2 := sampleFunc(4,3)
  fmt.Println("Values are: ", v1, v2)
}

func getPointerRefFunc(arg int) (return_type *int) {
  a := arg + 3
  return &a
}

func sampleFunc(arg1, arg2 int) (int, string) { 
  return arg1 , "Hello";
}
```

😰Uhoo! We are doing much. Okay, let's look up something Interesting.
Guys. The pointer is a most important concept in GO, So it's enough fo that time being.


###🔰 Flow control or Conditional Statment

```go
// if & else statements
if fruit == "apple" || fruit == "orange" {
  //.. do something
} else if fruit == "mango" && fruit == "cherry" {
  //... do something
} else {
  //...happens when none of them are matches
}


// switch statements

switch day {
  case "apple":
    //.. do something

  case "mango":
    //.. do something

  default:
    //...happens when none of them are matches
}

```


###🔰 Loop & Looping In Go


```go
  // just looping
  for count := 0; count <= 10; count++ {
     fmt.Println("My counter is at", count)
  }

  // looping over array
  items := []string{"abc","def","ghi"}
  for i, val := range items {
    fmt.Printf("At position %d, the character %s is present\n", i, val)
  }

```


###🔰 Let's talking about Functions 

- Lambdas
- Multiple return types
- Named return values

```go

func main() {

   // lambdas
   myfunc := func() bool {
     return "Hello! From Lambdas"
   }

   a, b := getMessage()
   a, b := getValue(2, 3)
}

//Multiple return types
func getMessage() (a string, b string) {
  return "Hello", "World"
}

// Named return values
func getValue(p int) (a, b int) {
  a = p + 2
  b = p - a
  return a, b
}

```

###🔰 Packages In Go

The packaging concept is quite smart in go language and it's pretty similar to python. It's just an awesome and important concept in Go.

```go

// import single 
import "fmt"
import "math/rand"

// multiple imports in a single block
import (
  "fmt"        // gives fmt.Println
  "math/rand"  // gives rand.Intn
)

// we can create custom aliases like below
import custom_name "math/rand"

func main() {
  fmt.Println("My favorite number is", custom_name.Intn(10))
}

// Exporting so that we can import that from another package, 
func Hello () {
  fmt.Println("I'm From Hello Function!")
}
```

Note: The package name should be the small case and with an underscore no space. Exported names begin with capital letters. Every package file has to start with the package.



###🔰 Concurrency In Go

Goroutines have faster startup time than threads. Goroutines makes use of channels, a built-in way used to safely communicate between themselves.

```go

package main
import "fmt"

func added(ch chan string, name string) {
  msg := "Hello: " + name + " | "
  ch <- msg
}

func main() {
  ch := make(chan string)   // "channel"

  // start concurrent routines
  go added(ch, "Moe")
  go added(ch, "Larry")
  go added(ch, "Curly", )

  // order isn't guaranteed)
  fmt.Println( <-ch, <-ch, <-ch )
  close(ch)   // Closing channels
}

```

```go
package main
import "fmt"

func main() {
   ch := make(chan string, 2)
   ch <- "ABC"
   ch <- "BCD"
   fmt.Println( <-ch )
   fmt.Println( <-ch )
   close(ch)      // Closing channels
}
```

###🔰 Structs In Go


```go
package main

import "fmt"

type Person struct {
	name string
	address string
}

func main() {

  person := Person{"Mr. ABC", "Dhaka, Bangladesh"}
  
  fmt.Println(person)
  person.name = "Sadhan"
  
  fmt.Println(person.name)
   fmt.Println(person)
}
```


```go
package main
import "fmt"

type Employee struct {
	firstName, lastName string
	salary int
	healthy bool
}
func main() {
  employee := Employee {
	 firstName: "ABC",
	 lastName: "Sarker",
	 salary: 1200,
	 healthy: true,
 }
 fmt.Println(employee)
 fmt.Println(employee.firstName)
}
```

###🔰 Interface in Go

```go
package main

import "fmt"

type I interface {
    Greeting()
}

type Human struct{}

func (Human) Greeting() {
    fmt.Println("Hello, from Golang") 
}

func f1(i I) { 
    i.Greeting()
}

func main() {
    h1 := Human{}
    f1(h1)
	
	var h2 Human
    f1(h2)
}
```

### 🔰 Why Go?

- No classes, divided into packages. Go has only structs & interface
- No Exceptions, No generics, No annotations, No constructors
- No support for inheritance.
- We can do Functional programming.
- No superclass to look out for.



👌 Congratulations!. & Thank You!
Feel free to comments, If you have any issues & queries.



🔰 Learn more from here,

- https://github.com/golang/go/wiki
- https://tour.golang.org/list
- https://github.com/golang/go/wiki/Switch
- https://gobyexample.com/range
- https://tour.golang.org/concurrency/4
- https://medium.com/@geisonfgfg/functional-go-bc116f4c96a4
- https://dev.to/deepu105/7-easy-functional-programming-techniques-in-go-3idp