Go Details 101

This article will list all kinds of details in Go. Some of these details are shown in other Go 101 articles, some are shown in the following sections.

• Code package related details:
  • A package can be imported more than once in a source file.
  • The comment // import "x.y.z.mypkg" following package mypkg is meaningful for the standard Go compiler.
• Control flow related details:
  • The default branch in switch and select blocks can be put before all case branches, after all case branches, or between case branches.
  • Nested deferred function calls can modify return result values of nesting functions.
  • For a slice s, the loop for i = range s {...} is not equivalent to the loop for i = 0; i < len(s); i++ {...}.
  • Exit a program with a os.Exit function call and exit a goroutine with a runtime.Goexit function call.
• Pointer related details:
  • For a numeric value pointer p, expression *p++ is equivalent to (*p)++. If p is not a numeric value pointer, *p++ doesn't compile.
  • Values of two named pointer types can be converted to each other if the base types of the two types are identical. The underlying types of the two pointer types can be different.
  • Addresses of different zero-sized values may be equal, or not.
  • The base type of a pointer type may be the pointer type itself.
  • A detail about selector shorthands.
• Container related details:
  • Sometimes, nested composite Literals can be simplified.
  • In some scenarios, it is ok to use array pointers as arrays.
  • Retreiving elements from nil maps will not panic. The result is a zero element value.
  • Deleting an entry from a nil map will not panic. It is a no-op.
  • The result slice of an append function call may share some elements with the original slice, or not.
  • The length of a subslice may be larger than the base slice the subslice is derived from.
  • Deriving a subslice from a nil slice is ok only if all the indexes used in the subslice expression are zero. The result subslice is also a nil slice.
  • The length and capacity of a slice can be modified seperately.
  • The indexes in slice and array composite literals must be non-negative integer constants.
  • Elements of unaddressable arrays are also unaddressable, but elements of unaddressable slices are always addressable.
  • It is ok to derive subslices from unaddressable slices, but not ok from unaddressable arrays. It is ok to take element addresses for unaddressable slices, but not ok for unaddressable arrays.
  • Putting elements with NaN as key to a map is like putting the elements in a black hole.
  • Constant key values in a container composite literal can't be duplicated.
  • In a for-range loop code block, any iteration variable can be ignored or omitted.
  • In a for-range loop, the iterator variable(s) and the ranged container are all value copies.
  • Ranging over a nil maps or a nil slices is ok, it is a no-op.
  • Range over a nil array pointer is ok if the second iteration variable is ignored or omitted.
  • There is an optimization made by the standard Go compiler to reset container elements as zero values.
  • The capacity of the result slice of a conversion from a string to byte/rune slice may be larger than the length of the result slice.
• String related details:
  • The time complexity of comparing two equal strings may be O(1) or O(n).
  • If the first argument of a built-in function copy or append call is a byte slice, then the second argument can be a string followed by ....
• Function and method related details:
  • A multi-result function call can't mix with other expessions when the call is used as the sources in an assignment or the arguments of another function call.
  • Some function calls are evaluated at compile time.
  • Each method corresponds to an implicit function.
• Interface related details:
  • Comparing an interface value with itself might cause a panic.
  • Type assertions can be used to convert a value of an interface type to another interface type, even if the former interface type doesn't implemented the latter one.
  • Whether or not the second optional result of a type assertion is present will affect the behavior of the type assertion.
  • For the standard Go compiler, the time complexity of comparing two equal interface values may be O(1) or O(n).
  • For the standard Go compiler, the time complexity of copying an interface value is O(1).
  • Two error values returned by two errors.New calls with the same argument are not equal.
• Channel related details:
  • Receive-only channels can't be closed.
  • Sending a value to a closed channel is viewed as a non-blocking operation, and this operation causes a panic.
• More type and value related details:
  • In Go, a value of some types may be composed of more than one parts.
  • Types can be declared within function bodies.
  • NaN != NaN, Inf == Inf.
  • The sizes of nil values of different types may be different.
  • nil, iota, true, false and built-in types are not keywords. They are just predeclared identifiers.
  • For the standard compiler, zero-sized fields in a struct may be treated as one-byte-sized value.
  • Non-exported method names and struct field names from different packages are viewed as diffferent names.
  • type T *T is a valid type definition.
• Miscellanies:
  • Parentheses are required in several rare scenarios to make code compile okay.
  • A program doesn't need a main entry function to run.
  • The extra last , in an item list (such parameter/argument/result lists and element lists in composite literals) never do harm.
