Go 入門

Go(別名 Golang)は Google が開発したオープンソースのプログラミング言語です。設計目標は、開発者がシンプルで信頼性が高く高性能なソフトウェアを効率的に構築できるようにすることです。

Go 言語は2007年に誕生し、Google の3人のシニアエンジニアである Robert Griesemer、Rob Pike、Ken Thompson によって共同設計され、2009年に正式にオープンソースとして公開されました。

Go の設計当初の目的は、Google 内部で直面していた大規模ソフトウェア開発の課題を解決することでした。C++ はコンパイルが遅すぎる、Java はランタイムが大きすぎる、スクリプト言語は性能が不十分、といった問題です。3人の設計者は、以下の両方を兼ね備えたプログラミング言語の創造を望んでいました。コンパイル型言語の性能と動的言語の開発効率を持つプログラミング言語です。

Go 言語のマスコットは Gopher という名前のホリネズミで、Go コミュニティの実用主義と活力を象徴しています。

Go 言語の重要な設計目標は以下のようにまとめられます。

設計目標説明
コンパイル速度大規模プロジェクトのコンパイルは数分ではなく数秒で完了する必要がある
並行処理サポート言語レベルで並行プログラミングをネイティブにサポートし、サードパーティ製ライブラリが不要
簡潔さ構文を最小限にし、クラスや継承をなくして認知的負荷を軽減
メモリ安全性自動ガベージコレクション(GC)により、手動メモリ管理のリスクを回避
静的型付けコンパイル時の型チェックで実行時エラーを削減
クロスプラットフォーム1つのコードから Windows、Linux、macOS など複数プラットフォームの実行可能ファイルをコンパイルできる

Go 誕生が解決しようとした3つの核心的な問題

問題従来言語の苦境Go の解決方法
コンパイルが遅い大規模な C++ プロジェクトではコンパイルに数分から数時間かかることがしばしばある依存関係管理の設計が極めて簡素で、コンパイル速度が非常に速く、通常数秒で完了
並行プログラミングが複雑スレッド、ロック、コールバックの組み合わせにより、並行コードの作成と保守が困難goroutine と channel を内蔵し、並行処理が順次コードを書くように行える
コードが保守しにくいC++ は機能が多すぎ、Java は過剰設計で、大規模チームでの協業が困難極めてシンプルな構文、強制フォーマット、1つの問題には1つの書き方しかない

Go の核心的な設計哲学

Go の公式スローガンは次の通りですSimple, Fast, Reliableこの3つの言葉が、Go のすべての設計上のトレードオフを要約しています。

Go は言語仕様の簡素さを意図的に保っています。言語仕様全体はわずか約60ページで、キーワードは25個しかありません(対照的に C++ には80以上のキーワードがあります)。つまり、経験豊富な開発者なら1〜2日で構文の全体像を把握でき、その後はビジネスロジックに集中できます。


Go 言語の発展の歴史

Go 言語の発展の過程は一朝一夕には成し遂げられたものではありません。以下に、プロジェクト開始から現在までの重要なマイルストーンを整理します。

時期バージョン/出来事説明
2007年プロジェクト開始Rob Pike、Ken Thompson、Robert Griesemer が Go 言語の設計を開始
2009年11月Go が初めてオープンソース化BSD ライセンスで GitHub 上に公開
2012年3月Go 1.0最初の安定版がリリースされ、後方互換性が約束される
2015年8月Go 1.5コンパイラが Go で自己ホスティングされる(以前は C で記述)、C への依存を除去
2018年8月Go 1.11Go Modules を導入し、依存関係管理の問題を初歩のに解決する
2020年2月Go 1.14Go Modules が公式推奨の依存関係管理方法となる
2022年3月Go 1.18ジェネリクス(Generics)を導入。これは Go のリリース以来最大の言語機能の変更です
2024年2月Go 1.22for ループ変数のセマンティクス最適化、ルーティングパターンマッチングの強化
2025年8月Go 1.24ランタイム性能、ツールチェーン体験、標準ライブラリを継続的に改善するするする

