Home
Go (Fundamentals) 101
Go Generics 101
Go Details & Tips 101
Go Optimizations 101
Go Quizzes 101
Go Q&A 101
Go Practices 101
Go Bugs 101
Go 101 Blog
Go 101 Apps & Libs
Go Optimizations 101, Go Details & Tips 101 and Go Generics 101 are all updated for Go 1.24 now. The most cost-effective way to get them is through this book bundle in the Leanpub book store.

TapirMD - a powerful, next-generation markup language that simplifies content creation (much more powerful than markdown). You can experience it online here.

Some Simple Summaries

Index:

Types whose values may have indirect underlying parts

Types whose values may have indirect underlying parts:
  • string types
  • function types
  • slice types
  • map types
  • channel types
  • interface types

The answer is based on the implementation of the standard Go compiler/runtime. In fact, whether or not function values may have indirect underlying parts is hardly to prove, and string values and interface values should be viewed as values without indirect underlying parts in logic. Please read value parts for details.

Types which values can be used as arguments of built-in len function (and cap, close, delete, make functions)

len cap close delete make
string
Yes

array
(and array pointer)
Yes
Yes

slice
Yes
Yes

Yes
map
Yes

Yes
Yes
channel
Yes
Yes
Yes

Yes

Values of above types can also be ranged over in for-range loops.

Types which values can be used as arguments of built-in function len can be called container types in broad sense.

Comparison of built-in container types

Type Can New Elements Be Added into Values? Are Elements of Values Replaceable? Are Elements of Values Addressable? Will Element Accesses Modify Value Lengths? May Values Have Underlying Parts
string
No
No
No
No
Yes(1)
array
No
Yes(2)
Yes(2)
No
No
slice
No(3)
Yes
Yes
No
Yes
map
Yes
Yes
No
No
Yes
channel
Yes(4)
No
No
Yes
Yes

(1) For the standard Go compiler/runtime.
(2) For addressable array values only.
(3) Generally, a slice value are modified by assigned another slice value to it by overwriting it. Here, such cases are not viewed as "add new elements". In fact, slice lengths can also be modified separately by calling the reflect.SetLen function. Increase the length of a slice by this way is kind of adding new elements into the slice. But the reflect.SetLen function is slow, so it is rarely used.
(4) For buffered channels which are still not full.

Types which values can be represented with composite literals (T{...})

Values of the following four kinds of types can be represented with composite literals:

Type (T) Is T{} a Zero Value of T?
struct
Yes
array
Yes
slice
No
(zero value is nil)
map
No
(zero value is nil)

Value sizes of all kinds of types

Please read value copy cost for details.

Types which zero values can be represented with nil

The zero values of the following types can be represented with nil.

Type (T) Size of T(nil)
pointer
1 word
slice
3 words
map
1 word
channel
1 word
function
1 word
interface
2 words

The above listed sizes are for the standard Go compiler. One word means 4 bytes on 32-bit architectures and 8 bytes on 64-bit architectures. and the indirect underlying parts of a value don't contribute to the size of the value.

The size of a zero value of a type is the same as any other values of the same type.

Types we can implement methods for

Please read methods in Go for details.

Types which can be embedded in struct types

Please read which types can be embedded for details.

Functions whose calls will/may be evaluated at compile time

If a function call is evaluated at compile time, its return results must be constants.

Function Return Type Are Calls Always Evaluated at Compile Time?
unsafe.Sizeof
uintptr
Yes, always.

But please note that the result of such a call is not viewed as a constant if the argument type of the call is a type parameter.

unsafe.Alignof
unsafe.Offsetof
len
int
Not always.

From Go specification:
  • the expression len(s) is constant if s is a string constant.
  • the expressions len(s) and cap(s) are constants if the type of s is an array or pointer to an array and the expression s does not contain channel receives or (non-constant) function calls.

Please note that, even if such a function call is evaluated at compile-time, the evaluation result is not viewed as a constant if the argument type of the call is a type parameter.

cap
real
The result is an untyped value. Its default type is float64.
Not always.

From Go spec: the expressions real(s) and imag(s) are constants if s is a complex constant.

imag
complex
The result is an untyped value. Its default type is complex128.
Not always.

From Go spec: the expression complex(sr, si) is constant if both sr and si are numeric constants.

Addressable and unaddressable values

Please read this FAQ item to get which values are addressable or unaddressable.

Types which don't support comparisons

Please read this FAQ item to get which values are addressable or unaddressable.

Which code elements are allowed to be declared but not used

Allowed to Be Declared but Not Used?
import
No
type
Yes
variable
Yes for package-level variables.
No for local variables (for the standard compiler).
constant
Yes
function
Yes
label
No

Named source code elements which can be declared together within ()

Following source code elements (of the same kind) can be declared together within ():
  • import
  • type
  • variable
  • constant

Functions can't be declared together within (). Also labels.

Named source code elements which can be declared both inside functions and outside any functions

Following named source code elements can be declared both inside functions and outside any functions:
  • type
  • variable
  • constant

Imports must be declared before declarations of other elements (and after the package clause). Functions can only be declared outside any functions. Anonymous functions can be defined inside other function bodies, but such definitions are not function declarations. Labels must be declared inside functions.

Expressions which evaluation results may contain optional additional values

The evaluation results of the following expressions may contain optional additional values:

Syntax Meaning of The Optional Value (ok in the syntax examples) Will Omitting the Optional Result Affect Program Behavior?
map element access
e, ok = aMap[key]
whether or not the accessed key is present in the map
No
channel value receive
e, ok = <- aChannel
whether or not the received value was sent before the channel was closed
No
type assertion
v, ok = anInterface.(T)
whether or not the dynamic type of the interface value matches the asserted type
Yes
(when the optional bool result is omitted, a panic occurs if the assertion fails.)

Ways to block the current goroutine ‎forever by using the channel mechanism

Without importing any package, we can use the following ways to make the current goroutine ‎enter (and stay in) blocking state forever:

  1. send a value to a channel which no ones will receive values from 
    make(chan struct{}) <- struct{}{}
// or
make(chan<- struct{}) <- struct{}{}

  2. receive a value from a never-closed channel which no values have been and will be sent to 
    <-make(chan struct{})
// or
<-make(<-chan struct{})
// or
for range make(<-chan struct{}) {}

  3. receive a value from (or send a value to) a nil channel 
    chan struct{}(nil) <- struct{}{}
// or
<-chan struct{}(nil)
// or
for range chan struct{}(nil) {}

  4. use a bare select block 
    select{}

Ways to concatenate strings

Please read strings in Go for details.

Optimizations made by the standard Go compiler

Please read the Go 101 wiki article for this summary.

Run-time panic and crash cases

Please read the Go 101 wiki article for this summary.

todo: kinds of control flow blocks control flow statements return, break, fallthrough, continue, goto which control flow statements can be followed a label. which control flow statements can appear in which control flow blocks

(more articles ↡)

The Go 101 project is hosted on Github. Welcome to improve Go 101 articles by submitting corrections for all kinds of mistakes, such as typos, grammar errors, wording inaccuracies, description flaws, code bugs and broken links.

If you would like to learn some Go details and facts every serveral days, please follow Go 101's official Twitter account @zigo_101.

The digital versions of this book are available at the following places:
Tapir, the author of Go 101, has been on writing the Go 101 series books and maintaining the go101.org website since 2016 July. New contents will be continually added to the book and the website from time to time. Tapir is also an indie game developer. You can also support Go 101 by playing Tapir's games (made for both Android and iPhone/iPad):
Individual donations via PayPal are also welcome.
Articles in this book: