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

# Unused imports
Go programs with unused imports don't compile. This is a deliberate feature of the language since importing packages slows down the compiler. In large programs, unused imports could make a significant impact on compilation time.

To keep the compiler happy during development, you can reference the package in some way:

package main

import (
    "fmt"
    "math"
)

// Reference unused package
var _ = math.Round
func main() {
    fmt.Println("Hello")
}

# `goimports`

A better solution is to use the `goimports` tool. `goimports` removes
unreferenced imports. What’s even better is that the following widget does not use `goimports` and the compilation fails

package main

import "math" // imported and not used: "math"

func main() {
    fmt.Println("Hello") // undefined: fmt
}

After running `goimports`:
```
./goimports main.go 
```

package main

import "fmt"

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

In the above code, `goimports` removes the unreferenced import `math` and adds the missing `fmt` import.

Go plugins for most popular IDEs run `goimports` automatically when
saving a source file.

# Underscore imports

Underscore imports reference a package solely for the package's side effects. This means the package creates package-level
variables and runs package #key# init functions: init() function is like the main function which neither takes any arguments nor returns any values. It serves the specific purpose of initializing the state of the application. It runs once at the startup of the application before the main() function runs. #key#.

Basics of Go

Data Types

Collection Types

Control Structures

Functions, Goroutines and Interfaces

Inheritance and Equality

Memory and Time

Wrap Up!

Imports

Unused imports

`goimports`