Go 1.0 のリリース時に、コアチームは重要な約束をしました。それは、後続のすべての 1.x バージョンの Go が後方互換性を維持するというものです。つまり、10年前に書かれた Go コードでも、今日の最新コンパイラでそのままコンパイルして実行できることを意味します。


Go 言語の核心的な特徴

Go の設計哲学がその機能群を決定づけています——簡潔でありながら強力です。以下で Go の最も核となる言語機能を一つずつ解説します。

ネイティブ並行処理: Goroutine と Channel

並行処理は Go 言語で最も注目すべき特徴です。Goroutineこれはオペレーティングシステムのスレッドよりはるかに軽量な実行単位です——各 Goroutine の初期スタックサイズはわずか約2KB しかなく、OS スレッドは通常1MB 以上です。

通常のマシン上で数十万個の Goroutine を同時に実行することができます。これは従来のスレッドモデルでは不可能なことです。

Channel(チャネル)は、Goroutine 間の通信パイプであり、Go の並行処理哲学に従っています:

共有メモリで通信するのではなく、通信でメモリを共有しなさい。(Don't communicate by sharing memory; share memory by communicating.)

シンプルな Goroutine と Channel の例:

例

package main

import (
    "fmt"
    "time"
)

// worker は作業用コルーチンを模擬し、チャネルからタスクを受信して処理する
func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d はタスク %d の処理を開始します\n", id, j)
        time.Sleep(time.Second) // 時間のかかる操作を模擬
        results <- j * 2        // 処理結果を results チャネルに送信
        fmt.Printf("worker %d はタスク %d を完了しました\n", id, j)
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)    // バッファ付きタスクチャネルを作成
    results := make(chan int, numJobs) // バッファ付き結果チャネルを作成

    // 3つの worker goroutine を起動
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 5つのタスクを jobs チャネルに送信
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs) // チャネルを閉じて、新たなタスクがないことを worker に通知

    // すべての処理結果を収集
    for a := 1; a <= numJobs; a++ {
        fmt.Printf("結果: %d\n", <-results)
    }
}

静的型付けと型推論

Go は静的型付け言語であり、すべての変数の型はコンパイル時に決定されます。しかし C/Java とは異なり、Go は以下をサポートしています。型推論——コンパイラが変数の型を自動的に推論できるため、開発者は何度も型名を宣言する必要がありません。

この設計は型安全性を保ちながら、コードを動的言語のように簡潔に書けるようにします。

例

package main

import "fmt"

func main() {
    // 完全な宣言: 型を明示的に指定
    var name string = "サンプル"

    // 型推論: コンパイラが型を自動的に推論
    var version = 1.24      // float64 と推論される
    count := 100            // 短変数宣言、int と推論される
    message := "Hello Go"   // string と推論される

    // 複数変数の宣言
    x, y := 10, 20          // 複数の変数を同時に宣言

    fmt.Println(name, version, count, message, x, y)
}

高速コンパイル

Goのコンパイル速度は非常に速く、大規模プロジェクト(数十万行のコード)でも数秒でコンパイルを完了できます。

これは、Goが設計した依存関係分析メカニズムによるものです。実際に参照されるパッケージのみをコンパイルし、C/C++におけるヘッダーファイルの重複解析のオーバーヘッドを排除しています。

組み込みガベージコレクション(GC)

Goは並行三色マーク・スイープアルゴリズム自動ガベージコレクションを実現します。GCはユーザーコードと並行して実行され、停止時間は通常マイクロ秒レベルであり、サービスの応答時間に顕著な影響を与えません。

開発者はメモリを手動で管理する必要がなく、同時にC言語に近いランタイムパフォーマンスを得られます。

充実した標準ライブラリ

Goの標準ライブラリは、現代の開発におけるほとんどのニーズをカバーしており、サードパーティの依存関係を導入しなくても一般的なタスクを完了できます。次の表に、最もよく使われる標準ライブラリパッケージを示します:

