Go cheatsheet

Variable declaration

var msg string var msg = "Hello, world!" var msg string = "Hello, world!" var x, y int var x, y int = 1, 2 var x, msg = 1, "Hello, world!" msg = "Hello" 

Declaration list

var ( x int y = 20 z int = 30 d, e = 40, "Hello" f, g string ) 

Shortcut of above (Infers type)

msg := "Hello" x, msg := 1, "Hello" 

const Phi = 1.618 const Size int64 = 1024 const x, y = 1, 2 const ( Pi = 3.14 E = 2.718 ) const ( Sunday = iota Monday Tuesday Wednesday Thursday Friday Saturday ) 

Constants can be character, string, boolean, or numeric values.

See: Constants

str := "Hello" 

str := `Multiline string` 

Strings are of type string.

Typical types

num := 3 // int num := 3. // float64 num := 3 + 4i // complex128 num := byte('a') // byte (alias for uint8) 

Other types

var u uint = 7 // uint (unsigned) var p float32 = 22.7 // 32-bit float 

// var numbers [5]int numbers := [...]int{0, 0, 0, 0, 0} 

Arrays have a fixed size.

slice := []int{2, 3, 4} 

slice := []byte("Hello") 

Slices have a dynamic size, unlike arrays.

func main () { b := *getPointer() fmt.Println("Value is", b) } 

func getPointer () (myPointer *int) { a := 234 return &a } 

a := new(int) *a = 234 

Pointers point to a memory location of a variable. Go is fully garbage-collected.

See: Pointers

i := 2 f := float64(i) u := uint(i) 

See: Type conversions

if day == "sunday" || day == "saturday" { rest() } else if day == "monday" && isTired() { groan() } else { work() } 

See: If

if _, err := doThing(); err != nil { fmt.Println("Uh oh") } 

A condition in an if statement can be preceded with a statement before a ;. Variables declared by the statement are only in scope until the end of the if.

See: If with a short statement

switch day { case "sunday": // cases don't "fall through" by default! fallthrough case "saturday": rest() default: work() } 

See: Switch

for count := 0; count <= 10; count++ { fmt.Println("My counter is at", count) } 

See: For loops

entry := []string{"Jack","John","Jones"} for i, val := range entry { fmt.Printf("At position %d, the character %s is present\n", i, val) } 

See: For-Range loops

n := 0 x := 42 for n != x { n := guess() } 

See: Go’s “while”

myfunc := func() bool { return x > 10000 } 

Functions are first class objects.

a, b := getMessage() 

func getMessage() (a string, b string) { return "Hello", "World" } 

func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return } 

By defining the return value names in the signature, a return (no args) will return variables with those names.

See: Named return values

import "fmt" import "math/rand" 

import ( "fmt" // gives fmt.Println "math/rand" // gives rand.Intn ) 

Both are the same.

See: Importing

import r "math/rand" 

r.Intn() 

func Hello () { ··· } 

Exported names begin with capital letters.

See: Exported names

package hello 

Every package file has to start with package.

func main() { // A "channel" ch := make(chan string) // Start concurrent routines go push("Moe", ch) go push("Larry", ch) go push("Curly", ch) // Read 3 results // (Since our goroutines are concurrent, // the order isn't guaranteed!) fmt.Println(<-ch, <-ch, <-ch) } 

func push(name string, ch chan string) { msg := "Hey, " + name ch <- msg } 

Channels are concurrency-safe communication objects, used in goroutines.

See: Goroutines, Channels

ch := make(chan int, 2) ch <- 1 ch <- 2 ch <- 3 // fatal error: // all goroutines are asleep - deadlock! 

Buffered channels limit the amount of messages it can keep.

See: Buffered channels

Closes a channel

ch <- 1 ch <- 2 ch <- 3 close(ch) 

Iterates across a channel until its closed

for i := range ch { ··· } 

Closed if ok == false

v, ok := <- ch 

See: Range and close

import "sync" func main() { var wg sync.WaitGroup for _, item := range itemList { // Increment WaitGroup Counter wg.Add(1) go doOperation(&wg, item) } // Wait for goroutines to finish wg.Wait() } 

func doOperation(wg *sync.WaitGroup, item string) { defer wg.Done() // do operation on item // ... } 

A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. The goroutine calls wg.Done() when it finishes. See: WaitGroup

type Vertex struct { X int Y int } 

func main() { v := Vertex{1, 2} v.X = 4 fmt.Println(v.X, v.Y) } 

See: Structs

v := Vertex{X: 1, Y: 2} 

// Field names can be omitted v := Vertex{1, 2} 

// Y is implicit v := Vertex{X: 1} 

You can also put field names.

v := &Vertex{1, 2} v.X = 2 

Doing v.X is the same as doing (*v).X, when v is a pointer.