intro.slide

Go crash course
3 Apr 2017
Tags: go, tutorial

Will Faught
Senior Software Engineer, BigCommerce
will.faught@bigcommerce.com

* Syntax

UTF-8 files:

    "I feel 😁"

Newlines can replace semicolons and separate brackets from content:

    struct{ x int; y int }

    struct {
        x int
        y int
    }

    import ("io"; "net")

    import (
        "io"
        "net"
    )

* Syntax, continued

Comma-delimited lists spanning multiple lines must have trailing commas:

    position{x: 7, y: 8}

    position{
        x: 7,
        y: 8,
    }

    foo(7, 8)

    foo(
        7,
        8,
    )

* Comments

Two kinds:

    // Line-ending comment

    /* Inter/intra-line comment */

Some comments are special annotations:

    package foo // import "foo.bar"

    // +build tag

    //go:generate command

    // Foo returns the...

* Expressions

* Parentheses

    (x) | ((x))

* Literals

Untyped:

    123 | 1.2e3 | 123i | 'r' | "s" | false | true | nil

Simple operations are evaluated by the compiler:

    1 + 2 | 3 / 4 | 5 << 6 | 7 < 8 | "a" + "b"

Literals implicitly type convert:

    var _      bool = false
    var _      bool = true
    var _ complex64 = 123i
    var _   float32 = 1.2e3
    var _      int8 = 123
    var _     int16 = 'r'
    var _      rune = 'r'
    var _   *string = nil
    var _     []int = nil
    var _  chan int = nil

* Literals, continued

Numbers have 256 bits of precision:

    var _ int64 = 1 << 100        // compiler error
    var _ int64 = 1 << 100 >> 100 // no compiler error

Default types:

    var _ = true // bool
    var _ = 7.7i // complex128
    var _ = 7.7  // float64
    var _ = 7    // int
    var _ = nil  // compile error: nil must be typed
    var _ = 'r'  // rune
    var _ = "s"  // string

* Identifiers

    _ | v | vv | v_ | _v | v_v | v7 | v7v | v.v | Ʃ

* Built-in named types

* Booleans

Type:

    bool

Literals:

    false | true

Operations:

    && | || | !

    bool(x) | new(bool)

* Integers

Types:

    int | int8 | int16 | int32 | int64 // int is word impl

    uint | uint8 | uint16 | uin32 | uint64 // uint is word impl

    uintptr // word impl

    byte // uint8 impl

    rune // int32 impl

Literals:

    7 | 07 | 0x7 | '7'

* Integers, continued

Operations:

    % | & | | | ^ | &^ | << | >>

    %= | &= | |= | ^= | &^= | <<= | >>=

    T(x) | new(T)

* Floating points

Types:

    float32 | float64

Literals:

    7 | 07 | 0x7 | '7' | 7.7 | 07.7 | 7e-7

Operations:

    T(x) | new(T) | new(T)

* Complexes

Types:

    complex64 | complex128

Literals:

    N1 + N2i | N1 - N2i | complex(N1, N1)

Operations:

    T(x) | imag(x) | new(T) | real(x)

* Integers, floating points, complexes

Operations:

    + | - | * | /

    += | -= | *= | /=

    ++ | --

    == | != | < | <= | > | >=

* Strings

Type:

    string

Literals:

    "" | `` | "s" | `s`

Operations:

    +

    +=

    == | != | < | <= | > | >=

    s[i] | s[i1:i2] | s[i:] | s[:i] | s[:]

    string(x) | len(s) | new(string) | string([]byte(x)) | []byte(s)

* Built-in unnamed types

* Arrays

Type:

    [N]T

Literals:

    A{} | A{e} | A{i: e} | [...]T{} | [...]T{e} | [...]T{i: e}

Operations:

    == | !=

    a[i] = e | a[i] | &a[i] | a[l:h] | a[l:] | a[:h] | a[:] | a[l:h:m] | a[:h:m]

    A(x) | cap(a) | len(a) | new(A)

Not synchronized.

* Slices

Type:

    []T

Literals:

    nil | S{} | S{e} | S{i: e}

Operations:

    == nil | != nil

    s[i] = e | s[i] | &s[i] | s[l:h] | s[l:] | s[:h] | s[:] | s[l:h:m] | s[:h:m]

    append(s, e) | append(s, e1, e2) | append(s1, s2...) | copy(dst, src)

    S(x) | cap(s) | len(s) | make(S) | make(S, c) | make(S, l, c) | new(S)

