hysryt commented 5 years ago

https://go-tour-jp.appspot.com http://go.shibu.jp/effective_go.html

hysryt commented 5 years ago

Docker でやる場合

docker-compose.yml

version: '3'
services:
  go:
    image: 'golang:latest'
    tty: true
    volumes:
      - './src:/go/src'

コンテナ起動

$ docker-compose up -d
$ docker-compose exec go /bin/bash

フォルダ構成

go/
 `- src/
     `- hello/
         `- hello.go

hello.go

package main

import "fmt"

func main() {
    fmt.Printf("hello, world\n")
}

コンパイル

$ cd /go/src/hello
$ go build
$ ./hello

コンテナ停止

$ docker-compose down

作成したバイナリファイルはコンテナ内でのみ実行できる。

hysryt commented 5 years ago

パッケージ
インポート
Exported Name は大文字で開始
関数は func で定義
```
func add(x int, y int) int {
return x + y
}
```
他の言語と違い、引数は 引数名型名 の順序で記述する。

引数の型が同じ場合は省略できる。

func add(x, y int) int {
  return x + y
}

関数は返り値を複数返すこともできる。


func swap(x, y string) (string, string) {
return y, x
}

func main() { a, b := swap("hello", "world") fmt.Println(a, b) }

- 返り値に名前をつけることもできる。
```go
func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return
}

変数の宣言には var を使う。型の指定が必須。
```
var c, python, java bool
```

func main() { var i int fmt.Println(i, c, python, java) }

引数と同じように型を省略できるので、上の例では `c`、`python`、`java` の3つが `bool` 型となる。

宣言と同時に初期化も可能。初期化子を与える場合は型はなくても良い。
```go
var i, j int = 1, 2

i には 1、j には 2 が代入される。

関数の中では変数の宣言を := で省略できる。

func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"

fmt.Println(i, j, k, c, python, java)
}

型は以下の通り
```
bool
```

string

int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 の別名

rune // int32 の別名 // Unicode のコードポイントを表す

float32 float64

complex64 complex128


- 変数の宣言はまとめることも可能
```go
var (
  ToBe   bool       = false
  MaxInt uint64     = 1<<64 - 1
  z      complex128 = cmplx.Sqrt(-5 + 12i)
)

変数に初期化子を与えない場合、ゼロ値が与えられる。ゼロ値とは、数値型の場合は 0、真偽値型の場合は false、文字列型の場合は空文字。

型の変換

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

定数は const で宣言
```
const Pi = 3.14
```

hysryt commented 5 years ago

for 文

sum := 0
for i := 0; i < 10; i++ {
  sum += i
}
fmt.Println(sum)

for 文の初期化ステートメントには var は使用できない。

Go では while 文も for 文で記述する。

sum := 0
for sum < 1000 {
sum += sum
}
fmt.Println(sum)

for {
// 無限ループ
}

if 文

x := 0
if x > 10 {
  fmt.Println("10よりでかい")
} else {
  fmt.Println("10以下")
}

for 文のような初期化ステートメントを使用できる。
```
if x := 0; x > 10 {
fmt.Println("10よりでかい")
}
```

switch 文

switch os := runtime.GOOS; os {
case "darwin":
  fmt.Println("OS X.")
case "linux":
  fmt.Println("Linux.")
default:
  // freebsd, openbsd,
  // plan9, windows...
  fmt.Printf("%s.", os)
}

break は不要

case に式を書くことも可能。

x := 1
switch {
case x > 10:
fmt.Println("10より大きい")
case x < 10:
fmt.Println("10より小さい")
case x == 10:
fmt.Println("10と同じ")
}

hysryt commented 5 years ago

defer 文

ある関数内で defer を指定した場合、その関数が終わるまで defer を指定した処理を延期する。

func main() {
defer fmt.Println("world")  // これを main() が終わるまで延期
fmt.Println("hello, ")
}

hello,
world

defer を複数回使用した場合、処理はスタックされる。
```
for i := 0; i < 3; i++ {
defer fmt.Println(i)
}
```
```
2
1
0
```

hysryt commented 5 years ago

ポインタ

var p *int

var p *int
var i int
fmt.Println(&i)  // 変数 i のポインタを取得する
p = &i           // ポインタ p に 変数 i のポインタを代入
*p = 10          // ポインタ p を介して変数 i に代入
fmt.Println(*p)  // ポインタ p の値を読み出す

ポインタ演算は存在しない

hysryt commented 5 years ago

構造体

type Vertex struct {
  X int
  Y int
}

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

構造体のポインタからフィールドへアクセスする場合は2通り方法がある
```
v := Vertex{1,2}
p := &v
fmt.Println((*p).X) // 下と同じ
fmt.Println(p.X)
```

hysryt / wiki

Go #107

Docker でやる場合