GO: A Basic Introduction

Go, also known as Golang, is an open-source programming language developed by Google. It is designed for simplicity, efficiency, and reliability, making it a popular choice for modern software development. This tutorial will guide you through the basics of Go, including setting up the environment, understanding functions and data types, exploring concurrency with goroutines, and utilizing the standard library.

Setting Up the Environment

Install Go:

1. Visit the Go official website and download the installer for your operating system.
2. Follow the installation instructions.

Set Up Go Workspace:

1. Create a directory for your Go projects, typically named go in your home directory.
2. Set the GOPATH environment variable to this directory.

Verify Installation:

1. Open your terminal and run:
   go version
2. You should see the installed Go version.

Writing Your First Go Program

Create a new file named hello.go in your workspace directory and add the following code:

//Every program made in go is part of a package
package main

import "fmt"

//main function, the first one to run when your program opens
func main() {
    fmt.Println("Hello, World!")
}

To run the program, navigate to the directory containing hello.go in your terminal and execute:

go run hello.go

Functions and Data Types

Functions:
Functions in Go are defined using the func keyword. Here’s a basic example:

package main

import "fmt"

//function to add two ints, then return an int
func add(a int, b int) int {
    return a + b
}

func main() {
    sum := add(3, 4)
    fmt.Println("Sum:", sum)
}

Data Types:
Go has several built-in data types, including integers, floats, strings, and booleans. They’re structured as var name type = value

package main

import "fmt"

func main() {
    var integer int = 10
    var floatingPoint float64 = 20.5 //float32 is also an option
    var str string = "Go is fun!"
    var boolean bool = true

    fmt.Println("Integer:", integer)
    fmt.Println("Float:", floatingPoint)
    fmt.Println("String:", str)
    fmt.Println("Boolean:", boolean)
}

var here stands for variable, which means the value can be changed. You can alternatively use constif you wish to create an immutable variable.

Arrays:

Arrays are used in go to store multiple values of the same type in one variable.

package main
import ("fmt")

func main() {
    var array1 = [3]int{1,2,3} //array, with declared size of 3
    array2 := [5]int{4,5,6,7,8} //array, with declared size of 5, but without using "var"
    var array3 = [...]string{"words","strings","palavras"} //array of inferred length


    fmt.Println(array1) // [1 2 3]
    fmt.Println(array2) // [4 5 6 7 8]
    fmt.Println(array3) // [words strings palavras]
}

Slices:

Similar type to arrays, but can grow and shrink as necessary.

package main
import ("fmt")

func main() {
    var slice = []int{1,2,3} 
    fmt.Println(slice) // [1 2 3]

    slice = append(slice, 4, 5) //adds two values at the end of the variable slice
    fmt.Println(slice) // [1 2 3 4 5]

    var slice2 = []int{6,7} //creates another slice
    slice= append(slice,slice2...) //adds values from slice2 to slice
    fmt.Println(slice) // [1 2 3 4 5 6 7]

    var subslice = slice[1:4]//takes a slice out of the previous slice, starting on index 1 ending on 4
    fmt.Println(subslice) // [2 3 4]
}

Concurrency and Goroutines

Go is known for its powerful concurrency model. Goroutines are lightweight threads managed by the Go runtime.

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        time.Sleep(1 * time.Second)
        fmt.Println(i)
    }
}

func printLetters() {
    for i := 'A'; i <= 'E'; i++ {
        time.Sleep(1 * time.Second)
        fmt.Printf("%c\n", i)
    }
}

func main() {
    go printNumbers()
    go printLetters()

    time.Sleep(6 * time.Second)
    fmt.Println("Main function finished")
}

The Standard Library

Go’s standard library provides a rich set of packages for various tasks, such as I/O, HTTP, and more.

Example: HTTP Server

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Server is running at http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

Conclusion

This tutorial covered the basics of Go, including setting up the environment, understanding functions and data types, exploring concurrency with goroutines, and using the standard library. If you wish to learn more, within the official website there is a “learn” section with many useful sources such as books and examples. Happy coding!