Go言語入門：効率的な学習ロードマップとモダンな開発スタイルの習得

my-project/
├── cmd/             # メインアプリケーションのエントリポイント
│   └── server/
│       └── main.go
├── internal/        # 外部からインポートされたくない非公開パッケージ
├── pkg/             # 外部から再利用可能な公開パッケージ
├── api/             # OpenAPI定義やプロトコル定義
├── configs/         # 設定ファイル
├── go.mod           # モジュール定義
└── go.sum           # 依存関係のチェックサム

mkdir my-go-app
cd my-go-app
go mod init github.com/username/my-go-app

go: creating new go.mod: module github.com/username/my-go-app

package main

import "fmt"

func main() {
    // 短縮変数宣言
    message := "Go言語の世界へようこそ" 
    version := 1.24 // 2026年時点の想定バージョン

    // 明示的な型宣言
    var isActive bool = true

    fmt.Printf("Message: %s, Version: %.2f, Active: %v\n", message, version, isActive)
}

Message: Go言語の世界へようこそ, Version: 1.24, Active: true

package main

import "fmt"

// User 構造体の定義
type User struct {
    ID    int
    Name  string
    Email string
}

// メソッドの定義（レシーバ引数を使用）
func (u User) Greet() string {
    return fmt.Sprintf("こんにちは、%sさん！", u.Name)
}

func main() {
    // 構造体の初期化
    user := User{
        ID:   1,
        Name: "山田太郎",
        Email: "yamada@example.com",
    }

    fmt.Println(user.Greet())
}

こんにちは、山田太郎さん！

package main

import "fmt"

// Greeter インターフェース
type Greeter interface {
    Greet() string
}

func SayHello(g Greeter) {
    fmt.Println(g.Greet())
}

// Robot 構造体
type Robot struct {
    ModelName string
}

func (r Robot) Greet() string {
    return "ピッ… ロボットモデル " + r.ModelName + " です。"
}

func main() {
    user := User{Name: "佐藤"}
    robot := Robot{ModelName: "RX-2026"}

    SayHello(user)  // UserはGreeterインターフェースを満たしている
    SayHello(robot) // RobotもGreeterインターフェースを満たしている
}

こんにちは、佐藤さん！
ピッ… ロボットモデル RX-2026 です。

package main

import (
    "errors"
    "fmt"
    "os"
)

func readFile(filename string) (string, error) {
    if filename == "" {
        return "", errors.New("ファイル名が空です")
    }
    // 実際にはファイル読み込み処理
    return "ファイルの内容", nil
}

func main() {
    content, err := readFile("")
    if err != nil {
        // エラーが発生した際の処理を明示的に記述する
        fmt.Fprintf(os.Stderr, "エラーが発生しました: %v\n", err)
        return
    }
    fmt.Println(content)
}

エラーが発生しました: ファイル名が空です

if errors.Is(err, os.ErrNotExist) {
    fmt.Println("ファイルが見つかりませんでした")
}

package main

import (
    "fmt"
    "time"
)

func processTask(id int, ch chan string) {
    // 重い処理をシミュレート
    time.Sleep(time.Second)
    ch <- fmt.Sprintf("タスク %d 完了", id)
}

func main() {
    ch := make(chan string)

    for i := 1; i <= 3; i++ {
        go processTask(i, ch)
    }

    // チャネルから結果を受け取る
    for i := 1; i <= 3; i++ {
        result := <-ch
        fmt.Println(result)
    }
    fmt.Println("すべてのタスクが終了しました")
}

タスク 1 完了
タスク 2 完了
タスク 3 完了
すべてのタスクが終了しました

package main

import "fmt"

// comparable制約を持つ型パラメータTを受け取る関数
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    intSlice := []int{1, 2, 3, 4, 5}
    fmt.Println(Contains(intSlice, 3)) // true

    stringSlice := []string{"Go", "Python", "Rust"}
    fmt.Println(Contains(stringSlice, "Java")) // false
}

true
false

package main

import "testing"

func Add(a, b int) int {
    return a + b
}

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5

    if got != want {
        t.Errorf("Add(2, 3) = %d; want %d", got, want)
    }
}

go test -v ./...

func BenchmarkAdd(b *testing.T) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

package main

import (
    "encoding/json"
    "net/http"
    "log/slog"
    "os"
)

type Response struct {
    Status  string `json:"status"`
    Message string `json:"message"`
}

func handler(w http.ResponseWriter, r *http.Request) {
    res := Response{
        Status:  "success",
        Message: "Go 2026 API Server is running",
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(res)
}

func main() {
    // モダンな構造化ロガー slog の使用
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    
    http.HandleFunc("/api/v1/status", handler)

    logger.Info("サーバーを起動します", "port", 8080)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        logger.Error("サーバー起動失敗", "error", err)
    }
}

{"time":"2026-04-30T10:00:00Z","level":"INFO","msg":"サーバーを起動します","port":8080}