Before writing the code, we need to import the database/sql package. This package must be used in conjunction with a SQL driver. In this tutorial, I will be connecting to SQL Server so github.com/microsoft/go-mssqldb will be imported. More SQL drivers can be found here and each can be installed with the go get command. I've also imported fmt for printing purposes:

import (
    "fmt",
    "database/sql",
    _ "github.com/microsoft/go-mssqldb"
)

Notice that I put the blank identifier, _, before the driver package name. This indicates that the imported package will not be used in the code itself. We import the driver so that it can be registered with the imported sql package. Note that when assigning an alias to an imported package in Go, the alias name comes before the imported package name.

Before connecting to any database, you need to create a connection string which usually requires the following credentials: the database server, name, username, and password.

func main() {

    connString := fmt.Sprintf("server=%s;user id=%s;
        password=%s;database=%s;Integrated Security=false;                                                                                            TrustedServerCertificate=True", server, user, password, db_name)

}

The next thing to do is to open the connection with the sql package we imported:

connection, error := sql.Open("mssql", connString)
if err != nil {
    fmt.Println("Could not connect to the database)
    panic(err)
}

The connection variable declared above is of type *sql.db as it points to a SQL connection.

After opening the connection, we can verify it and then close it. The defer keyword ensures that the database connection is closed regardless of how the function terminates (with or without error):

error := db.Ping()
if err != nil {
    fmt.Println("Could not verify connection to the database)
    panic(err)
}

defer connection.close()

We begin with the same code in main.go as in my previous blog post:

package main

import (
    "html/template"
    "os"
    "strings"
)

type Person struct {
    Name       string
    Age        int
    Employed   bool
    Occupation string
    Interests  []string
}

func sub(i int) int {
    return i - 1
}

func main() {
    people := []Person{
        {
            Name:       "Bob",
            Age:        42,
            Employed:   true,
            Occupation: "Doctor",
            Interests:  []string{"Reading", "Swimming"},
        },
        {
            Name:       "Jessica",
            Age:        22,
            Employed:   false,
            Occupation: "",
            Interests:  []string{"Piano", "Baking"},
        },
        {
            Name:       "Ben",
            Age:        23,
            Employed:   false,
            Occupation: "",
            Interests:  []string{"Music", "Running"},
        },
    }
    tmplFile := "demo_html.tmpl"
    fMap := template.FuncMap{
        "sub":  sub,
        "join": strings.Join,
    }
    tmpl, err := template.New(tmplFile).Funcs(fMap).ParseFiles(tmplFile)
    if err != nil {
        panic(err)
    }
    file, err := os.Create("layout.html")
    if err != nil {
        panic(err)
    }
    err = tmpl.Execute(file, people)
    if err != nil {
        panic(err)
    }
}

Note that I created a new template file demo_html.tmpl. Also, instead of outputting the template to the terminal, I chose to write it to a file called layout.html.

In demo_html.tmpl, we write the following code:

{{ range . }}

<h1> Name: {{.Name}} </h1>
<ul>
<li> Age: {{.Age}} </li>
<li> Occupation: {{ if .Employed }}{{ .Occupation }}{{ else }}Unemployed{{end}} </li>
<li> Interests: {{ join .Interests " & " }} </li>
</ul>

{{ end }}

After saving this file and running go run main.go, opening layout.html reveals the following:

<h1> Name: Bob </h1>
<ul>
<li> Age: 42 </li>
<li> Occupation: Doctor </li>
<li> Interests: Reading &amp; Swimming </li>
</ul>


<h1> Name: Jessica </h1>
<ul>
<li> Age: 22 </li>
<li> Occupation: Unemployed </li>
<li> Interests: Piano &amp; Baking </li>
</ul>


<h1> Name: Ben </h1>
<ul>
<li> Age: 23 </li>
<li> Occupation: Unemployed </li>
<li> Interests: Music &amp; Running </li>
</ul>

You can see in layout.html that the & characters are escaped by html/template package. Running layout.html will give the following on a web browser:

package main

import (
    "os"
    "text/template"
    "strings"
)

type Person struct {
    Name       string
    Age        int
    Employed   bool
    Occupation string
    Interests  []string
}

func main() {
    people := []Person{
        {
            Name:       "Bob",
            Age:        42,
            Employed:   true,
            Occupation: "Doctor",
            Interests:  []string{"Reading", "Swimming"},
        },
        {
            Name:       "Jessica",
            Age:        22,
            Employed:   true,
            Occupation: "Teacher",
            Interests:  []string{"Piano", "Baking"},
        },
        {
            Name:       "Ben",
            Age:        23,
            Employed:   true,
            Occupation: "Photographer",
            Interests:  []string{"Music", "Running"},
        },
    }
    tmplFile := "demo.tmpl"
    tmpl, err := template.New(tmplFile).ParseFiles(tmplFile)
    if err != nil {
        panic(err)
    }
    err = tmpl.Execute(os.Stdout, people)
    if err != nil {
        panic(err)
    }
}

Note that I added an attribute called Interests (slice of strings) to the Person struct. For an explanation of this code, please read my previous post.

In demo.tmpl, we can use the slice function and the range action to loop over a section of the slice people.

{{ range slice . 1 2 }}
-----------------
Name: {{.Name}}
Age: {{.Age}}
Occupation: {{ if .Employed }}{{ .Occupation }}{{ else }}Unemployed{{end}}
{{ end }}

{{ slice . 1 2 }} is equivalent to people[1:2], and so calling range on this slice iterates through the second element of people and prints out the following string:

-----------------
Name: Jessica
Age: 22
Occupation: Teacher

For the purpose of printing out one element, it may be easier to use the index function. For example, the line {{ index . 0 }} is equivalent to people[0] and would print out {Bob 42 true Doctor [Reading Swimming]}.

Creating a plaintext report solely through the use of actions and built-in functions in templates can be quite restrictive as arithmetic operations cannot be used in templates directly.

Introducing the option to feed in custom functions to your templates. These functions can be defined however you want, and they give you the possibility to perform operations that are otherwise not allowed in templates.

Let’s say you want to index the last element of the slice you pass in. If you know the length of the slice, then you can simply hardcode the index number. But to make this more reusable, we need to pass in a custom function that allows us to decrement the length by one so that we can index the last element of any slice.

We start by defining a new function called sub in main.go:

func sub(i int) int {
    return i - 1
}

In the main function, we create a map fMap that maps a function name (string) to the function definition. We then pass this into the template through the template.New().Funcs function:

fMap := template.FuncMap{
    "sub": sub,
}
tmpl, err := template.New(tmplFile).Funcs(fMap).ParseFiles(tmplFile)
if err != nil {
    panic(err)
}
err = tmpl.Execute(os.Stdout, people)
if err != nil {
    panic(err)
}

In the template file, we write {{ len . | sub | index . }} , indicating that the length of the slice is passed to the sub function, and the output of the sub function is passed to the index function. Therefore, when passing in the slice people, the output of this line is people[2] or { Ben 23 true Photographer [Music Running]}.

In a similar way, we can pass built-in Go functions into a template. For example, let’s say we want to convert the slice of Interests into a string where each interest is separated by & . To do this, we first pass in the function strings.Join to the template by adding a key-value pair to fMap like so:

fMap := template.FuncMap{
    "sub":  sub,
    "join": strings.Join,
}

Going back to demo.tmpl, this time looping through the whole slice, we can use this function to return the desired string:

{{ range . }}
-----------------
Name: {{.Name}}
Age: {{.Age}}
Occupation: {{ if .Employed }}{{ .Occupation }}{{ else }}Unemployed{{end}}
Interests: {{ join .Interests " & " }}
{{ end }}

Saving demo.tmpl and running go run main.go gives the following result:

-----------------
Name: Bob
Age: 42
Occupation: Doctor
Interests: Reading & Swimming

-----------------
Name: Jessica
Age: 22
Occupation: Teacher
Interests: Piano & Baking

-----------------
Name: Ben
Age: 23
Occupation: Photographer
Interests: Music & Running

First off, we introduce a feature of templates called actions. An action, defined as {{ <action> }}, may be a for-loop, conditional statement, or even a custom function defined by the user. Using the same starter code as in the last post, we have:

package main

import (
    "os"
    "text/template"
)

type Person struct {
    Name       string
    Age        int
    Employed   bool
    Occupation string
}

func main() {
    // insert code here
}

Note that whenever we want to export a variable or a function in Go, the variable name must begin with a capital letter. Hence, the Person struct and all of its attributes begin with capital letters.

The next step is to create a template file which we will call demo.tmpl. For now, this file will contain some basic text:

Nothing here yet

In main.go, we create a slice containing a couple of Person objects, which we will then pass to the template file by calling template.Execute.

func main() {
    people := []Person{
        {
            Name:       "Bob",
            Age:        42,
            Employed:   true,
            Occupation: "Doctor",
        },
        {
            Name:       "Jessica",
            Age:        22,
            Employed:   false,
            Occupation: "",
        },
    }
}

In the same file, we then call template.New().ParseFiles. This function initializes a template with the filename demo.tmpl and parses it to ensure that there are no syntax errors. The panic function ensures quick error-handling. We then execute the template using template.Execute, with the slice people as the second argument, as can be seen below:

    tmplFile := "demo.tmpl"
    tmpl, err := template.New(tmplFile).ParseFiles(tmplFile)
    if err != nil {
        panic(err)
    }
    err = tmpl.Execute(os.Stdout, people)
    if err != nil {
        panic(err)
    }

If we run go run main.go, on the terminal will be printed the string nothing here yet, as this is the only string written in the file at the moment.

We therefore begin populating the template file. We can use the range action to iterate through the slice that was passed in.

{{ range . }}
-----------------
Name: {{.Name}}
Age: {{.Age}}
{{ end }}

In the command {{ range . }}, the . represents the slice. The range action is also terminated with {{ end }}. In the code block above, we access the name and age of each Person object in the people slice. Running go run main.go gives us the following result:

-----------------
Name: Bob
Age: 42

-----------------
Name: Jessica
Age: 22

We want to display the occupation of each Person conditionally: if Employed is true, then display the occupation, otherwise display Unemployed. Both the if and else actions are used for this as seen below:

{{ range . }}
-----------------
Name: {{.Name}}
Age: {{.Age}}
Occupation: {{ if .Employed }}{{ .Occupation }}{{ else }}Unemployed{{end}}
{{ end }}

Note that the conditional statement is also terminated with {{ end }}. Running go run main.go gives us the following result:

-----------------
Name: Bob
Age: 42
Occupation: Doctor

-----------------
Name: Jessica
Age: 22
Occupation: Unemployed

At the top of the file, we want to include the number of people contained in the slice. We can do so by using the len action like so:

People: {{ len . -}}
{{ range . }}
-----------------
Name: {{.Name}}
Age: {{.Age}}
Occupation: {{ if .Employed }}{{ .Occupation }}{{ else }}Unemployed{{end}}
{{ end }}

Note that in the command {{ len . -}}, the . represents the slice and the - indicates that a newline character \n should not be printed after the first line. Running go run main.go gives us the final result:

People: 2
-----------------
Name: Bob
Age: 42
Occupation: Doctor

-----------------
Name: Jessica
Age: 22
Occupation: Unemployed

The first step is to create a Go file called main.go that imports the necessary packages and defines the main function.

package main

import (
    "os"
    "text/template"
)

func main() {
    // insert code here
}

For this tutorial, I will be using a struct called Person, which can be defined as so:

type Person struct {
    Name       string
    Age        int
}

In main.go, we first initialize a new template called demo, and we then parse the template string to ensure there are no syntax errors. We use the panic function to handle errors quickly. We then execute the template using the Execute function which takes in two arguments: the first argument is to specify where you want the final report to be printed (this could be another file or the terminal). For this demo, the final report will be printed to the terminal (os.Stdout). The second argument specifies the data that is sent to the template string. In this demo, one instance of the struct Person is passed into the template string. Code for this step is shown below:

    person := Person{"Alex", 32}
    tmpl, err := template.New("demo").Parse("{{.Name}} is {{.Age}} years old")
    if err != nil {
        panic(err)
    }
    err = tmpl.Execute(os.Stdout, person)
    if err != nil {
        panic(err)
    }

In the template string, both the Name and Age attributes of the Person object are accessed by prepending a . to the attribute name. The . here represents the Person object. Main.go now looks like this:

package main

import (
    "os"
    "text/template"
)

type Person struct {
    Name       string
    Age        int
}

func main() {
    person := Person{"Alex", 32}
    tmpl, err := template.New("demo").Parse("{{.Name}} is {{.Age}} years old")
    if err != nil {
        panic(err)
    }
    err = tmpl.Execute(os.Stdout, person)
    if err != nil {
        panic(err)
    }
}

After running go run main.go, you will get the following output in the terminal:

Alex is 32 years old

import "fmt"

s := make([]int, 2, 3)
for i := range s {
    s[i] = i+1
}

fmt.Println(s, len(s), cap(s)) // [1 2] 2 3

Note that if we were to add an element such that we exceed the slice’s capacity, the capacity will automatically increase. Therefore, in order to add/remove elements from the slice without exceeding its capacity, we first check whether its length, len(s), is equal to the capacity, cap(s).

type Stack struct {
    elements []int  // stores the objects in the stack
    size     int  // the maximum size of the stack
}

func (s *Stack) GetLength() int {
    return len(s.elements) // return current length of the stack
}

func (s *Stack) Add(element int) {
    if s.GetLength() == s.size { // if the stack is at max length, don't add new element
        fmt.Println("Stack is full")
        return
    } else {
        s.elements = append(s.elements, element)
        return
    }
}

We then define a new method called Pop with the following implementation:

func (s *Stack) Pop() int {
    if s.GetLength() == 0 { // if stack is empty, there is nothing to pop
        fmt.Println("Stack is empty")
        return 0
    } else if s.GetLength() == 1 {
        temp := s.elements[0]
        s.elements = s.elements[:0] // if current length is 1, stack becomes empty
        return temp
    } else {
        length := s.GetLength()
        temp := s.elements[length-1]
        s.elements = s.elements[:length-1]
        return temp // return the popped element
    }
}

We can then define the main function to create and modify a stack object:

import "fmt"

func main() {
    s := Stack{size: 3} // creates a stack with a max size of 3
    s.Add(1)
    s.Add(2)
    s.Add(3)
    s.Add(4)  // Stack is full
    fmt.Println(s.elements) // [1, 2, 3]
    elem1 := s.Pop()
    elem2 := s.Pop()
    elem3 := s.Pop()
    fmt.Println(elem1, elem2, elem3) // 3, 2, 1
    s.Pop() // Stack is empty
    fmt.Println(s.elements) // []
}

The stack data structure is now implemented!

The first step is to create the struct and call it Queue.

type Queue struct {
    elements []int  // stores the objects in the queue
    size     int  // the maximum size of the queue
}

After defining the struct, we can define its methods, namely GetLength(), Enqueue(), and Dequeue(). By writing (q *Queue) when defining the function (where q denotes a Queue object), we specify that the method belongs to the struct.

func (q *Queue) GetLength() int {
    return len(q.elements) // return current length of the queue
}

func (q *Queue) Enqueue(element int) {
    if q.GetLength() == q.size { // if the queue is at max length, don't add new element
        fmt.Println("Queue is full")
        return
    } else {
        q.elements = append(q.elements, element)
        return
    }
}

func (q *Queue) Dequeue() int {
    if q.GetLength() == 0 { // if queue is empty, there is nothing to dequeue
        fmt.Println("Queue is empty")
        return 0
    } else if q.GetLength() == 1 {
        temp := q.elements[0]
        q.elements = q.elements[:0] // if current length is 1, queue becomes empty
        return temp
    } else {
        temp := q.elements[0]
        q.elements = q.elements[1:]
        return temp // return the dequeued element
    }
}

The last step is to define the main function that will create and modify a queue object:

import "fmt"

func main() {
    q := Queue{size: 3} // creates a queue with a max size of 3
    q.Enqueue(1)
    q.Enqueue(2)
    q.Enqueue(3)
    q.Enqueue(4)  // Queue is full
    fmt.Print(q.elements) // [1, 2, 3]
    elem1 := q.Dequeue()
    elem2 := q.Dequeue()
    elem3 := q.Dequeue()
    fmt.Println(elem1, elem2, elem3) // 1, 2, 3
    q.Dequeue() // Queue is empty
}

The queue data structure is now implemented!

Note that the stack data structure is very similar in implementation. Only the Dequeue() method needs to be changed to remove the last element in elements instead of the first.

In Go, a struct is defined using the type keyword. The general way of defining a struct is as follows:

type <struct_name> struct {
    // struct attributes
}

The code block below does two things: it defines a struct called person that has name (type string) and age (type int) as its attributes, and it declares an object of this type:

import "fmt"

type person struct {
    firstName string
    age int
}
person1 := person{firstName: "Anna", age: 35}

fmt.Println(person1)  // {Anna 35}
fmt.Println(person1.firstName)  // Anna
fmt.Println(person1.age)  // 35

Structs are also mutable, so we can change the value of a struct’s attribute:

import "fmt"

person2 := person{firstName: "Allison", age: 20}

fmt.Println(person2)  // {Allison 20}
person2.age += 1
fmt.Println(person2)  // {Allison 21}

It is possible that only one variable is a struct, and so it doesn’t make sense to give the struct a name. The following code block creates an object flower with attributes colour and petal_number:

import "fmt"

flower := struct {
    colour       string
    petal_number int
}{
    "blue",
    6,
}
fmt.Println(flower)  // {blue 6}

Just like any other datatype, a string can be defined using either the var keyword or the shorthand method. Both ways can be seen in the code block below:

var string1 string = "hello"  // using 'var' keyword
string2 := "hi"  // using shorthand method

In order to use basic string functions in a code block, we have to import the strings package:

import "strings"

We can access many different functions from this package. The following section will present example usage of some of these functions.

The Contains() function returns whether a substring is found in another string. The first parameter is the string we want to search, and the second parameter is the substring we want to search for.

import (
"strings"
"fmt"
)

string3 := "Hello, how are you?"
contains_o := strings.Contains(string3, "o")
contains_q := strings.Contains(string3, "q")

fmt.Println(contains_o)  // true
fmt.Println(contains_q)  // false

The Index() function returns the index of a specific character in a string. The first parameter is the string we want to search, and the second parameter is the character whose index we want.

import (
"strings"
"fmt"
)

string4 := "Good morning"
index_o := strings.Index(string4, "o")
index_od := strings.Index(string4, "od")
index_q := strings.Index(string4, "q")

fmt.Println(index_o)  // 1
fmt.Println(index_od)  // 2
fmt.Println(index_q)  // -1: because q is not in the string

Index_o stores the index of the first instance of the letter o. Index_od stores the index of where the substring od starts. Since q is not in string4, -1 is returned when trying to get its index.

The Replace() function can be used to replace substring a in a string with substring b a specified number of times (n). The first parameter is the original string from which a copy is returned, the second parameter is a , the third parameter is b , and the fourth parameter is n. The code block below demonstrates how this function works:

import (
"strings"
"fmt"
)

string4 := "ababababa"
string4 = strings.Replace(string4, "b", "a", 2)
string5 := strings.Replace(string4, "b", "a", -1)

fmt.Println(string4)  // aaaaababa
fmt.Println(string5)  // aaaaaaaaa

The first example shows the first two instances of b replaced by a The second example - string5 - uses -1 as the last parameter, which indicates that all instances of ‘b’ should be replaced by a.

The Split() function slices a string into all substrings that are separated by a specified character. The function returns a slice with the substrings as its elements. The code block below demonstrates how this function works:

import (
"strings"
"fmt"
)

string6 := "1-2-3-4"
slice1 := []string{}
slice1 = strings.Split(string4, "-")

fmt.Println(slice1)  // [1 2 3 4]

The basic syntax for creating a map is as follows:

map1 := map[key_datatype]value_datatype{key-value pairs}

The code block below demonstrates how one can create a map with strings mapping to integers.

import "fmt"

map2 := map[string]int{}  // an empty map
map3 := map[string]int{"a": 1, "b": 2}  // a non-empty map

fmt.Println(map2)
fmt.Println(map3)
// output: 
//    map[]
//    map[a:1 b:2]

Once a map is initialized, there are many things that we can do with it. For instance, we can access the value of a certain key in the map by doing the following:

import "fmt"

map4 := map[string]int{"x": 1, "y": 2}

fmt.Println(map4["x"])
// output = 1

You may think that trying to access the value of a key that does not exist in the map will give you an error (like in Python). However, in Go, the value returned will be 0 (if the value datatype is an integer), 0.0 (if the value datatype is a float), or "" (if the value datatype is a string). This may be confusing because an actually existing key in the map may have the value 0. Therefore, to determine whether a key is in a map, we can do the following:

import "fmt"

map5 := map[string]int{"x": 1, "y": 2}
_, exists_x := map5["x"]
_, exists_z := map5["z"]

fmt.Println(exists_x)
fmt.Println(exists_z)
// output =
//    true
//    false

The '_' seen in the examples above is known as the blank identifier . Both examples have two parameters returned, the value of the key and whether the key is in the map. Since only the latter is used in the code, we can disregard the former by using '_'.

We can also assign a new value to a key in the map. The code block below demonstrates how we can do this:

import "fmt"

map5 := map[string]int{"animals": 4, "plants": 3}
map5["animals"] = 10

fmt.Println(map5["animals"])
// output = 10

We can also add/delete a key from the map:

import "fmt"

// adding a key
map6 := map[string]int{"lions": 1, "buffalo": 2}
map6["giraffes"] = 3
fmt.Println(map6)
// output: map[buffalo:2 giraffes:3 lions:1]

// deleting a key
delete(map6, "lions")  // "delete" function takes in a map and a key
fmt.Println(map6)
// output: map[buffalo:2 giraffes:3]

Note that the map is outputted with the keys in alphabetical order.

We can also iterate through a map using the for-each range loop (see this post for more details).

map7 := map[string]int{"x": 5, "y": 6}
for k, v := range map7 {
    fmt.Println(k, v)  // print both the key and value side-by-side
}
// output: 
//    x 5
//    y 6

For loops are used in two cases: either we want to execute a block of code a set number of times, or we want to iterate through elements of some data structure (ex. an array).

The code block below demonstrates how a for loop can be used to execute a block of code a set number of times:

import "fmt"

n := 10
for i := 0; i < 10; i++ {  // repeat 10 times
    n++  // increment n by 1
}
fmt.Println(n)
// output: n = 20

Looping through elements of an array or slice can either be done with the method above (with 'i' acting as the index) or with another loop called the for-each range loop shown below:

import "fmt"

arr := [5]{1, 2, 3, 4, 5}
for i := range arr {
    arr[i] += 2  // increment each element in 'arr' by 2
}

fmt.Println(arr)
// output: [3, 4, 5, 6, 7]

In the for-each range loop, we have access to both the index and the value of each element in the array. The example below demonstrates how this can be useful:

import "fmt"

slice1 := []int{1, 2, 3, 5}  // 'slice1' is a slice, not an array
for i, v := range slice1 {
    fmt.Println(i, v)  // print each index-value pair in slice1
}

// output: 
//    0 1
//    1 2
//    2 3
//    3 5

For while loops, instead of using the 'while' keyword (as in C, Python, and Java), Go uses the 'for' keyword. However, instead of being paired with an incremental variable, the 'for' keyword is paired with a condition. Therefore, the for loop will continue iterating while the condition is not met.

The code block below demonstrates how this type of for loop can be used:

import "fmt"

n := 0
slice2 := []int  // an empty slice is initiated
for n < 10:
    slice2 = append(slice2, n)  // append 'n' to 'slice2'
    n++  // increment 'n' by 1

fmt.Println(slice2)
// output: [0 1 2 3 4 5 6 7 8 9]

The first method is to use an if statement. The code block below demonstrates how this can be done:

import "fmt"

var a int = 1
if a == 1 {  // the condition checks whether a is equal to 1
      a++
}
fmt.Println(a)  
//output: 2

Note that the condition which is being evaluated does not have to be in brackets.

If/else statements can be used when we want code block 1 to be executed when condition a is true and code block 2 to be executed when condition a is false.

import "fmt"

var a int = 2
if a == 1 {
    fmt.Println("a is equal to 1")
} else if a < 1 {  // the condition checks whether a is less than 1
    fmt.Println("a is less than 1")
} else {  // proceed if both conditions above are false
    fmt.Println("a is greater than 1")
}
// output: a is greater than 1

Another conditional construct is a switch statement. A switch statement can be used when an expression needs to be compared to multiple different values. The code block below demonstrates how switch statements can be used:

import "fmt"

var a = 2
switch a {
    case 1: // does a == 1?
        fmt.Println("a is equal to 1")
    case 2: // does a == 2?
        fmt.Println("a is equal to 2")
}
// output: a is equal to 2

A switch statement can have a default case as well. An example below shows this:

import "fmt"

var a = 3
switch a {
    case 1:  // does a == 1?
        fmt.Println("a is equal to 1")
    case 2: // does a == 2?
        fmt.Println("a is equal to 2")
    default:
        fmt.Println("a is neither 1 nor 2")

// output: a is neither 1 nor 2

In both if/else and switch statements, it is possible to declare a variable inside the statement. Note that this variable would only exist within the scope of the conditional construct.

The code block below demonstrates how a variable can be declared in an if/else statement.

import "fmt"

if b := 10; b % 2 == 0 {  // define b = 10, check if b is divisible by 2
    b++  // increment 'b' by 1
    fmt.Println(b)
} else {
    b += 2  // increment 'b' by 2
    fmt.Println(b)
}
// output: 11

Note that it is not possible to print b outside of the if/else statement because it is only defined within the scope of the statement.

The code block below demonstrates how a variable can be declared inside a switch statement:

import "fmt"

switch b := 3; b {
    case 1:  // does b == 1?
        fmt.Println("b is equal to 1")
    case 2: // does b == 2?
        fmt.Println("b is equal to 2")
    default:
        fmt.Println("b is neither 1 nor 2")
// output: b is neither 1 nor 2

By tightly scoping a variable to where it is needed and by making the code more concise, declaring a variable within a conditional construct can improve code readability and maintainability.

There are a few ways to initialize a slice. The first way is very similar to how we initialize an array:

var slice1 = []int{} // initializes an empty slice with undefined length
var slice2 = []int{1, 2, 3}  // initalizes a non-empty slice

Note that in the square brackets on the right side of the equal sign, no length is specified (unlike for an array).

The second way is to create a slice from an array:

var arr1 = [5]int{1, 2, 3, 4, 5}
slice3 := arr1[1:4]  // slice3 = [2, 3, 4]

When a slice is created from an array, it is a pointer to a specific section of the array. Because of this, when modifying a slice, the same modifications will show up in the underlying array. This can be illustrated in the code block below:

slice3[0] = 44  // slice3 = [44, 3, 4]
fmt.Println(arr1)  // [1, 44, 3, 4, 5]

Elements can be added to a slice simply by using the "append" function. The first argument of this function is a slice and the rest are values that should be appended to the final slice. In the code below, we update the value of slice4 to be the original slice4 (containing values 5, 6, and 7) plus the values 8, 9, and 10:

var slice4 = []int{5, 6, 7}  // slice4 = [5, 6, 7]
slice4 = append(slice4, 8, 9, 10)  // slice4 = [5, 6, 7, 8, 9, 10]

Removing an element from a slice is done by using the "append" function as well. The code block below gives an example of how this is done:

var slice5 = []int{1, 2, 3, 4, 5}  // slice5 = [1, 2, 3, 4, 5]
slice5 = append(slice5[:2], slice5[3:]...)  // slice5 = [1, 2, 4, 5]

We can see that the value at the second index of "slice5" is removed by updating the value of "slice5" to be slice5[:2] plus slice5[3:] ([1, 2] + [4, 5]).

Let's say that we want to initialize an array without assigning it a value. The code block below creates an empty integer array with a maximum length of 5:

var arr[5]int

When an integer array is initialized as empty, each position in the array has the value 0. Similarly, when a float array is initialized as empty, each position has the value 0.0.

We can also initialize an array and assign it a value at the same time. The code block below initializes an array that stores values 1, 3, and 4:

arr1 := [3]int{1, 3, 4}  // array "arr1" has length of 3

Lastly, we can also initialize and assign a value to a multi-dimensional array in the same way. The code block below initializes two 2x2 arrays: an empty one named "arr" and a non-empty one named "arr1":

var arr[2][2]int
arr1 := [2][2]int{
    {1, 1}, 
    {2, 2},
}

To read user input, Go uses a function called 'Scan()', which can be found in the 'fmt' package, so we need to import it. Assuming the code will reside in the function 'main', we get the following starter code:

package main

import "fmt"

func main() {
    // write code here
}

In the main function, we first want to declare a string variable that will store the user's input. We can call this variable 'firstName'.

package main

import "fmt"

func main() {
    var firstName string
}

We can then use the 'Scan()' function to get the user input and store it into the 'firstName' variable. It is important to understand that 'Scan()' takes in a pointer to a variable. This is because Go needs the memory address of the variable in order to assign it a value. Therefore, we write '&firstName' as the parameter.

package main

import "fmt"

func main() {
    var firstName string
    fmt.Scan(&firstName)
}

Lastly, we want to output a greeting to the screen. We can do this with the 'Println()' function. Note that this function is the exact same as 'Print()' but it adds a newline character to the end of the outputted string.

package main

import "fmt"

func main() {
    var firstName string
    fmt.Scan(&firstName)
    fmt.Println("Hello", firstName)
}

With the script finished, you can run it with 'go run main.go'.

In Go, this is very easy to do. You simply use the keyword 'var'. To declare a variable without assigning a value to it right away, you can write the following:

var abc string

The code above defines a string variable called 'abc'.

We can just as well use this syntax to assign a value to the variable:

var abc string = "Hello"

The code above defines a string variable called 'abc' with the value "Hello."

You can also declare and assign without specifying the datatype of the variable by writing something like this:

var abc = "Hello"

In the code above, it is left to the compiler to figure out the datatype of the variable 'abc'.

There is another syntax that can be used for the declaring and assigning of a variable:

abc := "Hello"

The ':=' notation is used instead of 'var'. Note that this notation can only be used when first declaring a variable. If you want to assign 'abc' another value later on, you should use '=' and not ':='.

One final note on variables: they are designed to be mutable so you can change the value of them. However, the datatype of the variable cannot be changed.

Starting off with a blank file, we first have to import a library called 'fmt' which stands for 'format'. This module has formatted I/O functions that allow for the printing/scanning of user input.

import "fmt"

The code is going to reside in a function called 'main', and we can define this function like this:

func main() {}

Inside this function, we can use the 'Println' function found in the 'fmt' library to print 'Hello World'.

fmt.Println("Hello World")

And so the final script is this:

import "fmt"

func main() {
    fmt.Println("Hello World")
}

Congratulations, you have written your first script in GO! After writing the script, we would like to execute it, and this can be done through the following steps.

Let's say the 'Hello World' script exists inside a file called 'main.go' as shown below. Note that at line 1, we specify that this file belongs to the package 'main'. This is because every file written in Go must belong to some sort of package, otherwise Go will give an error.

In the terminal, we can then write the command 'go run main.go' to execute the script. After writing this command, you will see 'Hello World' outputted in the terminal. You have now successfully written and executed a Go script!

This tutorial will be taking you through the process of setting up Mattermost on Ubuntu 20.04. The process is not complicated, and I have added explanations (and things you should note) for each step to help you through it :)

Before starting, you should first update and upgrade Ubuntu.

sudo apt update
sudo apt updgrade

After, you should reboot the system by running:

reboot

First, you want to download PostgreSQL by running the command below:

sudo apt -y install postgresql postgresql-contrib

Once it finishes downloading, run the following command to login into the PostgreSQL database:

sudo --login --user postgres

Next, what you want to do is write a series of commands. *Note, copy all commands as is, so make sure the commands are in uppercase and that there is a ';' at the end of each statement (I left both parts out on my first attempt at running mattermost… it didn't work :p).

psql
CREATE DATABASE mattermost;

After running the command above, you should see printed on the command-line that the database was created. You can run \l to see all databases, and you should see the mattermost database there.

CREATE USER <username> WITH PASSWORD '<password>';

You should see that the role was created. Use your own username and password, and make sure you remember the username and password you chose for the user, as it will be used for future configurations.

GRANT ALL PRIVILEGES ON DATABASE mattermost to <username>;
\q

The last command exits the psql CLI.

Run the following command to exit the PostgreSQL account:

exit

Next, we want to add a new user to run our mattermost instance (the user is named mattermost):

sudo useradd --system --user-group mattermost

We are then going to install Mattermost by running the following command (here, version 5.37.0 is being installed, check the most recent version of Mattermost at the time you are installing it).

wget https://releases.mattermost.com/5.37.0/mattermost-5.37.0-linux-amd64.tar.gz

You want to then extract the archive and move it to the /opt folder

tar xvf mattermost-5.37.0-linux-amd64.tar.gz
sudo mv mattermost /opt

You should then create the storage directory for files that are posted to Mattermost

sudo mkdir /opt/mattermost/data

Give the mattermost user ownership and permission to the directory:

sudo chown -R mattermost:mattermost /opt/mattermost

Give the write permission to the mattermost user as well:

sudo chmod -R g+w /opt/mattermost

Next, you have to go into the configuration file that is stored in the directory:

sudo nano /opt/mattermost/config/config.json

In this file, you'll find keys with certain key-value pairs. There are four values you should change in your configuration of Mattermost. * Note, I am attempting to run Mattermost locally, and so that is why I am using 'localhost:8065'. You should change the values below depending on what domain name you want Mattermost to run on.

["ServiceSettings"]["SiteURL"] = "http://localhost:8065"

["ServiceSettings"]["ListenAddress"] = "localhost:8065"

Next, you want to rewrite a value so that Mattermost is using PostgreSQL in the backend.

["SqlSettings"]["DriverName"] = "postgres"

Make sure you put in the value below for the "Datasource" key. Make sure to put in your username and password where prompted. Also, make sure to keep the port in this URL as 5432 because otherwise, it'll give you a "failing to ping database" message after starting Mattermost.

["SqlSettings"]["DataSource"] = "postgres://<username>:<password>@localhost:5432/mattermost?sslmode=disable\u0026connect_timeout=10"

You should save and close the file after modifying the values.

Next, you have to go into the mattermost.service file by running the command below.

sudo nano /etc/systemd/system/mattermost.service

Copy and paste the below code snippet into the file.

[Unit]
Description=Mattermost
After=network.target
After=postgresql.service
Requires=postgresql.service

[Service]
Type=notify
ExecStart=/opt/mattermost/bin/mattermost
TimeoutStartSec=3600
Restart=always
RestartSec=10
WorkingDirectory=/opt/mattermost
User=mattermost
Group=mattermost
LimitNOFILE=49152

[Install]
WantedBy=multi-user.target

Save and close the file.

Then run the following commands to start and enable Mattermost.

sudo systemctl daemon-reload
sudo systemctl start mattermost.service
sudo systemctl enable mattermost.service

After running the commands above, you can check the status of Mattermost by running:

sudo systemctl mattermost.service

Outputted onto the screen, you can see the status of Mattermost. If it is running (active), then you can navigate to Mattermost using your own domain name and you should see Mattermost running there!