Variables, types, and the compiler that argues with you

This is the chapter where Go feels most foreign, and it is worth knowing why in advance. In JavaScript, a variable is a box that holds anything and can hold something else tomorrow. In Go, a variable has one type forever, decided when it is created, and the compiler refuses to build your program if you break that promise.

That refusal is the feature. Work with it for a week and you will notice a whole category of bug has stopped happening to you.

Declaring things

Go has two ways to make a variable, and you will use one of them ninety percent of the time.

var name string = "Ada"   // the long form, type stated
var age = 36              // type inferred, still a var
// short form: declare and infer, inside functions
name := "Ada"

The := operator is the one you want. It declares a new variable and infers its type from the value on the right. It only works inside a function, which is why package level variables use var.

An unused variable is a compile error, not a warning.

func main() {
    count := 10
    fmt.Println("hello")
}
// ./main.go:4:5: declared and not used: count

This feels hostile on day one and reasonable by day ten. Dead variables are usually the residue of a half-finished edit, and Go would rather stop you than let the residue accumulate. The same rule applies to unused imports.

The types you will actually use

Go has a lot of numeric types. You will use about four of them.

• Type
• JavaScript
• Notes
• string
• string
• Immutable, UTF-8 bytes. Indexing gives a byte, not a character
• int
• number
• Whole numbers. 64 bit on any machine you own
• float64
• number
• Decimals. The default for a fractional literal
• bool
• boolean
• true or false. No truthiness, ever
• byte
• -
• Alias for uint8. A byte of data
• rune
• -
• Alias for int32. One Unicode code point

The one to notice is that JavaScript's single number splits into int andfloat64, and Go will not convert between them for you.

count := 10          // int
price := 2.5         // float64
total := count * price
// invalid operation: count * price (mismatched types int and float64)

You must say what you mean:

total := float64(count) * price   // 25

Zero values: there is no undefined

Every type in Go has a zero value, and a declared variable always has it. There is no undefined, and no uninitialised memory.

• string
• ""
• int, float64
• 0
• bool
• false
• pointers, slices, maps, interfaces, functions
• nil

var name string
var count int
var ready bool
fmt.Println(name == "", count == 0, ready == false) // true true true

This is genuinely useful. A struct you create is immediately valid, with every field at a sensible default, and you never check whether a field "exists".

No truthiness

An if in Go takes a bool. Not a value that is bool-ish. A bool.

More characters, and no memorising which values are falsy. There is no == and=== distinction either, because there is only one == and it does not coerce.

Strings are bytes, and that matters

A Go string is a read-only slice of bytes holding UTF-8. Indexing it gives you a byte.

s := "héllo"
fmt.Println(len(s))     // 6, not 5: é takes two bytes
fmt.Println(s[1])       // 195, a byte value, not "é"

To work with characters, range over the string, which decodes runes:

for i, r := range "héllo" {
    fmt.Printf("%d: %c\n", i, r)
}
// 0: h
// 1: é      <- index jumps to 3 next, because é was two bytes
// 3: l
// 4: l
// 5: o

Strings are immutable, so building one in a loop with += allocates a new string every time. For anything beyond a few concatenations use a builder:

var b strings.Builder
for _, word := range words {
    b.WriteString(word)
    b.WriteString(" ")
}
result := b.String()

Control flow, briefly

if and for are almost familiar, with two differences worth stating.

There are no parentheses around the condition, and braces are mandatory even for one line.

if count > 10 {
    fmt.Println("plenty")
} else if count > 0 {
    fmt.Println("some")
} else {
    fmt.Println("none")
}

for is the only loop keyword. It covers every case JavaScript spreads acrossfor, while and for...of.

for i := 0; i < 10; i++ { }      // classic
for count < 10 { }               // while
for { }                          // infinite
for i, v := range items { }      // for...of, with the index

An if can carry a statement before the condition, scoped to the if. You will see this constantly in real code:

if err := doSomething(); err != nil {
    return err
}
// err does not exist here, which is the point

switch {
case score > 90:
    grade = "A"
case score > 80:
    grade = "B"
default:
    grade = "C"
}

package main

import "fmt"

func main() {
    fmt.Printf("%8s %8s\n", "C", "F")
    for c := -40; c <= 100; c += 20 {
        f := float64(c)*9/5 + 32
        fmt.Printf("%8d %8.1f\n", c, f)
    }
}

Assignment

Commit your work with the message Variables - Assignment One, exactly as written, so the leaderboard can score it.

fmt.Printf("%-10T %q\n", s, s)

Assignment

Commit your work with the message Variables - Assignment Two, exactly as written, so the leaderboard can score it.