パッケージ名機能典型的な用途
net/httpHTTPクライアントとサーバーWebサービス、RESTful APIの構築
encoding/jsonJSONエンコード/デコードAPIデータのシリアライズとデシリアライズ
database/sqlデータベースアクセスインターフェースドライバと組み合わせてMySQL、PostgreSQLなどを操作
osオペレーティングシステムとの連携ファイル読み書き、環境変数、プロセス管理
fmtフォーマット済み入出力ログ出力、文字列のフォーマット
sync同期プリミティブMutex、WaitGroup、Onceなどの並行制御
testingテストフレームワークユニットテスト、ベンチマークテスト、サンプルテスト
time時刻処理タイマー、定期実行、時刻のフォーマット
contextコンテキスト伝達タイムアウト制御、リクエストキャンセル、値の受け渡し
ioI/O抽象化統一された読み書きインターフェース
crypto暗号化アルゴリズムハッシュ、対称/非対称暗号化、TLS
flagコマンドライン引数の解析CLIツール開発

クロスプラットフォームコンパイル

Goコンパイラはクロスコンパイルをサポートしており、任意のプラットフォームで他のターゲットプラットフォーム向けの実行可能ファイルをコンパイルできます。設定するだけでGOOSとGOARCH2つの環境変数だけで十分です。

# 在 macOS 上编译 Linux 可执行文件
$ GOOS=linux GOARCH=amd64 go build -o app-linux main.go

# 在 Linux 上编译 Windows 可执行文件
$ GOOS=windows GOARCH=amd64 go build -o app.exe main.go

コンパイル成果物は独立したバイナリファイルであり、ターゲットマシンにGoランタイムや依存関係をインストールする必要はなく、直接実行できます。


Go 言語の応用分野

Goは、高性能、デプロイの容易さ、ネイティブ並行処理という利点により、以下の分野で広く採用されています。

クラウドネイティブとインフラストラクチャ

Goは現代のクラウドネイティブ技術スタックの事実上の標準言語です。ほぼすべての有名なクラウドネイティブプロジェクトはGoで書かれています。

プロジェクト説明所属分野
Dockerコンテナ化プラットフォームであり、ソフトウェアの提供方法を変えましたコンテナ
Kubernetes (K8s)コンテナオーケストレーションシステムであり、クラウドネイティブの事実上の標準コンテナオーケストレーション
etcd分散キーバリューストアであり、K8sのコアコンポーネント分散ストレージ
Prometheus監視およびアラートシステム可観測性
Grafanaデータ可視化プラットフォーム(バックエンド)可観測性
Terraformインフラストラクチャ・アズ・コード(IaC)ツールDevOps
Consulサービスディスカバリと設定管理サービスメッシュ
Traefikクラウドネイティブリバースプロキシとロードバランサーネットワーク

マイクロサービスと API 開発

Goは非常に低いメモリ使用量と優れた並行処理能力により、マイクロサービス構築の理想的な選択肢となっています。単純なHTTPサービスは数MBのメモリだけで実行できます。

一般的なGo WebフレームワークにはGin、Echo、Fiberなどがあり、これらはパフォーマンスベンチマークテストにおいて、他の言語の同種フレームワークを大幅にリードすることがよくあります。

CLI ツール開発

Goが単一のバイナリファイルにコンパイルされる特性により、CLIツール開発の第一選択肢となっています。ユーザーはランタイムをインストールする必要がなく、1つのファイルをダウンロードするだけで使用できます。

有名なプロジェクトには以下があります:Hugo(静的サイトジェネレーター)、fzf(ファジー検索ツール)、gh(GitHub CLI)とkubectl(Kubernetesコマンドラインツール)。

ネットワークプログラミングと分散システム

Go標準ライブラリのnetパッケージは完全なネットワークプログラミングサポートを提供し、goroutineモデルは高並行ネットワークサービス(プロキシサーバー、メッセージキュー、ゲームサーバーなど)に自然に適合します。gRPCフレームワークのGo実装も、分散システムにおけるサービス間通信の主流の選択肢です。

ブロックチェーン

Goはブロックチェーン分野でも重要な応用があります。go-ethereum(Geth)はイーサリアムで最も主流のクライアント実装であり、Hyperledger FabricのコアコンポーネントもGoで書かれています。

