Gain insights into Go's unique features, delve into advanced memory handling, strings, loops, and goroutines. Discover how to handle multidimensional datasets and protect against variable bugs.

go.tar.gz

unicode_norm

equality_test

equality_bench

memory_first

imports_pkg

exercise

SPA test

Run packages

Go is a popular language known for its simplicity. For developers who lack a deep knowledge of its features, it's a great time to pick up the Go language. The differences between Go and other popular programming languages can lead to hours of Google for the newer software engineer. Mastering these surprising, sometimes delightful, sometimes frustrating features can be the difference between time spent on debugging and time spent on deployment.

In this course, you will go deeper than an introductory book to learn the various features that make Go unique. You’ll learn how to protect against the bugs caused by poorly defined variables (and variable shadowing), how Go treats slicers and arrays similarly, and how to work with multidimensional datasets. You’ll also dive into memory handling, strings, loops, and goroutines.

This course will be most useful if you already have a basic understanding of Go and its syntax. By the end of the course, you’ll move from Go-familiar to Go-expert.

Exploring and Mastering the Full Go Featureset

What will be the output of the following code?
```Go
package main

import "fmt"

func modify(arr [1]int, slice []int) {
	arr[0] = 1
	slice[0] = 1
}

func main() {
	arr := [1]int{0}
	slice := []int{0}
	modify(arr, slice)
	fmt.Println(arr[0], slice[0])
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func modify(arr [1]int, slice []int) {
	arr[0] = 1
	slice[0] = 1
}

func main() {
	arr := [1]int{0}
	slice := []int{0}
	modify(arr, slice)
	fmt.Println(arr[0], slice[0])
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1[1:2]
	s2[0] = 4
	fmt.Println(s1)
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1[1:2]
	s2[0] = 4
	fmt.Println(s1)
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1
	s2[0] = 4
	fmt.Println(s1)
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1
	s2[0] = 4
	fmt.Println(s1)
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1
	s2 = append(s2, make([]int, 100)...)
	s2[0] = 4
	fmt.Println(s1)
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	s1 := []int{1, 2, 3}
	s2 := s1
	s2 = append(s2, make([]int, 100)...)
	s2[0] = 4
	fmt.Println(s1)
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	s1 := make([]int, 3)
	s1 = append(s1, []int{1, 2, 3}...)
	fmt.Println(s1)
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	s1 := make([]int, 3)
	s1 = append(s1, []int{1, 2, 3}...)
	fmt.Println(s1)
}
</code></pre>

Go strings are always encoded as Unicode.

Which of the following statements is true?

Which of the following statements is true?

What is the length of `s1` string in the following code snippet?
```Go
s1 := string([]byte{0, 0, 0})
```

What is the length of <code>s1</code> string in the following code snippet?
<pre><code class="language-Go">s1 := string([]byte{0, 0, 0})
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	var b1 []byte // b1 is nil
	fmt.Println(string(b1) == "")
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	var b1 []byte // b1 is nil
	fmt.Println(string(b1) == &quot;&quot;)
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	str := "touché"
	fmt.Println(len(str))
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	str := &quot;touché&quot;
	fmt.Println(len(str))
}
</code></pre>

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	i := 0
	for range "touché" {
		i++
	}
	fmt.Println(i)
}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	i := 0
	for range &quot;touché&quot; {
		i++
	}
	fmt.Println(i)
}
</code></pre>

In the same order that they were added to the map.


None of the above because the order is undefined

In what order are Go map elements iterated?

In what order are Go map elements iterated?

Print `false` and then panic because the element does not exist in the `map` and the second return argument of a `map` lookup is not used.

What will be the output of the following code?
```Go
package main

import "fmt"

func main() {
	m := map[int]int{1: 1, 2: 2, 3: 3}
	el, exists := m[4]
	fmt.Println(exists)
	el2 := m[4]
	fmt.Println(el, el2)

}
```

What will be the output of the following code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	m := map[int]int{1: 1, 2: 2, 3: 3}
	el, exists := m[4]
	fmt.Println(exists)
	el2 := m[4]
	fmt.Println(el, el2)

}
</code></pre>

If `mymap` is not initialized (is `nil`), which of these ways of using it will cause a runtime panic?
```
var mymap map[int]int
```

If <code>mymap</code> is not initialized (is <code>nil</code>), which of these ways of using it will cause a runtime panic?
<pre><code>var mymap map[int]int
</code></pre>

Since map is implemented using a hashtable and its elements are moved around in memory, is it safe to do the following? What is the output of the code?
```Go
package main

import "fmt"

func main() {
	m := make(map[int]*int)
	i := 1
	m[1] = &i
	i = 2
	fmt.Println(*m[1])
}
```

Since map is implemented using a hashtable and its elements are moved around in memory, is it safe to do the following? What is the output of the code?
<pre><code class="language-Go">package main

import &quot;fmt&quot;

func main() {
	m := make(map[int]*int)
	i := 1
	m[1] = &amp;i
	i = 2
	fmt.Println(*m[1])
}
</code></pre>

Lets say a `map` is used to store and retrieve information about users that are currently logged in on the Go server. Since reads and writes to that `map` would happen from multiple concurrent *goroutines*, which of the following is a good option in such a case?

Lets say a <code>map</code> is used to store and retrieve information about users that are currently logged in on the Go server. Since reads and writes to that <code>map</code> would happen from multiple concurrent goroutines, which of the following is a good option in such a case?

Test your understanding of different collection types in Go.

Basics of Go

Data Types

Collection Types

Control Structures

Functions, Goroutines and Interfaces

Inheritance and Equality

Memory and Time

Wrap Up!

Quiz: Collection Types