Goの全キーワードまとめ

## はじめに

Go 言語仕様で予約されているキーワード25個の一覧と、それぞれの説明および使用例を紹介します。
`goto`や`fallthrough`などは知らなかったので、良い機会になりました。
以下の語は Go 言語があらかじめ予約しているキーワードなので、変数名や関数名など自分で名前を付ける識別子には使えません。

https://go.dev/ref/spec#Keywords

## 一覧表

| キーワード       | 説明                                                       | 使用例                                                                                      |
|------------------|------------------------------------------------------------|---------------------------------------------------------------------------------------------|
| [`break`](#break)          | ループ (`for`) や `switch` から抜ける                        | `for i := 0; i < 10; i++ { if i == 5 { break } }`                                            |
| [`continue`](#continue)       | ループの次の反復へ飛ぶ                                      | `for i := 0; i < 5; i++ { if i%2 == 0 { continue } ; fmt.Println(i) }`                       |
| [`goto`](#goto)           | 任意のラベルへ無条件ジャンプ                                | `Label: fmt.Println("start"); goto Label`                                                   |
| [`fallthrough`](#fallthrough)    | `switch` の次の `case` を実行（Go はデフォルトでフォールスルーしない） | `switch n { case 1: fmt.Println(1); fallthrough; case 2: fmt.Println(2) }`                   |
| [`default`](#default)        | `switch`/`select` のどの `case` にも該当しない場合に実行      | `switch x { case 1: …; default: fmt.Println("no match") }`                                   |
| [`case`](#case)           | `switch`/`select` 内の各分岐条件                            | `switch day := "Sat"; day { case "Sat", "Sun": fmt.Println("Weekend") }`                     |
| [`if`](#if)             | 条件式に基づく分岐                                          | `if v := math.Sqrt(2); v > 1 { fmt.Println(v) }`                                            |
| [`else`](#else)           | `if` の条件が偽のときに実行                                 | `if x%2 == 0 { fmt.Println("even") } else { fmt.Println("odd") }`                            |
| [`for`](#for)            | Go の唯一のループ構造                                       | `for i := 0; i < 3; i++ { fmt.Println(i) }`                                                 |
| [`range`](#range)          | 配列・スライス・マップ・チャネルをイテレーション           | `for i, v := range []int{2, 3, 4} { fmt.Println(i, v) }`                                     |
| [`switch`](#switch)         | 値または条件に応じた多岐分岐                                 | `switch os := runtime.GOOS; os { case "linux": …; default: … }`                              |
| [`select`](#select)         | 複数チャネル操作を待ち、準備できたものをひとつ実行           | `select { case v := <-ch: fmt.Println(v); case ch <- 1: }`                                   |
| [`go`](#go)             | 新しいゴルーチンを起動                                      | `go doWork()`                                                                                |
| [`defer`](#defer)          | 関数終了時に呼び出しを遅延                                  | `defer file.Close()`                                                                        |
| [`import`](#import)         | 他パッケージをインポート                                    | `import "fmt"; import "math"`                                                               |
| [`package`](#package)        | ソースファイルの所属パッケージを宣言                        | `package main`                                                                              |
| [`func`](#func)           | 関数やメソッドを定義                                        | `func add(x, y int) int { return x + y }`                                                   |
| [`return`](#return)         | 関数から値を返し実行を終了                                  | `func swap(a, b string) (string, string) { return b, a }`                                   |
| [`var`](#var)            | 変数を宣言                                                  | `var x, y int = 1, 2; z := 3`                                                               |
| [`const`](#const)          | 定数を宣言（`iota` と組み合わせ可能）                       | `const Pi = 3.14; const ( A = iota; B; C )`                                                 |
| [`type`](#type)           | 新しい型（構造体・エイリアス・インターフェースなど）を定義 | `type MyInt = int; type User struct { Name string }`                                         |
| [`struct`](#struct)         | フィールドの集まりとして構造体を定義                        | `type Point struct { X, Y float64 }; p := Point{1, 2}`                                       |
| [`interface`](#interface)      | メソッド集合で型の振る舞いを定義                            | `type Shape interface { Area() float64 }`                                                   |
| [`map`](#map)            | キーと値のペアを持つハッシュマップ型                        | `m := make(map[string]int); m["ans"] = 42`                                                  |
| [`chan`](#chan)           | ゴルーチン間でデータをやり取りするチャネルを定義            | `ch := make(chan int); go func() { ch <- 3 }(); fmt.Println(<-ch)`                          |

## break  
- **説明**  
  ループ (`for`) や `switch` 文の実行を即座に終了し、次の文に制御を移します
  
- **使用例**  
  ```go
  for i := 0; i < 10; i++ {
      if i == 5 {
          break
      }
      fmt.Println(i)
  }
  // 出力: 0 1 2 3 4
  ```  

## continue 
- **説明**  
  ループの現在の反復処理をスキップし、次の反復処理に移ります
- **使用例**  
  ```go
  for i := 0; i < 5; i++ {
      if i%2 == 0 {
          continue
      }
      fmt.Println(i)
  }
  // 出力: 1 3
  ```  

## goto  
- **説明**  
  任意のラベルに無条件でジャンプします。可読性を損ないやすいため、使用は慎重に行います
- **使用例**  
  ```go
  i := 0
  Start:
      fmt.Println(i)
      i++
      if i < 3 {
          goto Start
      }
  // 出力: 0 1 2
  ```

## fallthrough  
- **説明**  
  `switch` 文で現在の `case` から次の `case` に制御を移します。Go ではデフォルトでフォールスルーしないため、明示的指定が必要です
- **使用例**  
  ```go
  switch 2 {
  case 1:
      fmt.Println("1")
  case 2:
      fmt.Println("2")
      fallthrough
  case 3:
      fmt.Println("3")
  }
  // 出力: 2 3
  ```

## default  
- **説明**  
  `switch` または `select` 文で、他の `case` にマッチしない場合に実行されるブロックを示します
- **使用例**  
  ```go
  switch x := 5; x {
  case 1:
      fmt.Println("1")
  default:
      fmt.Println("default")
  }
  // 出力: default
  ```
  
## case  
- **説明**  
  `switch`／`select` 文内での分岐条件を表します
- **使用例**  
  ```go
  switch day := "Sat"; day {
  case "Sat", "Sun":
      fmt.Println("Weekend")
  default:
      fmt.Println("Weekday")
  }
  // 出力: Weekend
  ```
  
## if  
- **説明**  
  条件式に基づきコードブロックを実行します。短いステートメントを先行させて変数スコープを限定可能です
- **使用例**  
  ```go
  if v := math.Sqrt(2); v > 1 {
      fmt.Println(v)
  }
  // 出力: 1.4142135623730951
  ```  

## else  
- **説明**  
  `if` の条件が偽の場合に実行されるブロックを示します 
- **使用例**  
  ```go
  if x%2 == 0 {
      fmt.Println("even")
  } else {
      fmt.Println("odd")
  }
  ```

## for  
- **説明**  
  Go の唯一のループ構造。従来の `for`、条件のみ、`range` 形式があります 
- **使用例**  
  ```go
  for i := 0; i < 3; i++ {
      fmt.Println(i)
  }
  // 出力: 0 1 2
  ```  

## range  
- **説明**  
  配列、スライス、マップ、チャネルをイテレーションします  ([The Go Programming Language Specification - The Go Programming Language](https://go.dev/ref/spec)).  
- **使用例**  
  ```go
  nums := []int{2, 3, 4}
  for i, num := range nums {
      fmt.Println(i, num)
  }
  // 出力: 0 2 1 3 2 4
  ```

## switch  
- **説明**  
  与えられた式の値によって複数分岐を行います。最初にマッチした `case` が実行されます  
- **使用例**  
  ```go
  switch os := runtime.GOOS; os {
  case "darwin":
      fmt.Println("OS X.")
  case "linux":
      fmt.Println("Linux.")
  default:
      fmt.Printf("%s.\n", os)
  }
  ```

## select  
- **説明**  
  複数チャネル操作を待ち受け、準備できたケースをランダムに1つ実行します
- **使用例**  
  ```go
  ch1 := make(chan int)
  ch2 := make(chan int)
  go func() { ch1 <- 1 }()
  select {
  case v := <-ch1:
      fmt.Println("Received", v)
  case ch2 <- 2:
      fmt.Println("Sent 2")
  }
  // ほとんどの場合: Received 1
  ```  

## go 
- **説明**  
  新しいゴルーチン（軽量スレッド）を起動します。並行実行を実現する基本手段です
- **使用例**  
  ```go
  go func() {
      fmt.Println("Hello from goroutine")
  }()
  fmt.Println("Hello from main")
  ```  

## defer  
- **説明**  
  関数終了時に指定した関数呼び出しを実行します。リソースの解放等で利用されます 
- **使用例**  
  ```go
  func main() {
      defer fmt.Println("world")
      fmt.Println("hello")
  }
  // 出力: hello world
  ```  

## import  
- **説明**  
  他パッケージを取り込み、利用可能にします
- **使用例**  
  ```go
  import (
      "fmt"
      "math"
  )
  ```

## package  
- **説明**  
  ソースファイルの所属パッケージを宣言します。`main` パッケージは実行可能バイナリを生成します
- **使用例**  
  ```go
  package main
  ```  

## func 
- **説明**  
  関数やメソッドを定義します。複数戻り値や名前付き戻り値をサポートします
- **使用例**  
  ```go
  func add(x, y int) int {
      return x + y
  }
  ```

## return 
- **説明**  
  関数から値を返し、実行を終了します。名前付き戻り値を使うと単に `return` だけで返せます  
- **使用例**  
  ```go
  func swap(x, y string) (a, b string) {
      a, b = y, x
      return
  }
  ```

## var  
- **説明**  
  変数を宣言します。複数変数の同時宣言や初期化が可能です
- **使用例**  
  ```go
  var i, j int = 1, 2
  ```

## const  
- **説明**  
  定数を宣言します。`iota` と組み合わせて列挙型のように使えます
- **使用例**  
  ```go
  const Pi = 3.14
  const (
      A = iota
      B
      C
  )
  ```

## type 
- **説明**  
  新しい型を定義します。構造体、インターフェース、エイリアス型などを作成可能です
- **使用例**  
  ```go
  type Vertex struct {
      X, Y float64
  }
  type MyInt = int
  ```

## struct
- **説明**  
  フィールドの集まりとして構造体を定義します。Go の基本データ構造です
- **使用例**  
  ```go
  type Vertex struct {
      X, Y float64
  }
  v := Vertex{X: 1, Y: 2}
  ```

## interface 
- **説明**  
  メソッドの集合で振る舞いを定義する型を作ります。実装は暗黙的に行われます 
- **使用例**  
  ```go
  type Shape interface {
      Area() float64
  }
  ```

## map
- **説明**  
  キーと値のペアを保持するハッシュマップ型を定義します
- **使用例**  
  ```go
  m := make(map[string]int)
  m["answer"] = 42
  ```

## chan
- **説明**  
  ゴルーチン間でデータをやり取りするチャネル型を定義します  
- **使用例**  
  ```go
  ch := make(chan int)
  go func() { ch <- 3 }()
  fmt.Println(<-ch)
  ```