AI と機械学習(新興分野)

Pythonは依然としてAI/ML分野の主要言語ですが、Goも徐々にこの分野に参入しています。Ollama(ローカル大規模モデル実行ツール)とLangChainGoなどのプロジェクトの台頭は、AIインフラストラクチャとLLMアプリケーション開発におけるGoの可能性を示しています。


クイックスタート

ゼロからGo開発環境を構築するには、インストール、設定、コード作成の3ステップだけです。

Go のインストール

アクセスgo.dev/dl対応するプラットフォームのインストールパッケージをダウンロードします。macOSユーザーはHomebrewでもインストールできます。

# macOS (Homebrew)
$ brew install go

# 验证安装
$ go version
go version go1.24.0 darwin/arm64

最初の Go プログラム

プロジェクトディレクトリを作成し、定番のHello Worldプログラムを書きます。

例

// ファイルパス: main.go
// すべてのGoプログラムはパッケージに属する必要があり、mainパッケージは実行可能プログラムのエントリポイントです

package main

// フォーマット出力用の標準ライブラリパッケージをインポート
import "fmt"

// main関数: プログラムのエントリポイント、引数なし、戻り値なし
func main() {
    // Printlnは1行の内容を出力し、末尾に自動的に改行を追加します
    fmt.Println("Hello, サンプル!")
    fmt.Println("Go言語の世界へようこそ")
}

実行方法は2つあります:直接実行(バイナリファイルを生成しない)またはコンパイル後に実行。

# 方式一:直接运行(开发调试时常用)
$ go run main.go
Hello, サンプル!
欢迎来到 Go 语言的世界

# 方式二:编译为二进制文件后执行(生产部署时常用)
$ go build -o hello main.go
$ ./hello
Hello, サンプル!
欢迎来到 Go 语言的世界

Go Modules の初期化

正式なプロジェクトでは、Go Modulesを使用して依存関係を管理することをお勧めします。モジュール名は通常、リポジトリのパス(GitHubアドレスなど)を使用して、他の人が参照しやすくします。

# 初始化 Go Module
$ mkdir my-go-project && cd my-go-project
$ go mod init github.com/サンプル/my-go-project
go: creating new go.mod: module github.com/サンプル/my-go-project

# go.mod 文件内容
module github.com/サンプル/my-go-project

go 1.24

基本構文の概要

Goの構文は簡潔で一貫性があります。以下に、最もよく使われる構文要素を簡単に紹介します。各例は直接実行できる完全なプログラムです。

変数と定数

Goはさまざまな変数宣言方法を提供し、異なるシーンに対応します。定数はconstキーワードで宣言します。

例

package main

import "fmt"

func main() {
    // 方法1: 標準宣言(明示的な型)
    var age int = 25

    // 方法2: 宣言後の代入(型は宣言時に指定)
    var score float64
    score = 98.5

    // 方法3: 短変数宣言(最も一般的、関数内のみ)
    name := "サンプル"

    // 方法4: 複数変数の同時宣言
    x, y := 10, 20

    // 定数宣言(コンパイル時に確定、変更不可)
    const Pi = 3.14159
    const AppName = "サンプル"

    fmt.Println(name, age, score, x, y, Pi, AppName)
}

制御フロー

Goの制御フローはif、forとswitch3つに簡素化されています。Goにはwhileキーワードがなく、すべてのループはforを使用して実装されます。

例

package main

import "fmt"

