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

This code will not compile because there is an unused variable.

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

var unusedGlobal int 

func main() {
}
```

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

var unusedGlobal int 

func main() {
}
</code></pre>

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

func main() {
	var unusedVariable int 
}
```

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

func main() {
	var unusedVariable int 
}
</code></pre>

Compile error: non-declaration statement outside function body

What will the following code print?
```Go
package main
import "fmt"

v1 := 1 

func main() {
    fmt.Println(v1)
}
```

What will the following code print?
<pre><code class="language-Go">package main
import &quot;fmt&quot;

v1 := 1 

func main() {
 fmt.Println(v1)
}
</code></pre>

What will the following code print?
```Go
package main

import "fmt"

func main() {
 v1, v2 := 1, 2
 for i := 0; i < 3; i++ {
	 v2 := 3
	 v1, v2 = v1 + 1, v2 + 2
 }
 fmt.Println(v1, v2) 
}
```

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

import &quot;fmt&quot;

func main() {
 v1, v2 := 1, 2
 for i := 0; i &lt; 3; i++ {
	 v2 := 3
	 v1, v2 = v1 + 1, v2 + 2
 }
 fmt.Println(v1, v2) 
}
</code></pre>

By using an external tool to not let the code compile.

Not using short variable declarations
inside of nested code blocks.

How can we avoid accidental errors in code having shadowed variables?

How can we avoid accidental errors in code having shadowed variables?

Operator precedence is ___ in most programming languages including Go.

Operator precedence is ___ in most programming languages including Go.

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

import "fmt"

func main() {
	fmt.Println(1 + 2 << 1 * 3)
}
```

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

import &quot;fmt&quot;

func main() {
	fmt.Println(1 + 2 &lt;&lt; 1 * 3)
}
</code></pre>

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

import (
	"fmt"
)

func main() {
	i := 0
	slice := []int{0, 0, 0}
	for si := range slice {
		i++
		slice[si] = i
	}
	fmt.Println(slice)
}
```

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

import (
	&quot;fmt&quot;
)

func main() {
	i := 0
	slice := []int{0, 0, 0}
	for si := range slice {
		i++
		slice[si] = i
	}
	fmt.Println(slice)
}
</code></pre>

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

import (
	"fmt"
)

func main() {
	i := 0
	slice := []int{0, 0, 0}
	for si := range slice {
		slice[si] = ++i
	}
	fmt.Println(slice)
}
```

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

import (
	&quot;fmt&quot;
)

func main() {
	i := 0
	slice := []int{0, 0, 0}
	for si := range slice {
		slice[si] = ++i
	}
	fmt.Println(slice)
}
</code></pre>

Will print "Weekend" if the day is Sunday or Saturday.

Will print "Not weekend" otherwise.

Will print "Not weekend" if the day is Sunday or Saturday.

Will print "Weekend" otherwise.

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

import (
	"fmt"
	"time"
)

func main() {
	v := time.Now().Weekday()
	fmt.Println(
		v == time.Sunday || v == time.Saturday 
		? "Weekend"
		: "Not weekend")
}
```

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

import (
	&quot;fmt&quot;
	&quot;time&quot;
)

func main() {
	v := time.Now().Weekday()
	fmt.Println(
		v == time.Sunday || v == time.Saturday 
		? &quot;Weekend&quot;
		: &quot;Not weekend&quot;)
}
</code></pre>

What will be the output of the following code snippet?
```Go
package main
import "fmt"

func main() {
  const (
    myconst = "c"
    myconst2 = "c2"
    constx = iota 
    consty = iota 
)
    fmt.Println(consty)
}

```

What will be the output of the following code snippet?
<pre><code class="language-Go">package main
import &quot;fmt&quot;

func main() {
 const (
 myconst = &quot;c&quot;
 myconst2 = &quot;c2&quot;
 constx = iota 
 consty = iota 
)
 fmt.Println(consty)
}

</code></pre>

Test your understanding of data 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: Data Types