• Standard packages related:
  • The results of reflect.DeepEqual(x, y) and x == y may be different.
  • We should use os.IsNotExist(err) instead of err == os.ErrNotExist to check whether or not a file exists.
  • The flag standard package treats boolean command flags differently than integer and string flags.
  • [Sp|Fp|P]rintf functions support positional arguments.

A Go source file can imports the same package multiple times, but the import names must be different. These same-pacakge imports reference the same package instance.

For example:

package main

import "fmt"
import "io"
import inout "io"

func main() {
	fmt.Println(&inout.EOF == &io.EOF) // true
}

The reason is the elements of an array value and the array will be stored in the same memory block when the array is stored in memory. But the situation is different for slices.

An example:

package main

func main() {
	// Container composite literals and map elements are all unaddressable.

	// Take container element addresses.
	_ = &[]int{1}[0] // ok
	_ = &[5]int{}[0] // error: cannot take the address of [5]int literal[0]
	_ = &(&[5]int{})[0] // ok
	_ = &(*&[5]int{})[0] // ok

	// Modify container element values.
	map[int]int{}[1] = 9
	[]int{1,2,3}[1] = 9
	[3]int{1,2,3}[1] = 9 // error: cannot assign to [3]int literal[1]
	(&[3]int{1,2,3})[1] = 9
}

The reason is the same as the last detail.

An example:

package main

func main() {
	// Literal values and map elements are unaddressable in Go.

	// The following lines fail to compile.
	/*
	_ = [...]int{6, 7, 8, 9}[1:3]  // error: slice of unaddressable value
	_ = &([...]int{6, 7, 8, 9}[0]) // error: cannot take element address
	var ma = map[string][4]int{"abc": {0, 1, 2, 3}}
	_ = ma["abc"][1:3]  // error: slice of unaddressable value
	_ = &(ma["abc"][0]) // error: cannot take element address
	*/

	// The following lines compile okay.
	_ = []int{6, 7, 8, 9}[1:3]
	_ = &([]int{6, 7, 8, 9}[0])
	var ms = map[string][]int{"abc": {0, 1, 2, 3}}
	_ = ms["abc"][1:3]
	_ = &(ms["abc"][0])
}

This follows IEEE-754 standard and is consistent with most other programming languages:

package main

import "fmt"
import "math"

func main() {
	var a = math.Sqrt(-1.0)
	fmt.Println(a)      // NaN
	fmt.Println(a == a) // false

	var x = 0.0
	var y1, z1 = 1 / x, 2 / x
	var y2, z2 = -1 / x, -2 / x
	fmt.Println(y1, z1, y1 == z1) // +Inf +Inf true
	fmt.Println(y2, z2, y2 == z2) // +Inf +Inf true
}

This reason is NaN != NaN (see the above detail). The elements with NaN as key can only be found out in a for-range loop.

package main

import "fmt"
import "math"

func main() {
	var a = math.NaN()
	fmt.Println(a)      // NaN

	var m = map[float64]int{}
	m[a] = 123
	v, present := m[a]
	fmt.Println(v, present) // 0 false
	m[a] = 789
	v, present = m[a]
	fmt.Println(v, present) // 0 false

	fmt.Println(m) // map[NaN:<nil> NaN:<nil>]
	delete(m, a) // no-op
	fmt.Println(m) // map[NaN:<nil> NaN:<nil>]

	for k, v := range m {
		fmt.Println(k, v)
	}
	// the above loop outputs:
	// NaN 123
	// NaN 789
}

The time complexity depends on whether or not the direct parts of the two equal interfaces both reference the undrelying value. Please read the article value parts for detail.

package main

import "fmt"
import "time"

func main() {
	bigarr := [1 << 20]int{}

	type I interface{}

	// i0, i1 and i2 are three equal interfaces.
	var i0 I = bigarr // the dynamic value of i0 is a copy of bigarr.
	var i1 I = bigarr // the dynamic value of i1 is also a copy of bigarr.
	                  // Note, the dynamic values of i0 and i1 are
	                  // two different copies of bigarr.
	var i2 I = i1 // i2 shares the same dynamic value copy with i1.

	startTime := time.Now()
	_ = i0 == i1
	duration := time.Since(startTime)
	fmt.Println("duration for (i0 == i1):", duration)

	startTime = time.Now()
	_ = i1 == i2
	duration = time.Since(startTime)
	fmt.Println("duration for (i1 == i2):", duration)
}
/*
The output (1ms == 1,000,000ns):
duration for (i0 == i1): 1.381337ms
duration for (i1 == i2): 609ns
*/