Not synchronized.

* Slices, continued

Slices as subarrays:

- Slices are references to subarrays
- Slice indexes start at 0
- Slices have the length of the subarray

Slices as dynamic arrays:

- Appending an element increments the length and inserts it at the last index
- If the last index is outside the array, the subarray is first copied into a bigger array
- Slice capacity is the length from the beginning of the subarray to the end of the array

Slices cannot be compared because they can be circular:

    var s = []interface{}{nil}

    s[0] = s

* Channels

Types:

    chan T | <-chan T | chan<- T

Literal:

    nil

Operations:

    == | !=

    <-c | c <- e | (<-chan T)(c) | (chan<- T)(c)

    C(x) | cap(c) | close(c) | len(c) | make(C) | make(C, n) | new(C)

* Maps

Type:

    map[T1]T2

Literals:

    nil | M{} | M{i: e}

Operations:

    == nil | != nil

    m[i] = e | m[i]

    M(x) | delete(m, i) | len(m) | make(M) | make(M, n) | new(M)

Not synchronized.

* Pointers

Type:

    *T

Literal:

    nil

Operations:

    == | !=

    P(x) | &x | *x

Value x must be addressable for &x.
Not synchronized.

* Structs

Types:

    struct{}

    struct{f T} | struct{f1 T; f2 T} | struct{f1, f2 T} | struct{f1, f2 T; f3, f4 T}

    struct{T} | struct{T1; T2} | struct{T; f T} | struct{f T; T} | struct{T1; f T; T2}

    struct{f1, f2 T `json:"field_f" xml:"field-f,attr"`}

    struct{f1 T "s"; f2 T "s"}

Literals:

    S{} | S{e} | S{f: e}

* Structs, continued

Operations:

    == | !=

    s.f = x | s.f | &s.f

    S(x) | new(S)

Not synchronized.

* Structs, continued

Embedded struct fields can be accessed at the top level if unambiguous:

    type T1 struct { f1, f2 T }
    type T2 struct { T1; f2, f3 T }

    var t1 T1
    var t2 T2

    t1.f1 = z // t1 == T1{f1: z}
    t1.f3 = z // t1 == T1{f1: z, f2: z}

    t2.f1 = z // t2 == T2{T1: T1{f1: z}}
    t2.f2 = z // t2 == T2{T1: T1{f1: z}, f2: z}
    t2.f3 = z // t2 == T2{T1: T1{f1: z}, f2: z, f3: z}

* Functions

Types:

    func() | func(T) T | func(T, T) (T, T) | func(...T) | func(T, ...T)

    func(T) | func(a T) | func(a T, b T) | func(a, b T) | func(a, b T, c, d T)

    func() T | func() (a T) | func() (a T, b T) | func() (a, b T) | func() (a, b T, c, d T)

Literals:

    F{} | F{ /* ... */ } // open bracket must be on the same line

Operations:

    == nil | != nil

    f() | f(x) | f(s...) | f(x, s...)

    F(x) | new(F)

Not synchronized.

* Functions, continued

Named parameter and result variables are declared implicitly:

    func f(a T) (b T) {
        // compiler error: var a, b T

        a, b = z, z

        // ...
    }

Parameter and result names do not affect function type equivalence.

* Statements

* Blocks

    {} | { /* ... */ }

New, nested scope within the brackets.

* Constant declarations

Singles:

    const a T = z
    const b, c T = z, z

    const a = z
    const b, c = z, z

Blocks:

    const (a T = z)
    const (b = z)

    const (a, b T = z, z)
    const (c, d = z, z)

    const (a, b T = z, z; c, d T = z, z)
    const (e, f = z, z; g, h = z, z)

Constants don't have to be used.

* Variable declarations

Singles:

    var a T
    var b T = z

    var a, b T
    var c, d T = z, z

    var a = z
    var b, c = z, z

    var a = oneresult()
    var b, c = tworesults()

* Variable declarations, continued

Blocks:

    var (a T)
    var (b T = z)
    var (c = z)

    var (a, b T)
    var (c, d T = z, z)
    var (e, f = z, z)

    var (a, b T; c, d T)
    var (e, f T = z, z; g, h T = z, z)
    var (i, j = z, z; k, l = z, z)

* Variable declarations, continued

