社内で「Go言語を採用するかも?」というチームに向けて行った勉強会の資料です。

9. export GOPATH=$HOME/go
export PATH=$GOPATH/bin:$PATH
$GOPATH
├── bin
├── pkg
└── src
$ go install
$ go build

10. $GOPATH/src/github.com/nametake/myapp

17. ‐
‐
foo‐bar‐baz baz
_
_

18. ※
package main
import . "fmt"
func main() {
Println("period import")
}

19. $GOPATH

20. $GOPATH/src/github.com/user/myapp/main.go
package main
func main() {
~~~
}

21. myapp
$GOPATH/src/github.com/user/myapp/cmd/myapp/main.go
cmd/myapp‐batch

24. file, err := os.Open("file.go")
if err != nil {
return err
}

25. type ParseError struct {
Line, Col int
}
func (p ParseError) Error() string {
return fmt.Sprintf(`parse error on line %d,
column %d`, p.Line, p.Col)
}
switch err := err.(type) {
case ParseError:
PrintParseError(err)
}

26. file, err := os.Open("file.go")
if err != nil {
return err // ←
}

27. fmt.Errorf
file, err := os.Open("file.go")
if err != nil {
return fmt.Errorf(`failed file open
in foo: %s`, err)
}
:

28. file, err := os.Open("file.go")
if err != nil {
return errors.Wrap(`failed file open
in foo: %s`, err)
}
errors
fmt.Errorf
fmt.Errorf
errors.Cause(err)

31. func TestFoo(t *testing) {
// Foo
}

32. func TestSuccessFoo(t *testing) {
}
func TestFailedFoo(t *testing) {
}
func TestFailedFooAtBarData(t *testing) {
}
‐run

33. func Fib(n int) int {
if n < 2 {
return n
}
return Fib(n‐1) + Fib(n‐2)
}

34. var fibTests = []struct {
n int // input
expected int // expected result
}{
{1, 1},
{2, 1},
{3, 2},
{4, 3},
{5, 5},
{6, 8},
{7, 13},
}
func TestFib(t *testing.T) {
for _, tt := range fibTests {
actual := Fib(tt.n)
if actual != tt.expected {
t.Errorf("Fib(%d): expected %d, actual %d",
tt.n, tt.expected, actual)
}
}
}

35. _test _test
package foo package foo_test
‐race

38. type Talker interface {
Talk() string
}

41. ※

42. err := dbmap.Insert(user)
trans, _ := dbmap.Begin()
trans.Insert(user)
err := trans.Commit()

43. type updater interface {
Update(list ...interface{}) (int64, error)
}
func changeStatus(u updater, user *User) error {
if user.IsLogin {
user.Status = "active"
} else {
user.Status = "inactive"
}
row, err := u.Update(user)
if err != nil {
return err
}
return nil
}

44. type updater interface {
Update(list ...interface{}) (int64, error)
}

47. type User struct {
Name string
Age int
}

48. type UserID string
func (u *UserID) Valid() bool{
~~~ID ~~~
}
func User(id UserID) *User {
~~~User ~~~
}