Gotchas in Golang

Golang Gotchas

Writing programs that work when everything goes as expected is a good start. Making your programs behave properly when encountering unexpected conditions is where it really gets challenging.

Even seasoned Gopher can get trapped in one of the many pitfalls of the Go language. But there are some cases which might confuse or rather trick a rookie coder. These are called "Gotchas"! Originating from the informal term "Got You!", a gotcha is a case or scenario when the program plays the trick and results in an output that is quite different from what was expected.

The list of common gotchas is far from exhaustive, and is presented in no particular order of severity.

Mismatched types int and float64

The Go type system will not allow any mathematical operation between integer and float variables.

package main

import "fmt"

func main() {
	var x, y = 13, 3.5
	fmt.Println(x / y)
}

.\error-1.go:7:16: invalid operation: x / y (mismatched types int and float64)

What do you think will be the output of the following program?

package main

import "fmt"

func main() {
	var x = 13 / 3.5
	fmt.Println(x)
}

3.7142857142857144

package main

import "fmt"

func main() {
	var x, y = 13, 3.5
	fmt.Println(float64(x) / y)
}

Assignment to entry in nil map

Map types are reference types, like pointers or slices, and so the value of rect is nil; it doesn't point to an initialized map. A nil map behaves like an empty map when reading, but attempts to write to a nil map will cause a runtime panic; don't do that.

package main

import "fmt"

func main() {
	var rect map[string]int
	rect["height"] = 10
	fmt.Println(rect["height"])
}

panic: assignment to entry in nil map

What do you think will be the output of the following program?

package main

import "fmt"

func main() {
	var rect map[string]int
	fmt.Println(rect["height"])
	fmt.Println(len(rect))

	idx, key := rect["height"]
	fmt.Println(idx)
	fmt.Println(key)
}

The Zero Value of an uninitialized map is nil. Both len and accessing the value of rect["height"] will work on nil map. len returns 0 and the key of "height" is not found in map and you will get back zero value for int which is 0. Similarly, idx will return 0 and key will return false.

0
0
0
false

package main

import "fmt"

func main() {
	var rect = map[string]int{"height": 10}
	fmt.Println(rect["height"])
}

Raw string literals vs Interpreted string literals

There are two different ways to represent string literals.

package main

import "fmt"

func main() {
	s := `Go\tJava\nPython`
	fmt.Println(s)
}

What do you think will be the output of the above program?

Go\tJava\nPython

Raw strings are enclosed in back-ticks `. Here, \t and \n has no special meaning, they are considered as backslash with t and backslash with n. If you need to include backslashes, double quotes or newlines in your string, use a raw string literal.

package main

import "fmt"

func main() {
	s := "Go\tJava\nPython"
	fmt.Println(s)
}

Raw strings are enclosed in quotes ". Hence \t would be interpreted as tab and \n as new line. The above program will print,

Go      Java
Python

Invalid operation mismatched types Int and Time.Duration

The operands to numeric operations must have the same type unless the operation involves shifts or untyped constants.

package main

import (
	"fmt"
	"time"
)

func main() {
	var timeout = 3
	fmt.Println(timeout)
	fmt.Println(timeout * time.Millisecond)
}

.\error-1.go:11:22: invalid operation: timeout * time.Millisecond (mismatched types int and time.Duration)

What do you think will be the output of the following program?

package main

import (
	"fmt"
	"time"
)

func main() {
	const timeout = 10
	fmt.Println(timeout)
	fmt.Println(timeout * time.Millisecond)
}

Millisecond's underlying type is an int64, which the compiler knows how to convert to. Literals and constants are untyped until they are used, unless the type is explicitly declared. timeout is an untyped constant in this example. Its type is implicitly converted to time.Millisecond. This program will print the output −

10
10ms

package main

import (
	"fmt"
	"time"
)

func main() {
	var timeout time.Duration
	timeout = 10
	fmt.Println(timeout * time.Millisecond)
}

String Length Bytes vs Runes

When you ask the length of string in Go, you will get the size in bytes.

package main

import "fmt"

func main() {
	data := "We♥Go"
	fmt.Println(len(data))
}

What do you think will be the output of the above program?

7

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	data := "We♥Go"
	fmt.Println(utf8.RuneCountInString(data))
}

5

Initialize variable with nil

Nil is not a type but a reserved word, you cannot use it in assignment.

package main

import (
	"fmt"
)

func main() {
	var data string = nil
	if data == nil {
		fmt.Println(data)
	}
}

cannot use nil as type string in assignment

What do you think will be the output of the following program?

package main

import (
	"fmt"
)

func main() {
	var data *string = nil
	if data == nil {
		fmt.Println(data)
	}
}

*string is the type of the pointer variable which points to a value of type string. The zero value of a pointer is nil.

nil

Floating point multiplication

Floating-point arithmetic is considered an esoteric subject by many people.

package main

import (
	"fmt"
)

func main() {
	 var m = 1.39
	 fmt.Println(m * m)
	 
	 const n = 1.39
	 fmt.Println(n * n)
}

1.9320999999999997
1.9321

String type conversion

Go doesn't allow automatic type promotion between variables. You must use a type conversion when variable types do not match.

package main

import "fmt"

func main() {
	 i := 105
	 s := string(i)
	 fmt.Println(s)	 
}

What do you think will be the output of the above program?

i

package main

import (
	"fmt"
	"strconv"
)

func main() {
	i := 105
	s := strconv.Itoa(i)
	fmt.Println(s)
	
	s = fmt.Sprintf("%d", i)
	fmt.Println(s)
}

105
105

Unused Variables vs Unused Constants

Go has some rules that are unique among programming languages.

package main

func main() {
	var i = 100
}

i declared and not used

If you have unused variables, the code will not compile. If you assign a value to an unused variable, still your code will not compile. We'll have to use it somewhere to please the compiler.

package main

func main() {
	const i = 100
}