func main() {
    // if文: 条件式には括弧は不要ですが、中括弧は必須です
    score := 85
    if score >= 90 {
        fmt.Println("サンプル 評価: A")
    } else if score >= 60 {
        fmt.Println("サンプル 評価: B")
    } else {
        fmt.Println("サンプル 評価: C")
    }

    // forループ1: 標準の3要素形式(Cのforに類似)
    fmt.Print("カウント: ")
    for i := 0; i < 5; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()

    // forループ2: 条件のみ(whileに類似)
    sum := 0
    n := 1
    for n <= 10 {
        sum += n
        n++
    }
    fmt.Println("1から10の合計:", sum)

    // forループ3: rangeによる反復(最も一般的)
    fruits := []string{"apple", "banana", "cherry"}
    for index, fruit := range fruits {
        fmt.Printf("インデックス %d: %s"\n", index, fruit)
    }

    // switch文: 各caseは自動的にbreakされるため、手動で追加する必要はありません
    day := "月曜日"
    switch day {
    case "月曜日":
        fmt.Println("新しい一週間が始まりました")
    case "金曜日":
        fmt.Println("週末が近づいています")
    default:
        fmt.Println("普通の一日")
    }
}

関数

Goの関数の使用funcキーワード宣言、サポート複数の戻り値——これは Go のエラー処理メカニズムの基礎です。

例

package main

import (
    "errors"
    "fmt"
)

// add 関数: 2つの引数は両方とも int 型で、1つの int を返します
func add(a, b int) int {
    return a + b
}

// divide 関数: 結果とエラーの2つの値を返します
// Go 慣用の (result, error) パターンでエラー処理を行います
func divide(a, b float64) (float64, error) {
    if b == 0 {
        // ゼロ値とカスタムエラーを返します
        return 0, errors.New("除数はゼロにできません")
    }
    return a / b, nil // nil はエラーがないことを示します
}

// swap 関数: 複数の戻り値を使用して複数の計算結果を返します
func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    // 通常の関数を呼び出します
    sum := add(10, 20)
    fmt.Println("10 + 20 =", sum)

    // 複数の戻り値を持つ関数を呼び出し、エラーをチェックします
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("エラー:", err)
    } else {
        fmt.Println("10 / 2 =", result)
    }

    // ゼロ除算のケースをテストします
    _, err = divide(10, 0) // _ を使用して不要な戻り値を無視します
    if err != nil {
        fmt.Println("ゼロ除算エラー:", err) // このエラーが出力されることを期待しています
    }

    // 複数の戻り値で交換します
    first, second := swap("サンプル", "Hello")
    fmt.Println("交換後:", first, second)
}

Go には try-catch 例外メカニズムはなく、関数が error 値を返すことでエラーを明示的に処理します。この設計によりエラー処理の経路が一目瞭然となり、暗黙的な制御フローを避けられます。

構造体とメソッド

Go にはクラスの概念がなく、struct(構造体)でデータを整理し、型にメソッドを定義することでオブジェクト指向スタイルの振る舞いを実現します。メソッドはレシーバー(receiver)を持つ関数です。

例

package main

import "fmt"

// User はユーザー構造体を定義します(他の言語のクラスに似ています)
type User struct {
    Name  string // 先頭大文字 = 公開フィールド(外部パッケージからアクセス可能)
    Email string
    age   int    // 先頭小文字 = プライベートフィールド(パッケージ内のみアクセス可能)
}

// Greet は User 型に定義されたメソッドです
// (u User) は値レシーバーであり、メソッド内で u を変更しても元の値には影響しません
func (u User) Greet() string {
    return fmt.Sprintf("こんにちは、私は %s です。メールアドレスは %s です", u.Name, u.Email)
}

// Birthday はポインタレシーバーを使用するため、メソッド内で元の値を変更できます
func (u *User) Birthday() {
    u.age++ // ポインタを通じて元の構造体の age フィールドを直接変更します
}

func main() {
    // 構造体インスタンスを作成します
    user := User{
        Name:  "サンプル",
        Email: "サンプル@example.com",
        age:   25,
    }

    // メソッドを呼び出します
    fmt.Println(user.Greet())
    fmt.Printf("誕生日前の年齢: %d\n", user.age)

    user.Birthday() // ポインタレシーバーを使用するため、age が変更されます
    fmt.Printf("誕生日後の年齢: %d\n", user.age)
}

インターフェース

Go のインターフェースは暗黙的な実装です。ある型がインターフェース内のすべてのメソッドを実装していれば、明示的に implements を宣言しなくても自動的にそのインターフェースを満たします。この設計により、コードの結合度が大幅に低減されます。

例

package main

import (
    "fmt"
    "math"
)