Short assignments:

    var a, err = z()    // "var a T1" and "var err T2" declarations implied
    b, err := y()       // "var b T3" declaration implied
    c, d, err := x()    // "var c T4" and "var d T5" declarations implied
    e, c, d, err := w() // "var e T5" declaration implied

    a, err := z()       // do not do this; use "var a, err = z()" instead
    b, err := z()

Shadowing gotcha:

    a, b := z()

    if b {
        a, err := y() // new "a" variable
    }

    // old "a" variable unchanged

Local variables have to be used.

* Type declarations

Declare a new type in terms of an existing type:

    type newtypename existingtype

- The new type's "underlying type" is the existing type.
- New types are convertible to their underlying types transitively and vice versa

Singles:

    type a z
    type b z

Blocks:

    type (a z)

    type (a z; b z)

Types don't have to be used.

* Type declarations, continued

New types have the literals and operations of equivalent types:

    type A [1]int

    A{7}[0] // == 7

    type F func()

    F(func(){})() // compile error: F{}

    type I int

    I(7) + I(8) // == I(15)

    type M map[int]int

    M{7: 8}[7] // == 8

    type S string

    S("a") + S("b") // == S("ab")

* Assignments

    a = a
    a, b = b, a
    a, b = f()

    e = <-c
    e, ok = <-c

    e = m[i]
    e, ok = m[i]

    v = i.(T)
    v, ok = i.(T)

* Deferred function invocations

    defer a()

    defer a(z)

    defer a()
    defer b()

Can change named function results:

    func() (err error) {
        defer func() {
            err = fmt.Errorf("not implemented")
        }()

        return f()
    }

* Goroutine invocations

    go a()

    go a(z)

* Conditionals

    if b { /* ... */ }

    if b { /* ... */ } else { /* ... */ }

    if b { /* ... */ } else if b { /* ... */ } else { /* ... */ }

    if simplestatement; b { /* ... */ } // empty, expression, send, inc, dec, assignment, short decl

* Loops

    for { /* ... */ }

    for b { /* ... */ }

    for simplestatement; b; simplestatement { /* ... */ }

    for i := range x { /* ... */ } // x is an array, channel, map, slice, or string

    for i, e := range x { /* ... */ } // x is an array, map, slice, or string

    label:
    for {
        break
        break label
        continue
        continue label
    }

Loop index variables are declared once and reassigned per iteration.
Copy index variable values to keep them past the iteration.

* Switches

    switch {} | switch x {} | switch x.(type) | switch simplestatement; x {}

    switch x1 {
    case x2:
        /* ... */

    case x3, x4:
        /* ... */

    case x4:
        fallthrough

    case x5:
        break

    case x6:

    default:
        /* ... */
    }

* Switches, continued

    label:
    for {
        switch {
        case false:
            break       // breaks the switch, not the loop
        default:
            break label // breaks the loop
        }
    }

* Selects

    select {}

    select {
    case <-c:
        /* ... */

    case c <- x:
        /* ... */

    default:
        break
    }

* Selects, continued

    label:
    for {
        select {
        case <-c:
            break       // breaks the select, not the loop
        default:
            break label // breaks the loop
        }
    }

* Gotos

    goto label1

    /* ... */

    label1:

    /* ... */

    label2:

    /* ... */

    goto label2

- Labels are only used in function blocks
- Labels are scoped to the entire function block
- Label scope extends before label declarations and inside nested blocks

* Import declarations

Singles:

    import "a"
    import "b"

Blocks:

    import ("a")

    import ("a"; "b")

Only in file scope.
All imports must be used.

* Function declarations

Form:

    func f(a T) (b T) { /* ... */ }

Equivalent to:

    var f = func(a T) (b T) { /* ... */ }

Only in package scope.

* Methods

    type T struct{f *T}

    func (T) m1() {}

    func (*T) m2() {}

    func (t T) m3() {}

    func (t *T) m4() {}

    func (T) f() {} // compile error: one namespace for methods and fields

    var a T
    var b *T
    a.m1()
    b.m1() // run error: nil dereference
    (a.m2)()
    (b.m2)()

Only in package scope.

* Methods, continued

Methods are inherited from embedded types:

    type T1 struct{}

    func (T1) m1() {}

    type T2 struct{T1}

    func (*T2) m2() {}

T1 method set:

- m1()

T2 method set:

- m1()
- m2()

* Interfaces

Interface types represent method sets.