1ms is 1000000ns!

Duplicated non-constant keys are allowed. For example:

package main

import "fmt"

func main() {
	const N = 123
	var n = N

	var m = map[int]string {
		N: "abc",
		// N: "xyz", // error: duplicate key N in map literal
		n: "hello", // ok
		n: "bye", // ok
	}

	fmt.Println(m[N])
}

Please note, Go specification doesn't specifies the element initilization order in a composite literal. So the above program may print abc, hello or bye, depending on compilers and compiler versions.

Whether or not the addresses of two zero-sized values are equal is compiler and compiler version dependent.

package main

import "fmt"

func main() {
	a := struct{}{}
	b := struct{}{}
	x := struct{}{}
	y := struct{}{}
	m := [10]struct{}{}
	n := [10]struct{}{}
	o := [10]struct{}{}
	p := [10]struct{}{}

	fmt.Println(&x, &y, &o, &p)

	// For the standard Go compiler (1.10),
	// x, y, o and p escape to heap,
	// but a, b, m and n are allocated on stack.

	fmt.Println(&a == &b) // false
	fmt.Println(&x == &y) // true
	fmt.Println(&a == &x) // false

	fmt.Println(&m == &n) // false
	fmt.Println(&o == &p) // true
	fmt.Println(&n == &p) // false
}

The outputs indicated in the above code are for the standard Go compiler 1.10.

Using err == os.ErrNotExist may miss errors.

package main

import (
	"fmt"
	"os"
)

func main() {
	_, err := os.Stat("a-nonexistent-file.abcxyz")
	fmt.Println(os.IsNotExist(err))    // true
	fmt.Println(err == os.ErrNotExist) // false
}

An example:

package main

func main() {
	type P *P
	var p P
	p = &p
	p = **************p
}

Similarly,

• the element type of a slice type can be the slice type itself,
• the element type of a map type can be the map type itself,
• the element type of a channel type can be the channel type itself,
• and the argument and result types of a function type can be the function type itself.

package main

func main() {
	type S []S
	type M map[string]M
	type C chan C
	type F func(F) F

	s := S{0:nil}
	s[0] = s
	m := M{"Go": nil}
	m["Go"] = m
	c := make(C, 3)
	c <- c; c <- c; c <- c
	var f F
	f = func(F)F {return f}

	_ = s[0][0][0][0][0][0][0][0]
	_ = m["Go"]["Go"]["Go"]["Go"]
	<-<-<-c
	f(f(f(f(f))))
}

For example:

package main

type T struct{x, y int}

func main() {
	// Each of the following three lines makes code fail to compile.
	// Some "{}" confuse compilers.
	/*
	if T{} == T{123, 789} {}
	if T{} == (T{123, 789}) {}
	if (T{}) == T{123, 789} {}
	*/

	// We must add parentheses like the following two lines to
	// make code compile okay.
	if (T{} == T{123, 789}) {}
	if (T{}) == (T{123, 789}) {}
}

For example, when the source files importing this package are compiled by the standard Go compiler, the import path of the following package must be "x.y.z.mypkg".

package mypkg // import "x.y.z.mypkg"
...

The respective final values of the iteration variable i may be different for the two loops.

package main

import "fmt"

var i int

func fa(s []int, n int) int {
	i = n
	for i = 0; i < len(s); i++ {}
	return i
}

func fb(s []int, n int) int {
	i = n
	for i = range s {}
	return i
}

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(fa(s, -1), fb(s, -1)) // 6 5
	s = nil
	fmt.Println(fa(s, -1), fb(s, -1)) // 0 -1
}

The following program runs well before Go 1.10, for the standard Go compiler. But since Go 1.11, it fails to compile.

package main

import (
    "fmt"
    "time"
)

func init() {
	for {
		time.Sleep(time.Second)
		fmt.Println("hi")
	}
}

var main int

For a pointer value, which type is either defined or not, if the base type of its (pointer) type is a struct type, then the pointer value can access the fields of the struct value it references. However, if the type of the pointer value is a defined type, the value can not access the methods of the value its references.

package main

type T struct {
	x int
}
func (T) m(){} // T has one method.