// Shape インターフェース: 幾何学的形状の振る舞いの仕様を定義します
type Shape interface {
    Area() float64      // 面積を計算します
    Perimeter() float64 // 周囲の長さを計算します
}

// Circle 円形構造体
type Circle struct {
    Radius float64
}

// Circle は Shape インターフェースを実装します(暗黙的な実装であり、明示的な宣言は不要です)
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// Rectangle 矩形構造体
type Rectangle struct {
    Width, Height float64
}

// Rectangle も暗黙的に Shape インターフェースを実装します
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// PrintShape は Shape インターフェースを実装した任意の型を受け取ります
func PrintShape(s Shape) {
    fmt.Printf("面積: %.2f、周囲の長さ: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    c := Circle{Radius: 5}          // 半径5の円
    r := Rectangle{Width: 4, Height: 6} // 幅4、高さ6の矩形

    fmt.Println("円形(サンプル の例):")
    PrintShape(c)

    fmt.Println("矩形(サンプル の例):")
    PrintShape(r)
}

Go のインターフェース設計は「小さなインターフェース」を推奨しています。通常は1〜3個のメソッドのみを含みます。標準ライブラリの io.Reader(Read メソッドのみ)と io.Writer(Write メソッドのみ)が最も古典的な例です。


よく使う例

以下では、実際のシナリオに近い2つの完全な例を通じて、Go の実際の開発での使い方を示します。

HTTP サーバーの構築

標準ライブラリの net/http を使用するだけで、機能が完全な Web サービスを構築できます。サードパーティのフレームワークは一切必要ありません。

例

// ファイルパス: server.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

// Response は JSON レスポンスのデータ構造を定義します
type Response struct {
    Code    int    `json:"code"`    // 構造体タグで JSON フィールド名を指定します
    Message string `json:"message"`
    Data    any    `json:"data,omitempty"` // omitempty: 値が空の場合、そのフィールドは出力されません
}

// helloHandler は /hello ルートへのリクエストを処理します
func helloHandler(w http.ResponseWriter, r *http.Request) {
    // GET リクエストのみ許可します
    if r.Method != http.MethodGet {
        http.Error(w, "GET リクエストのみサポートしています", http.StatusMethodNotAllowed)
        return
    }

    // クエリパラメータから name を取得し、デフォルトは "サンプル" です
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "サンプル"
    }

    // レスポンスデータを構築します
    resp := Response{
        Code:    200,
        Message: fmt.Sprintf("こんにちは、%s さん! Go HTTP サービスへようこそ", name),
    }

    // レスポンスヘッダーを設定し、JSON を返します
    w.Header().Set("Content-Type", "application/json; charset=utf-8")
    json.NewEncoder(w).Encode(resp)
}

func main() {
    // ルート処理関数を登録します
    http.HandleFunc("/hello", helloHandler)

    addr := ":8080"
    fmt.Printf("サンプル サーバーが起動しました。監視アドレス: http://localhost%s\n", addr)
    fmt.Printf("アクセス例: http://localhost%s/hello?name=Go開発者\n", addr)

    // HTTP サービスを起動します(ブロックされ、サービスが停止するまで続きます)
    log.Fatal(http.ListenAndServe(addr, nil))
}

サービス起動後、対応するアドレスにアクセスすると JSON レスポンスが得られます:

$ go run server.go
サンプル 服务器启动,监听地址: http://localhost:8080
访问示例: http://localhost:8080/hello?name=Go开发者

# 使用 curl 测试
$ curl http://localhost:8080/hello?name=Go开发者
{"code":200,"message":"你好,Go开发者!欢迎访问 Go HTTP 服务"}

$ curl http://localhost:8080/hello
{"code":200,"message":"你好,サンプル!欢迎访问 Go HTTP 服务"}

本番レベルの Web サービスでは、実際のニーズに応じて適切なフレームワークを選択することをお勧めします。小規模プロジェクトでは標準ライブラリで十分ですが、ルーティンググループやミドルウェアなどの機能が必要な場合は、Gin や Echo を選択できます。

