An Introduction To Programming In Go

Singapore Gophers Meetup - May 21, 2014

Transcript

1. can go oredi anot? singapore gophers meetup - 21 may 2014 an introduction to programming in go
2. peter jihoon kim @raingrove co-founder & cto, nitrous.io
3. what is go?
4. be an easier and safer alternative to C created by google, designed to go is a programming language
5. built-in support for concurrency no manual memory management (gc) string, slice, map, and function closures methods and interfaces for structs type safety. compiled to machine code
6. demo: hello world
7. package main ! import "fmt" ! func main() { fmt.Println("herro woll!”) }
8. variable declaration
9. var foo string var bar = "bar" baz := "baz" type inference
10. function declaration
11. func herro(name string) string { return "herro " + name } ! ! func Bai(name string) string { return "okthxbai " + name } private to this package exported (public)
12. func herro(name string) (h string) {
 h = "herro " + name return } named result
 parameters
13. herro := func(name string) string { return "herro " + name }
14. func herrobai(name string) (string, string) { herro := "herro " + name bai := "okthxbai " + name return herro, bai } ! h, b := herrobai("fren") _, b := herrobai("fren") multiple return values unused return value
15. slices
16. s := []string{"foo", "bar", "baz"} type of value
17. s := []string{"foo", "bar", "baz"} s[0] s[1] = "bear" ! len(s) "foo" 3
18. s = append(s, "qux", "quux") 
 t := []string{"satu", "dua"} s = append(s, t...) s := []string{"foo", "bar", "baz"} converts slice into
 arguments
19. s := [][]string{{"foo", "bar"},{"satu", "dua"}} []string is optional
20. s := [][]string{ {"foo", "bar"}, {"satu", "dua"}, } required
21. maps
22. m := map[string]int{"foo": 1, "bar":2} key value type of value type of key
23. m := map[string]int{"foo": 1, "bar":2} m["foo"] m["bar"] = 200 m["baz"] = 1337 ! len(m) 2 3
24. range
25. for i, v := range s { fmt.Println(i, v) } ! 0 foo 1 bar 2 baz s := []string{"foo", "bar", "baz"} index value
26. for k, v := range m { fmt.Println(k, v) } ! foo 1 bar 2 m := map[string]int{"foo": 1, "bar":2} key value
27. concurrency
28. go foo() invokes function in a goroutine* * a lightweight thread of execution that can run concurrently
29. sum := func(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum } ! a := [][]int{{1, 2, 3}, {4, 5, 6}} c := make(chan int) go sum(a[0], c) go sum(a[1], c) x, y := <-c, <-c fmt.Println(x+y) send result to channel* receive result from channel * a typed pipe through which goroutines can communicate
30. demo: sleep sort
31. package main ! import ( "fmt" "time" ) ! func main() { fmt.Println(sleepSort([]int{5, 3, 7, 10, 6, 1, 4, 2})) } ! func sleepSort(s []int) (sorted []int) { c := make(chan int) sorted = make([]int, len(s)) for _, v := range s { go func(n int) { time.Sleep(time.Duration(n) * time.Second) c <- n }(v) } for i := 0; i < len(s); i++ { sorted[i] = <-c } return }
32. structs
33. type Person struct { Name string Age int } exported
34. p := Person{Name: "Pete", Age: 28} ! q := &Person{Name: "Pete", Age: 28} “address of” type: Person type: *Person (pointer to Person)
35. p := Person{Name: "Pete", Age: 28} q := &Person{Name: "Pete", Age: 28} ! p2 := p ! q2 := q copies p points to *q
36. p := Person{Name: "Pete", Age: 28} q := &Person{Name: "Pete", Age: 28} ! p.Name q.Name p.Age = 18 q.Age = 18 "Pete"
37. methods
38. type Person struct { Name string Age int }
 func (this *Person) Greet() { fmt.Println(this.Name + " says hello!") } p := &Person{Name: "Pete", Age: 28} p.Greet() Pete says hello! method declaration method receiver
39. interfaces
40. type Triangle struct { Base float64 Height float64 } ! func (this *Triangle) Area() float64 { return 0.5 * this.Base * this.Height } ! type Rectangle struct { Width float64 Length float64 } ! func (this *Rectangle) Area() float64 { return this.Width * this.Length }
41. type Shape interface { Area() float64 } ! ! shapes := []Shape{ &Triangle{Base: 10.0, Height: 5.0}, &Rectangle{Width: 5.0, Length: 4.0}, } ! for _, shape := range shapes { fmt.Println(shape.Area()) } interfaces are satisfied
 implicitly
42. check out “a tour of go”: tour.golang.org create a free go box at www.nitrous.io where to go from here? topics not covered today: packages, testing, web development… attend future singapore gophers meetups
43. thanks & we’re hiring! www.nitrous.io/jobs