type P *T  // a defined one-level pointer type.
type PP *P // a defined two-level pointer type.

func main() {
	var t T
	var tp = &t
	var tpp = &tp
	var p P = tp
	var pp PP = &p
	tp.x = 12  // okay
	p.x = 34   // okay
	pp.x = 56  // error: type PP has no field or method x
	tpp.x = 78 // error: type **T has no field or method x)

	tp.m()  // okay. Type *T also has a "m" method.
	p.m()   // error: type P has no field or method m
	pp.m()  // error: type PP has no field or method m
	tpp.m() // error: type **T has no field or method m
}

For example, if the following types are declared in package foo:

package foo

type I = interface {
	about() string
}

type S struct {
	a string
}

func (s S) about() string {
	return s.a
}

and the following types are declared in package bar:

package bar

type I = interface {
	about() string
}

type S struct {
	a string
}

func (s S) about() string {
	return s.a
}

then,

• values of the two respective types S from the two packages can't be converted to each other.
• the two respective interface types S from the two packages denote two distinct method sets.
• type foo.S doesn't implement the interface type bar.I.
• type bar.S doesn't implement the interface type foo.I.

package main

import "包2/foo"
import "包2/bar"

func main() {
	var x foo.S
	var y bar.S
	var _ foo.I = x
	var _ bar.I = y

	// The following lines fail to compile.
	x = foo.S(y)
	y = bar.S(x)
	var _ foo.I = y
	var _ bar.I = x
}

The reason is the errors.New function will copy the input string argument and use a pointer to the copied string as the dynamic value of the returned error value. Two different calls will produce two different pointers.

package main

import "fmt"
import "errors"

func main() {
	notfound := "not found"
	a, b := errors.New(notfound), errors.New(notfound)
	fmt.Println(a == b) // false
}

There are three forms to pass command arguments.

1. -flag, for boolean flags only.
2. -flag=x, for any flag.
3. -flag x, for non-boolean flags only.

And please note that, all items following a boolean flag with the first form are viewed as arguments.

package main

import "fmt"
import "flag"

var b = flag.Bool("b", true, "a boolean flag")
var i = flag.Int("i", 123, "an integer flag")
var s = flag.String("s", "hi", "a string flag")

func main() {
	flag.Parse()
	fmt.Print("b=", *b, ", i=", *i, ", s=", *s, "\n")
	fmt.Println("arguments:", flag.Args())
}

If we run the following program with the below shown flags and arguments

./exampleProgram -b false -i 789 -s bye arg0 arg1

the output will be

b=true, i=123, s=hi
arguments: [false -i 789 -s bye arg0 arg1]

This output is obviously not what we expect.

We should pass the flags and arguments like

./exampleProgram -b=false -i 789 -s bye arg0 arg1

or

./exampleProgram -i 789 -s bye -b arg0 arg1

to get the output we expect:

b=true, i=789, s=bye
arguments: [arg0 arg1]

We should not assume the length and the capacity of the result slice are always equal.

In the following example, if the last fmt.Println line is removed, the outputs of the two lines before it print the same value 32, otherwise, one print 32 and one print 8. (For the standard Go compiler 1.10.)

package main

import "fmt"

func main() {
	s := "a"
	x := []byte(s)              // len(s) == 1
	fmt.Println(cap([]byte(s))) // 32
	fmt.Println(cap(x))         // 8
	fmt.Println(x)
}

The following program will print 3, 2, 1.

An example:

package main

import "fmt"

func main() {
	fmt.Printf("%[3]v, %[2]v, %[1]v", 1, 2, 3) // 3, 2, 1
}

We can exit a program from any function by calling the os.Exit function. An os.Exit function call takes an int code as argument and returns the code to operating system.

An example:

// exit-example.go
package main

import "os"
import "time"

func main() {
	go func() {
		time.Sleep(time.Second)
		os.Exit(1)
	}()
	select{}
}

Run it:

$ go run a.go
exit status 1
$ echo $?
1

We can make a goroutine exit by calling the runtime.Goexit function. The runtime.Goexit function has no parameters.

In the following example, the Java word will not be printed.

package main

import "fmt"
import "runtime"

func main() {
	c := make(chan int)
	go func() {
		defer func() {c <- 1}()
		defer fmt.Println("Go")
		func() {
			defer fmt.Println("C")
			runtime.Goexit()
		}()
		fmt.Println("Java")
	}()
	<-c
}