並行 Worker プール

これは Go の並行処理の古典的なユースケースです。限定された数の goroutine を使用して、大量のタスクを並列処理します。

例

// ファイルパス: workerpool.go
package main

import (
    "fmt"
    "sync"
    "time"
)

// worker は jobs チャネルからタスクを読み取り、処理後に結果を results チャネルに書き込みます
// タスク処理が完了したら wg.Done() を呼び出して WaitGroup に通知します
func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done() // 関数がどのように終了しても、その worker が完了したことをマークします
    for job := range jobs {
        fmt.Printf("[Worker %d] タスク %d を処理中\n", id, job)
        time.Sleep(200 * time.Millisecond) // タスク処理の所要時間をシミュレーションします
        results <- job * job               // 結果として平方を計算します
    }
}

func main() {
    const numJobs = 10    // タスクの総数
    const numWorkers = 3  // 並行 worker の数

    jobs := make(chan int, numJobs)     // バッファ付きのタスクチャネル
    results := make(chan int, numJobs)  // バッファ付きの結果チャネル
    var wg sync.WaitGroup               // すべての worker の完了を待つために使用します

    fmt.Println("=== サンプル Worker Pool の例 ===")

    // 固定数の worker goroutine を起動します
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1) // worker を1つ起動するたびに、WaitGroup のカウントを1増やします
        go worker(w, jobs, results, &wg)
    }

    // すべてのタスクをチャネルに送信します
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs) // jobs チャネルを閉じると、worker の range ループは自動的に終了します

    // すべての worker の完了を待ってから、結果チャネルを閉じます
    go func() {
        wg.Wait()
        close(results)
    }()

    // すべての結果を収集して出力します
    fmt.Println("結果の集計:")
    for result := range results {
        fmt.Printf("%d ", result)
    }
    fmt.Println("\nすべてのタスクの処理が完了しました")
}
$ go run workerpool.go
=== サンプル Worker Pool 示例 ===
[Worker 3] 处理任务 1
[Worker 1] 处理任务 3
[Worker 2] 处理任务 2
[Worker 1] 处理任务 4
[Worker 3] 处理任务 5
[Worker 2] 处理任务 6
...
结果汇总:
1 4 9 16 25 36 49 64 81 100
所有任务处理完成

よく使うツールとコマンド

Go には完全な開発ツールチェーンが同梱されており、追加のビルドツールをインストールする必要はありません。以下は最もよく使われる go コマンドの早見表です:

コマンド機能よく使うシナリオ
go buildソースコードをコンパイルする実行可能ファイルを生成し、デプロイに使用する
go runコンパイルして実行するコードをすばやくテストし、開発やデバッグを行う
go testテストを実行する_test.go ファイル内のテスト関数を実行する
go mod initモジュールを初期化する新しいプロジェクト作成時に go.mod ファイルを生成する
go mod tidy依存関係を整理する不足している依存関係をダウンロードし、未使用の依存関係を削除する
go fmtコードをフォーマットするコードスタイルを統一する(Go コミュニティで必須)
go vet静的解析コード内の疑わしい構造をチェックする
go get依存パッケージをインストールする指定したパッケージをダウンロードしてインストールする
go docドキュメントを表示するターミナルでパッケージや関数のドキュメントを表示する
go env環境変数を表示するGOPATH、GOROOT などの設定を表示する
go cleanビルドキャッシュをクリアするディスク領域を解放する

go fmt は Go コミュニティにおける必須の取り決めです。すべての Go コードは go fmt でフォーマットする必要があります。これによりコードスタイルに関する議論がなくなり、コードベースの一貫性が高く保たれます。ほとんどのエディター(VS Code、GoLand など)は、保存時に go fmt を自動実行する機能をサポートしています。


注意点とよくある問題

以下は、Go の初心者が最も遭遇しやすい問題とベストプラクティスのアドバイスです。

GOPATH と Go Modules

Go 1.16 以降、Go Modules がデフォルトモードになりました。新しいプロジェクトは GOPATH ディレクトリに置く必要がなくなり、任意の場所に作成できます。

