• Strong and static typing - the type of the variables can't be changed over time and they have to be defined at compile time
• Simplicity
• Fast compile times
• Built-in concurrency
• Garbage collected
• Platform independent
• Compile to standalone binary - anything you need to run your app will be compiled into one binary. Very useful for version management in run-time.

True

Any exported variable, function, ... begins with a capital letter. In fact when using a package, you can use only the things the package exports for you and others to use.

• False
• True

With var x int = 2 we are setting the variable type to integer, while with x := 2 we are letting Go figure out by itself the type. The result is the same, both styles can't be used in every situation. For example, short declaration can't be used outside of a function.

package main

import "fmt"

x := 2

func main() {
    x = 3
    fmt.Println(x)
}

It will fail with expected declaration, found x as outside of a function, every statement should start with a keyword (and short variable declarations won't work).

package main

import "fmt"

func main() {
    var x int = 101
    var y string
    y = string(x)
    fmt.Println(y)
}

It looks what unicode value is set at 101 and uses it for converting the integer to a string. If you want to get "101" you should use the package "strconv" and replace y = string(x) with y = strconv.Itoa(x)

package main
 
import "fmt"
 
func main() {
    var x uint
    x = -3
    // comment!
    fmt.Println(x)
}

Error. When x is declared as uint it means you can't put any negative values. But because we did put a negative value (-3) it will fail to compile it.

package main

import "fmt"

func main() {
  const X := 2
  fmt.Print(X)
}

It won't run. Constants cannot be declared using :=.

package main

import "fmt"

const (
    Const1 = 1 
    Const2 = 1 < 2 
    Const3 = 1 << 10                              
)

func main() {
    fmt.Println(Const1)
    fmt.Println(Const2)
    fmt.Println(Const3)
}

The 1024 result is because we shifted a 1 bit left 10 places.

var str string = "cowabunga"
fmt.Println(str[3])

97 Because it prints the ascii code of 'a' which is 97.

'ab'

package main
  
import ( 
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    if randNum := rand.Intn(100); randNum%2 == 0 {
        fmt.Print("Bingo!")               
    } else {
        fmt.Print(randNum)
    }       
}

Defines a variable with random value between 0 and 100. If the random value is even, prints "Bingo!" otherwise, prints the random value itself.

Because we want to reference the memory address of the variable, this is where the user input will be stored.

var arr = [...]int{1, 2, 3, 4}
var anotherArr = [4]int{1, 2, 3, 4}
fmt.Println(arr == anotherArr)

The result of comparison is true.

False. Go treats the array size as being part of the type itself. So [1]int type != [2]int type.

False. It's not possible to use variable to define an array of certain size. As the size of an array is part of its type and types must be resolved at compile time, not runtime.

var slice []int var slice = []int{1, 2}

b = append(b, 7)

[2 0 1 7 2 0 2 2]

Because in Go when you pass a something to a function, it copies it. So when we append something to a slice it appends it to a copy of it. So in order to change the original slice, we need to assign the returned copy back into the original slice.

slice := make([]int, 20)

slice := make([]int, 3, 20)

It's more efficent to set the size once for a slice rather than increase its capacity every times new items added to it.

slice := make([]int, 3)
slice = append(slice, 41)

[0 0 0 41]

True. Otherwise it will cause compile-time error or run-time error, depends on how you defined it.

• [1 2 3 4 5]
• [3 4 5]
• [1]
• [3 4]

slice := []int{1, 2, 3}
anotherSlice := slice[1:]
slice[1] = 999
anotherslice[1] = 5
fmt.Println("slice:", slice)
fmt.Println("slice:", anotherSlice)

[10 999 3]
[999 5]

The expalantion is that slicing a slice isn't creating a copy of the data but rather creates another variable that shares the very same memory.

for {
    fmt.Print("forever!")
}

for true {
    fmt.Print("forever!")
}

From result perspective, there is no difference. Both are infinite loops.

nonEmptyMap := map[string][]int{
  "someKey": []int{1, 2, 3},
  "anotherKey": []int{4, 5, 6},
}

someMap := make(map[int][]string, 100)

True. This is also true for the all the values in a single map.

len(someMap)

False.

someMap := map[string]int{}
someMap["x"] = 41
fmt.Println(someMap["y"])

0

someMap := map[string]int{
  "x": 41,
}
value, exists := someMap["x"]
fmt.Println(value, exists)
value, exists = someMap["y"]
fmt.Println(value, exists)

41 true 0 false

someMap := map[string]int{
  "x": 41,
  "y": 303,
  "z": 56,
}

delete(someMap, "y")

func add(x int, y int) int {
    return x + y
}

add is a function that takes two parameters (two integers) and returns their sum.

func add(x int, y int) int {
    return x + y
}

func add(x, y int) int {
    return x + y
}

Both. If two or more parameters share the same type, you can specify it only once.

False. A fucntion in Go can return multiple values

func process(num int) (x int) {
    x = num + 10
    var z = num - x
    x = z + x
    return
}

func main() {
  fmt.Println(process(10))
}

10

package main

import "fmt"

func main() {
    defer fmt.Println("1")

    fmt.Println("2")
}

2
1

2 is printed before 1 due to the defer statement. The defer statement defers the execution of the function (fmt.Println("1")) until the surrounding fucntion (which is main()) returns.

True.

package main

import "fmt"

func main() {
    fmt.Println("100")

    for i := 0; i < 10; i++ {
      defer fmt.Println(i)
    }

    fmt.Println("200")
  }

100
200
9
8
7
6
5
4
3
2
1
0

Deferred functions are executed in a last-in-first-out order, this is why it prints it from 9 to 0 instead of from 0 to 9.

Capitalize the first letter of what you would like to export.

• Local
• Package
• Global