G

AN

DO
GOL

JO
BUILT-IN TYPES SWITCH
bool, string, weapon := "Ninja Star"

switch weapon {
Cheat Sheet
int, int8, int16, int32, int64,
[ every golang ninja's secret weapon ]
uint, uint8, uint16, uint32, uint64, uintptr, case "Ninja Star":

rune, byte, fmt.Println("It’s a Ninja Star!")

float32, float64, case "Ninja Sword":

complex64, complex128 fmt.Println("It’s a Ninja Sword!")

VARIABLES
powerLevel := 9001

switch {

var ninja = "Johnny" case powerLevel > 9000:

var level, yoe int = 1, 2 fmt.Println("It’s over...NINE THOUSAND!!!")

var isSkilled bool default:

weapon := "Ninja Star" fmt.Println("It’s a Baby Ninja")

fmt.Println(ninja, level, yoe, isSkilled, weapon)

// Johnny 1 2 false Ninja Star

ARRAYS
// an array is a numbered sequence

CONSTANTS // of elements of a specific length

var evilNinjas [3]string

const dojo string = "Golang Dojo"
fmt.Println(len(evilNinjas))
const powerLevel = 9001

evilNinjas[0] = "Johnny"
const opLevel = 3e20
fmt.Println(evilNinjas)
// a numeric constant has no type
fmt.Println(evilNinjas[0])
// until it's given one
fmt.Println(len(evilNinjas))
fmt.Printf("%T\n", opLevel)

moreEvilNinjas := [3]string{"Andy", "Tommy", "Bobby"}

fmt.Println(moreEvilNinjas)

LOOPS
var missionRewards [2][3]int
isSkilled := true
for i := 0; i < 2; i++ {
for isSkilled {
for j := 0; j < 3; j++ {
fmt.Println("Ready for mission!")
missionRewards[i][j] = i + j
isSkilled = false
}
}
}

for level := 7; level < 9; level++ {

SLICES
fmt.Println(level)

fmt.Println("Leveling up!")

} // a slice, on the other hand, doesn’t need

// to be given a specific length

for { var evilNinjas []string

fmt.Println("I’m a Golang Ninja") fmt.Println(len(evilNinjas))

break evilNinjas = append(evilNinjas, "Tommy")

} fmt.Println(len(evilNinjas))
 G
AN

DO
MAPS STRUCTS

GOL

JO
// to create an empty map, use the built-in make type ninja struct {

Cheat Sheet
ninjaLevels := make(map[string]int) name string

ninjaLevels["Johnny"] = 7 level int

ninjaLevels["Tommy"] = 13 } [ every golang ninja's secret weapon ]

fmt.Println(ninjaLevels)

fmt.Println(len(ninjaLevels)) func main() {

fmt.Println(len(ninjaLevels)) fmt.Println(ninja{name: "Bobby", level: 20})

delete(ninjaLevels, "Johnny")

fmt.Println(len(ninjaLevels)) fmt.Println(ninja{name: "Andy", level: 30})

// the optional second return value when getting // omitted fields will be zero-valued

// a value from a map indicates if the key was fmt.Println(ninja{name: "Johnny"})

// present in the map

_, ok := ninjaLevels["Tommy"] tommy := ninja{name: "Tommy", level: 50}

fmt.Println(ok) fmt.Println(tommy.level)

// another option of initializing maps tommy.level = 51

moreNinjaLevels := map[string]int{"Bobby": 8, "Andy": 3} }

fmt.Println(moreNinjaLevels)

INTERFACE
type ninjaWeapon interface{

RANGE attack()

}
evilNinjas:= []string{"Tommy", "Johnny", "Andy"}

for index, evilNinja := range evilNinjas{

type ninjaStar struct{}
fmt.Println("Attacking target", index, evilNinja)

}
func(n ninjaStar) attack() {

fmt.Println("Throwing Ninja Star")

evilNinjasWithLevels:= map[string]int{"Tommy": 2}
}
for evilNinja, level := range evilNinjasWithLevels {

fmt.Printf("%s -> %d\n", evilNinja, level)

type ninjaSword struct{}
}

func(n ninjaSword) attack() {

POINTERS
fmt.Println("Throwing Ninja Sword")

type ninja struct {

name string func main() {

} weapons := []ninjaWeapon{

ninjaStar{},

func main() { ninjaSword{},

tommy := ninja{"Tommy"} }

tommyPointer := &tommy for _, weapon := range weapons {

johnnyPointer := &ninja{"Johnny"} weapon.attack()

var ninjaPointer *ninja = new(ninja) }

} }
 G
AN

DO
GOL

JO
Cheat Sheet
FUNCTIONS [ every golang ninja's secret weapon ]

func useWeapon(ninja string, weapon string) string {

return fmt.Sprintf(ninja + "is using " + weapon)

GOROUTINES
}
func attack(target string) {

fmt.Println("Throwing ninja stars at", target)

// multiple return values
}
func isValidLevel(level int) (int, bool) {

if level > 10 {
func main() {
return level, true
go attack("Tommy")
}
time.Sleep(time.Second)
return level, false
}
}

// variadic functions

CHANNELS
func attack(evilNinjas ...string) {

for _, evilNinja:= range evilNinjas{

fmt.Println("Attacking target", evilNinja) func attack(target string, attacked chan bool) {

} time.Sleep(time.Second)

} fmt.Println("Throwing ninja stars at", target)

attacked <- true

func main() { }

usage := useWeapon("Tommy", "Ninja Star")

level, valid := isValidLevel(11) func main() {

smokeSignal := make(chan bool)

fmt.Println(usage, level, valid) evilNinja := "Tommy"

go attack(evilNinja, smokeSignal)

attack("Tommy", "Johnny") fmt.Println(<-smokeSignal)

attack("Tommy", "Johnny", "Andy", "Bobby")

// buffered channels

// if you already have multiple args in a slice, moreSmokeSignal := make(chan bool, 1)

// apply them to a variadic function moreSmokeSignal <- true

// using func(slice...) fmt.Println(<-moreSmokeSignal)

evilNinjas:= []string{"Tommy", "Johnny", "Andy"}

attack(evilNinjas...) // closing channel to prevent deadlocks

moreSmokeSignal <- true

// closures close(moreSmokeSignal)

attackToo := attack for message := range moreSmokeSignal {

attackToo(evilNinjas...) fmt.Println(message)

func() { }

fmt.Println("Attacking Evil Ninjas...") }

}()

FOLLOW US
weekly golang tutorial for beginners

www.golangdojo.com
Golang Dojo