T1 interface:

    interface {
        m1()
    }

T2 interface:

    interface {
        m1()
        m2()
    }

* Interfaces, continued

Types:

    interface{} | interface{m()} | interface{m1(); m2()}

Literals:

    nil

Operations:

    == | !=

    i.m | i.(T)

    T(x) | new(T)

* Interfaces, continued

Use interface types to abstract method implementations:

    type T1 struct{}

    func (T1) A() {}

    func B(a T1) { a.A() }

    func C(a interface{ A() }) { a.A() }

    type T2 struct{}

    func (T2) A() {}

    /* ... */

    B(T1{})
    C(T1{})
    C(T2{})

* Interfaces, continued

Interfaces are implemented as:

- Pointer to the value
- Pointer to the type

Interface types box values:

    var p position        // p allocated on the stack
    var v interface{} = p // p moved to the heap, v refers to p on the heap

Interface values are nil only if their internal value and type pointers are nil:

    var i interface{} // i == nil
    var p *int        // p == (*int)(nil)

    i = 7 // i == 7,           i != nil
    i = p // i == (*int)(nil), i != nil

* Name binding

Nested scopes:

- Block
- Function
- File
- Package
- Universe

Namespaces:

- Single namespace for constants, variables, types, and functions
- Single namespace for struct fields and methods

* Exports

- All package-scope identifiers are exported to the same package
- All capitalized package-scope identifiers are exported to other packages
- Exportation only provides the ability to write a package's identifier

    // package p

    type t struct{}

    func A() t { return t{} }

    func B(t) {}

    // package q

    p.B(p.A())

    var x p.t = p.A() // compile error: p.t not exported
    var x = p.A()

    p.B(x)

* Exports, continued

Field export trick:

    type person1 struct { id, name string }
    type person2 struct { ID, Name string }

    json.Marshal(person1{}) // {}
    json.Marshal(person1{}) // {"ID":"","Name":""}

* Exports, continued

Method export trick:

    // package p

    type Doer interface { Do(); do() }

    type BaseDoer struct{}

    var _ Doer = BaseDoer{}

    func (d BaseDoer) Do() {}
    func (d BaseDoer) do() {}

    // package q

    type MyDoer struct{}

    var _ p.Doer = MyDoer{} // compile error: MyDoer missing the p.Doer.do method

    func (d MyDoer) Do() {}
    func (d MyDoer) do() {}

* Packages

Directories with .go files are Go packages.

Directories with sub-packages and no .go files are not Go packages.

GOPATH defaults to ~/go.

GOPATH tree for main package x and library package x/internal/y:

    bin/
        x
    pkg/
        darwin_amd64/
            x/
                internal/
                    y.a
    src/
        x/
            internal/
                y/
                    y.go
            main.go

* Packages, continued

Resolution of import path x/internal/y:

- Fail if . is not x or under x
- Use ./vendor/x/internal/y if it exists
- Use ../vendor/x/internal/y if it exists; repeat up the ancestor chain
- Use $GOPATH/src/x/internal/y if it exists

Package nesting has no semantic meaning but is often meaningful:

    encoding
    encoding/json
    io
    io/ioutil
    net
    net/http
    net/http/httputil

* Panics

Fail fast philosophy implementation and convention.

The system and programmer "panic" for irrecoverable conditions:

- Undefined behavior (nil dereference)
- Bad behavior (goroutine deadlock)
- Impossible errors (`json.Marshal(1)`)

Panics are special-purpose exceptions. Deferred function invocations still run.

Trigger (throw) a panic:

    panic(panicvalue) // parameter has type interface{}, nil okay

Recover from (catch) a panic:

    var panicvalue = recover() // result has type interface{}, nil possible

* Panics, continued

Call the panic function anywhere.
Call the recover function only in deferred functions (it always returns nil otherwise):

    defer func() { if v := recover(); v != nil { /* panic happened */ } }()

Don't handle all errors with panics and recoveries like normal exceptions.

* Errors

    type error interface { Error() string }

Used everywhere to signal error conditions:

    if err := f(); err != nil { /* error happened */ }

Can add more detail:

    type Error struct {
        error
        RequestID string
    }

    if err := f(); err != nil {
        if err, ok := err.(*Error); ok {
            log.Println(err.RequestID)
        }

        return err
    }

* Have fun!

[[https://gopherize.me][What kind of Gopher are you?]]