チュートリアルで GOPATH の複雑な設定を見かけても、通常は無視して構いません。Go Modules を使用すれば、ほとんどの開発ニーズを満たせます。

エラーハンドリングを無視できない

Go コンパイラは error の処理を強制しませんが、エラーを無視するのは悪い習慣です。少なくとも開発段階ではエラー情報を記録または出力すべきです。

例

package main

import (
    "fmt"
    "os"
)

func main() {
    // 非推奨:エラーを無視
    data, _ := os.ReadFile("config.txt")
    fmt.Println(string(data))

    // 推奨:エラーを明示的に処理
    data, err := os.ReadFile("config.txt")
    if err != nil {
        fmt.Printf("ファイルの読み取りに失敗: %v\n", err)
        return
    }
    fmt.Println(string(data))
}

Goroutine リーク

goroutine を起動した後、それが永久にブロックされて終了できない場合、goroutine リークが発生します。長期間稼働するサービスでは、goroutine リークによりメモリが徐々に枯渇します。

ベストプラクティス:

  • 各 goroutine に終了経路を確保する
  • 使用するcontext.Contextキャンセルシグナルを伝達する
  • 使用するsync.WaitGroupgoroutine のライフサイクルを追跡する

スライス(slice)の基盤配列の共有

複数のスライスが同じ基盤配列を共有する可能性があります。あるスライスに対して append や変更操作を行うとき、同じ基盤配列を参照する他のスライスに影響を与えないか注意する必要があります。

不確かな場合は、copy() を使用して独立したコピーを作成します。

nil インターフェースと nil ポインタの違い

これは古典的な Go の罠です:インターフェース値が nil ポインタを含む場合、インターフェース自体は nil ではありません。つまりif err != nilが true を返す可能性がありますが、実際のポインタは nil です。

error を返すときは、nil ポインタを含む error インターフェース変数を return するのではなく、直接 return nil とすべきです。

Go の型システムは簡潔ですが、独自の「性格」を持っています。他の言語から移ってきた開発者は、Effective Go 公式ドキュメント(golang.org/doc/effective_go)を読んで、Go 慣用的なコーディング方式とデザインパターンを理解することをお勧めします。

コードの構成

Go はパッケージ(package)フォルダのディレクトリ構造ではなく、パッケージでコードを構成します。

同じディレクトリ内のすべての .go ファイルは同じパッケージに属する必要があり、パッケージ名は通常ディレクトリ名と一致します(main パッケージと _test テストファイルを除く)。Go には「サブパッケージ」の概念はありません。異なるディレクトリのパッケージは、パスが近くても完全に独立しています。


まとめ

Go 言語は、極めて簡潔な構文、卓越した性能、そしてネイティブの並行処理サポートにより、クラウドネイティブ、マイクロサービス、DevOps などの分野で代替不可能な地位を確立しています。

Go は機能を追求する言語ではなく、エンジニアリング効率を追求する言語です。チームがより少ないコードを書き、より安定したシステムを得られるようにします。

Go 言語の利点と適用シーンは以下のとおりです:

側面Go の特徴
学習曲線構文が簡潔で、プログラミング経験のある開発者は 1 週間で習得可能
コンパイル速度大規模プロジェクトでも秒単位でコンパイルでき、非常に高速な開発フィードバックループ
実行時性能C/C++ に近く、Python/Ruby/JavaScript をはるかに上回る
メモリ使用量基本的な HTTP サービスはわずか 5〜10 MB のメモリしか必要としない
並行処理goroutine は非常に軽量で、数万の並行処理も問題にならない
デプロイの難易度独立したバイナリファイルにコンパイルされ、コピーするだけで実行可能
最も適しているクラウドネイティブサービス、マイクロサービス、CLI ツール、分散システム、ネットワークプログラミング
あまり適していないGUI デスクトップアプリ、モバイル開発、OS カーネル、組み込みの低レイヤー

並行処理向けのバックエンドサービス、CLI ツール、またはインフラストラクチャプロジェクトを構築しているなら、Go は真剣に検討する価値のある選択肢です。

その他の拡張