Go言語 チートシート

// 型を指定して宣言 (ゼロ値で初期化)
var count int
// 初期値を指定して宣言 (型推論)
var message = "Hello"
// 関数内での短縮宣言 (型推論)
value := 100

// まとめて宣言
var x, y int
var a, b = 1, "text"
c, d := true, 3.14

// グループ化して宣言
var (
    appVersion string = "1.0.0"
    debugMode  bool   = false
)

// 型なし定数 (使用時に型が決定)
const Pi = 3.14159
// 型付き定数
const MaxSize int = 1024
// 連続する定数 (iota)
const (
    Sunday = iota // 0
    Monday        // 1
    Tuesday       // 2
)
// iotaの応用
const (
    _ = 1 << (10 * iota) // 読み飛ばし
    KiB                   // 1 << (10*1) = 1024
    MiB                   // 1 << (10*2) = 1048576
    GiB                   // 1 << (10*3) = 1073741824
)

score := 75
if score >= 80 {
    fmt.Println("Great")
} else if score >= 60 {
    fmt.Println("Good")
} else {
    fmt.Println("Needs Improvement")
}

// 条件判定前に簡単なステートメントを実行
if err := process(); err != nil {
    fmt.Println("Error:", err)
}

// 基本的なswitch
day := "Monday"
switch day {
case "Sunday", "Saturday":
    fmt.Println("Weekend! 😊")
case "Monday":
    fmt.Println("Start of the week...")
default:
    fmt.Println("Weekday")
}

// 条件式を持つswitch (if/else ifの代替)
num := 15
switch {
case num < 10:
    fmt.Println("Single digit")
case num < 100:
    fmt.Println("Double digit")
default:
    fmt.Println("Large number")
}

// フォールスルー (fallthrough)
value := 1
switch value {
case 1:
    fmt.Println("Value is 1")
    fallthrough // 次のcaseも実行
case 2:
    fmt.Println("Value is 1 or 2")
default:
    fmt.Println("Other value")
}

// C言語風forループ
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 条件式のみ (while風)
n := 0
for n < 5 {
    fmt.Println(n)
    n++
}

// 無限ループ
// for {
//     fmt.Println("Looping forever...")
//     time.Sleep(1 * time.Second)
// }

// スライスやマップの反復 (range)
nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

// インデックスのみ
for index := range nums {
    fmt.Println("Index:", index)
}

// 値のみ
for _, value := range nums {
    fmt.Println("Value:", value)
}

// マップの反復
colors := map[string]string{"red": "#ff0000", "green": "#00ff00"}
for key, value := range colors {
    fmt.Printf("Key: %s, Value: %s\n", key, value)
}

// 文字列の反復 (rune単位)
for index, runeValue := range "Go言語" {
    fmt.Printf("%#U starts at byte position %d\n", runeValue, index)
}

func readFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close() // 関数終了時に必ず実行される

    // ファイル処理...
    return nil
}

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

// 引数の型が同じ場合は省略可能
func multiply(x, y int) int {
    return x * y
}

func divide(numerator, denominator int) (int, error) {
    if denominator == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return numerator / denominator, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

// 戻り値の変数を事前に宣言
func calculate(a, b int) (sum int, difference int) {
    sum = a + b
    difference = a - b
    // return文で変数を指定しなくても良い (naked return)
    return
}

s, d := calculate(5, 3) // s = 8, d = 2

func sumNumbers(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

sum := sumNumbers(1, 2, 3, 4, 5) // sum = 15

// スライスを渡すことも可能
numbers := []int{10, 20}
sum = sumNumbers(numbers...) // sum = 30

// 変数に関数を代入
greet := func(name string) {
    fmt.Println("Hello,", name)
}
greet("Alice")

// クロージャ (関数が定義されたスコープの変数を参照)
func incrementer() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

inc := incrementer()
fmt.Println(inc()) // 1
fmt.Println(inc()) // 2

var arr [3]int // [0 0 0]
arr[0] = 1
fmt.Println(arr, len(arr)) // [1 0 0] 3

arr2 := [...]string{"apple", "banana"} // 要素数から長さを推論
fmt.Println(arr2, len(arr2)) // [apple banana] 2

// スライスリテラルで作成
s1 := []int{1, 2, 3}
fmt.Println(s1, len(s1), cap(s1)) // [1 2 3] 3 3

// makeで作成 (長さと容量を指定)
s2 := make([]int, 3, 5) // 長さ3, 容量5のスライス [0 0 0]
fmt.Println(s2, len(s2), cap(s2)) // [0 0 0] 3 5

// appendで要素追加 (容量が足りなければ新しい配列を確保)
s1 = append(s1, 4, 5)
fmt.Println(s1, len(s1), cap(s1)) // [1 2 3 4 5] 5 6 (容量は実行環境依存で増加)

// スライスからスライスを作成 (元の配列を共有)
s3 := s1[1:3] // インデックス1から3の手前まで [2 3]
fmt.Println(s3, len(s3), cap(s3)) // [2 3] 2 5 (容量は元のスライスの末尾まで)

s3[0] = 99 // 元のスライスs1も変更される
fmt.Println(s1) // [1 99 3 4 5]

// copyでスライスをコピー
s4 := make([]int, len(s1))
copiedCount := copy(s4, s1)
fmt.Println(s4, copiedCount) // [1 99 3 4 5] 5

// マップリテラルで作成
m1 := map[string]int{"apple": 100, "banana": 200}
fmt.Println(m1) // map[apple:100 banana:200]

// makeで作成
m2 := make(map[string]string)
m2["go"] = "Golang"
m2["js"] = "JavaScript"
fmt.Println(m2) // map[go:Golang js:JavaScript]

// 要素へのアクセスと存在確認
price := m1["apple"] // 100
price, ok := m1["orange"] // price = 0 (ゼロ値), ok = false
if ok {
    fmt.Println("Price:", price)
} else {
    fmt.Println("Orange not found")
}

// 要素の削除
delete(m1, "banana")
fmt.Println(m1) // map[apple:100]

// マップの反復 (順序は保証されない)
for key, value := range m2 {
    fmt.Printf("Key: %s, Value: %s\n", key, value)
}

type Person struct {
    Name string
    Age  int
}

// 構造体の初期化
p1 := Person{Name: "Alice", Age: 30}
p2 := Person{"Bob", 25} // フィールド名を省略 (順序が重要)
p3 := new(Person) // ポインタを返す (*Person)、フィールドはゼロ値
p3.Name = "Charlie"
p3.Age = 40

fmt.Println(p1, p2, *p3) // {Alice 30} {Bob 25} {Charlie 40}

// フィールドへのアクセス
fmt.Println(p1.Name) // Alice

// 構造体の埋め込み (Embedding)
type Employee struct {
    Person // 型名をそのままフィールドとして埋め込む
    EmployeeID string
    Salary     int
}

emp := Employee{
    Person: Person{Name: "David", Age: 35},
    EmployeeID: "E123",
    Salary: 50000,
}

// 埋め込まれた構造体のフィールドに直接アクセス可能
fmt.Println(emp.Name) // David
fmt.Println(emp.Person.Age) // 35

x := 10
p := &x // xのアドレスをポインタpに格納

fmt.Println("Value of x:", x)    // 10
fmt.Println("Address of x:", p)  // メモリアドレス (例: 0x...)
fmt.Println("Value via p:", *p) // ポインタpが指す先の値 (デリファレンス) -> 10

*p = 20 // ポインタ経由で値を変更
fmt.Println("New value of x:", x) // 20

func increment(val *int) {
    *val++ // ポインタが指す先の値をインクリメント
}

num := 5
increment(&num)
fmt.Println("Incremented num:", num) // 6

ptr := new(int) // int型のゼロ値(0)へのポインタを返す
fmt.Println(*ptr) // 0
*ptr = 100
fmt.Println(*ptr) // 100

type Rect struct {
    Width, Height float64
}

// 値レシーバ (元の値を変更しない)
func (r Rect) Area() float64 {
    return r.Width * r.Height
}

// ポインタレシーバ (元の値を変更できる)
func (r *Rect) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rect{Width: 10, Height: 5}
fmt.Println("Area:", rect.Area()) // 50.0

rect.Scale(2) // ポインタレシーバでも自動的にアドレスが渡される
fmt.Println("Scaled Rect:", rect) // {20 10}

// ポインタ型変数でもメソッド呼び出し可能
rectPtr := &Rect{Width: 3, Height: 4}
fmt.Println("Area:", rectPtr.Area()) // 12.0 (自動的にデリファレンスされる)
rectPtr.Scale(3)
fmt.Println("Scaled Rect Ptr:", *rectPtr) // {9 12}

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

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

// Shapeインターフェースを満たす型はShape型の変数に代入可能
func printArea(s Shape) {
    fmt.Printf("Area of %T: %f\n", s, s.Area())
}

r := Rect{Width: 4, Height: 5}
c := Circle{Radius: 3}

printArea(r) // Rect型はArea()メソッドを持つのでShapeインターフェースを満たす
printArea(c) // Circle型も同様

var i interface{}
i = "hello"
fmt.Println(i) // hello

i = 42
fmt.Println(i) // 42

// 型アサーション (Type Assertion)
s, ok := i.(string) // string型への変換を試みる
if ok {
    fmt.Println("It's a string:", s)
} else {
    fmt.Println("Not a string")
}

// 型スイッチ (Type Switch)
func checkType(v interface{}) {
    switch t := v.(type) {
    case string:
        fmt.Println("String:", t)
    case int:
        fmt.Println("Integer:", t)
    case bool:
        fmt.Println("Boolean:", t)
    default:
        fmt.Printf("Unknown type: %T\n", t)
    }
}

checkType("world")
checkType(123)
checkType(true)
checkType(3.14)

type IPAddr [4]byte

// String()メソッドを実装することでStringerインターフェースを満たす
func (ip IPAddr) String() string {
	return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
}

addr := IPAddr{127, 0, 0, 1}
fmt.Println(addr) // 127.0.0.1 (String()が呼ばれる)

type error interface {
    Error() string
}

file, err := os.Open("nonexistent.txt")
if err != nil {
    log.Printf("Failed to open file: %v\n", err)
    // エラーに応じた処理 (早期リターンなど)
    return
}
defer file.Close()
// 正常系の処理
fmt.Println("File opened successfully.")

err := errors.New("something went wrong")
fmt.Println(err)

func readFile(path string) error {
    _, err := os.ReadFile(path)
    if err != nil {
        // %w で元のエラーをラップする
        return fmt.Errorf("error reading file %s: %w", path, err)
    }
    return nil
}

err := readFile("config.yaml")
if err != nil {
    fmt.Println(err)
}

err1 := os.ErrNotExist // 事前定義されたエラー
err2 := fmt.Errorf("operation failed: %w", err1)

if errors.Is(err2, os.ErrNotExist) {
    fmt.Println("The file does not exist.")
}

type MyError struct {
    Code int
    Msg  string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Msg)
}

func doSomething() error {
    // 何らかの処理...
    return fmt.Errorf("wrapping custom error: %w", &MyError{Code: 500, Msg: "internal server error"})
}

err := doSomething()
var myErr *MyError
if errors.As(err, &myErr) {
    fmt.Printf("Caught MyError - Code: %d, Message: %s\n", myErr.Code, myErr.Msg)
} else {
    fmt.Println("Caught a different error:", err)
}

func recoveryDemo() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()

    fmt.Println("Calling dangerous function...")
    causePanic()
    fmt.Println("This line will not be executed if panic occurs and is recovered.")
}

func causePanic() {
    fmt.Println("About to panic!")
    panic("something bad happened")
    fmt.Println("This line will not be executed.")
}

recoveryDemo()

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("World") // 新しいGoroutineでsay("World")を実行
    say("Hello")    // 現在のGoroutineでsay("Hello")を実行

    // main関数が終了すると他のGoroutineも終了するため、少し待つ
    // time.Sleep(500 * time.Millisecond) // より良い方法はsync.WaitGroupを使う
}

// チャネル作成 (バッファなし)
ch := make(chan string)

go func() {
    time.Sleep(1 * time.Second)
    ch <- "Data from goroutine" // チャネルにデータを送信 (受信されるまでブロック)
}()

fmt.Println("Waiting for data...")
msg := <-ch // チャネルからデータを受信 (データが来るまでブロック)
fmt.Println("Received:", msg)

// バッファ付きチャネル (指定サイズまでブロックせずに送信可能)
bufCh := make(chan int, 2)
bufCh <- 1 // ブロックしない
bufCh <- 2 // ブロックしない
// bufCh <- 3 // バッファが満杯なのでブロックする

fmt.Println(<-bufCh) // 1
fmt.Println(<-bufCh) // 2

c1 := make(chan string)
c2 := make(chan string)

go func() {
    time.Sleep(1 * time.Second)
    c1 <- "one"
}()
go func() {
    time.Sleep(2 * time.Second)
    c2 <- "two"
}()

// 2つのGoroutineからの応答を待つ
for i := 0; i < 2; i++ {
    select {
    case msg1 := <-c1:
        fmt.Println("Received from c1:", msg1)
    case msg2 := <-c2:
        fmt.Println("Received from c2:", msg2)
    case <-time.After(3 * time.Second): // タイムアウト
        fmt.Println("Timeout waiting for messages")
        return
    // default: // 他に準備ができているチャネルがない場合に実行 (ノンブロッキング)
    //     fmt.Println("No messages ready yet")
    //     time.Sleep(100 * time.Millisecond)
    }
}

jobs := make(chan int, 5)
done := make(chan bool)

go func() {
    for {
        j, more := <-jobs // moreはチャネルが開いているかを示す
        if more {
            fmt.Println("Received job", j)
        } else {
            fmt.Println("Received all jobs")
            done <- true
            return
        }
    }
}()

for j := 1; j <= 3; j++ {
    jobs <- j
    fmt.Println("Sent job", j)
}
close(jobs) // これ以上送信しないことを示す
fmt.Println("Sent all jobs and closed channel")

<-done // worker goroutineの終了を待つ

var counter int
var mu sync.Mutex
var wg sync.WaitGroup

func incrementCounter() {
    defer wg.Done()
    for i := 0; i < 1000; i++ {
        mu.Lock() // ロックを取得
        counter++
        mu.Unlock() // ロックを解放
    }
}

func main() {
    numGoroutines := 5
    wg.Add(numGoroutines)
    for i := 0; i < numGoroutines; i++ {
        go incrementCounter()
    }
    wg.Wait() // 全てのGoroutineの終了を待つ
    fmt.Println("Final Counter:", counter) // 期待値: 5000
}

// 上記Mutexの例を参照
// 1. WaitGroup変数を宣言: var wg sync.WaitGroup
// 2. Goroutine起動前に wg.Add(1) でカウンタを増やす
// 3. Goroutine内の処理終了時に defer wg.Done() でカウンタを減らす
// 4. メインGoroutineで wg.Wait() でカウンタが0になるのを待つ

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done(): // 親コンテキストからのキャンセル通知を待つ
            fmt.Printf("Worker %d: stopping due to cancellation: %v\n", id, ctx.Err())
            return
        default:
            fmt.Printf("Worker %d: working...\n", id)
            time.Sleep(500 * time.Millisecond)
            // ここで ctx.Value("requestID") のような値を使うこともできる
        }
    }
}

func main() {
    // タイムアウト付きのコンテキストを作成 (例: 2秒後にキャンセル)
    // ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)

    // キャンセル関数付きのコンテキストを作成
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // main関数終了時に必ずキャンセルを呼ぶ

    // リクエストIDなどの値を付与する場合
    // requestID := "req-123"
    // ctx = context.WithValue(ctx, "requestID", requestID)

    go worker(ctx, 1)
    go worker(ctx, 2)

    // 3秒後にキャンセルシグナルを送る
    time.Sleep(3 * time.Second)
    fmt.Println("Main: sending cancellation signal...")
    cancel()

    // Workerが終了するのを少し待つ
    time.Sleep(1 * time.Second)
    fmt.Println("Main: finished.")
}

• **Generator:** チャネルを使って一連の値を生成する関数。
• **Worker Pool:** 固定数のワーカーGoroutineでタスクキューを処理する。
• **Pipeline:** 複数のステージ（Goroutine）をチャネルで繋ぎ、データを段階的に処理する。
• **Fan-In/Fan-Out:** 複数のGoroutineにタスクを分散（Fan-Out）し、結果を一つのチャネルに集約（Fan-In）。
• **Semaphore:** 同時にアクセスできるGoroutineの数を制限する。

go mod init example.com/myproject

# 最新バージョンを追加
go get github.com/gin-gonic/gin

# 特定のバージョンを追加
go get github.com/gin-gonic/gin@v1.7.7

# バージョンを更新
go get -u github.com/gin-gonic/gin

# 全ての依存関係を更新
go get -u ./...

go mod tidy

go mod download

go list -m all

go mod vendor

• テストファイル: `*_test.go`
• テスト関数: `func TestXxx(*testing.T)` (Xxxはテスト対象の関数名など、大文字で始まる)
• ベンチマーク関数: `func BenchmarkXxx(*testing.B)`
• Example関数: `func ExampleXxx()`

// mymath/mymath.go
package mymath

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

// mymath/mymath_test.go
package mymath

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected) // エラーを報告しテスト続行
        // t.Fatalf("Add(2, 3) = %d; want %d", result, expected) // エラーを報告しテスト終了
    }
}

# カレントディレクトリのテストを実行
go test

# 詳細表示 (-v)
go test -v

# 特定のテスト関数を実行 (-run 正規表現)
go test -v -run TestAdd

# カバレッジ計測
go test -cover
go test -coverprofile=coverage.out
go tool cover -html=coverage.out # HTMLで結果表示

func TestAddTableDriven(t *testing.T) {
    testCases := []struct {
        name     string // テストケース名 (オプション)
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -1, -5, -6},
        {"zero", 0, 0, 0},
        {"positive and negative", 10, -3, 7},
    }

    for _, tc := range testCases {
        // t.Run でサブテストを作成 (go test -run TestAddTableDriven/negative_numbers のように実行可能)
        t.Run(tc.name, func(t *testing.T) {
            result := Add(tc.a, tc.b)
            if result != tc.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tc.a, tc.b, result, tc.expected)
            }
        })
    }
}

func BenchmarkAdd(b *testing.B) {
    // b.N はベンチマークフレームワークによって自動的に調整される実行回数
    for i := 0; i < b.N; i++ {
        Add(100, 200)
    }
}

# ベンチマーク実行 (-bench 正規表現)
go test -bench .
go test -bench BenchmarkAdd

func ExampleAdd() {
    sum := Add(1, 5)
    fmt.Println(sum)
    // Output: 6
}

• `t.Helper()`: テストヘルパー関数内で呼び出すと、エラー発生時のファイル/行番号がヘルパー呼び出し元になる。
• `TestMain`: パッケージ内のテスト実行前後に一度だけ実行される特殊な関数。DB接続や一時ファイル作成などに使う。

  func TestMain(m *testing.M) {
      fmt.Println("Setting up tests...")
      // セットアップ処理
  
      exitCode := m.Run() // パッケージ内のテストを実行
  
      fmt.Println("Tearing down tests...")
      // ティアダウン処理
  
      os.Exit(exitCode)
  }

func MyHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, test!")
}

func TestMyHandler(t *testing.T) {
    req := httptest.NewRequest(http.MethodGet, "/test", nil)
    rr := httptest.NewRecorder() // http.ResponseWriterのモック

    handler := http.HandlerFunc(MyHandler)
    handler.ServeHTTP(rr, req)

    // ステータスコードをチェック
    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    // レスポンスボディをチェック
    expected := "Hello, test!\n"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

type Config struct {
    Server   string `json:"serverAddress"` // タグでJSONキー名を指定
    Port     int    `json:"port"`
    Enabled  bool   `json:"enabled"`
    Users    []string `json:"users,omitempty"` // omitempty: スライスがnilか空なら出力しない
    Password string `json:"-"` // -: このフィールドはJSONに含めない
}

conf := Config{
    Server:  "localhost",
    Port:    8080,
    Enabled: true,
    // Users: []string{"admin", "guest"},
    Password: "secret",
}

jsonData, err := json.Marshal(conf)
// jsonData, err := json.MarshalIndent(conf, "", "  ") // 整形して出力する場合
if err != nil {
    log.Fatal("JSON marshal error:", err)
}

fmt.Println(string(jsonData))
// 出力例 (Marshal): {"serverAddress":"localhost","port":8080,"enabled":true}
// 出力例 (MarshalIndent):
// {
//   "serverAddress": "localhost",
//   "port": 8080,
//   "enabled": true
// }

jsonString := `{"serverAddress":"192.168.1.100","port":9000,"enabled":false,"users":["root"],"unknownField":"ignore"}`
var loadedConf Config

err := json.Unmarshal([]byte(jsonString), &loadedConf) // ポインタを渡す
if err != nil {
    log.Fatal("JSON unmarshal error:", err)
}

fmt.Printf("Loaded Config: %+v\n", loadedConf)
// 出力例: Loaded Config: {Server:192.168.1.100 Port:9000 Enabled:false Users:[root] Password:}

jsonString := `{"name":"Alice","age":30,"city":"New York","extra":{"active":true}}`
var data map[string]interface{} // mapまたはinterface{}にデコード

err := json.Unmarshal([]byte(jsonString), &data)
if err != nil { /*...*/ }

name := data["name"].(string) // 型アサーションで値を取り出す
age := data["age"].(float64) // JSONの数値はfloat64としてデコードされることが多い
extraMap := data["extra"].(map[string]interface{})
isActive := extraMap["active"].(bool)

fmt.Println(name, age, isActive) // Alice 30 true

// http.Request.Body (io.Reader) などから読み込む場合
// dec := json.NewDecoder(r.Body)
// err := dec.Decode(&myStruct)

// ファイルから読み込む例
file, _ := os.Open("large.json")
defer file.Close()

dec := json.NewDecoder(file) // io.Readerを渡す
var v map[string]interface{} // または具体的な構造体

err := dec.Decode(&v) // JSONオブジェクトを1つデコード
if err != nil { /*...*/ }
fmt.Println(v)

// http.ResponseWriter (io.Writer) などに書き込む場合
// enc := json.NewEncoder(w)
// err := enc.Encode(myStruct)

// ファイルに書き込む例
file, _ := os.Create("output_stream.json")
defer file.Close()

enc := json.NewEncoder(file) // io.Writerを渡す
enc.SetIndent("", "  ") // 整形出力する場合
data := map[string]string{"hello": "world"}

err := enc.Encode(data) // JSONオブジェクトを書き込む
if err != nil { /*...*/ }

resp, err := http.Get("https://example.com")
if err != nil {
    log.Fatal("HTTP GET error:", err)
}
defer resp.Body.Close() // レスポンスボディは必ず閉じる

fmt.Println("Status Code:", resp.StatusCode)

if resp.StatusCode == http.StatusOK {
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal("Error reading response body:", err)
    }
    fmt.Println("Response Body:\n", string(bodyBytes))
}

// カスタムクライアント (タイムアウト設定など)
client := &http.Client{
    Timeout: 10 * time.Second,
}

// リクエストを作成 (メソッド, URL, ボディを指定)
reqBody := strings.NewReader(`{"key":"value"}`) // io.Reader
req, err := http.NewRequest(http.MethodPost, "https://httpbin.org/post", reqBody)
if err != nil {
    log.Fatal("Error creating request:", err)
}

// ヘッダーを設定
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer your_token")
req.Header.Set("User-Agent", "MyGoApp/1.0")

// リクエストを実行
resp, err := client.Do(req)
if err != nil {
    log.Fatal("HTTP Do error:", err)
}
defer resp.Body.Close()

// レスポンス処理 (上記Getの例と同様)
fmt.Println("Status Code:", resp.StatusCode)
bodyBytes, _ := io.ReadAll(resp.Body)
fmt.Println(string(bodyBytes))

func helloHandler(w http.ResponseWriter, r *http.Request) {
    // w: レスポンスを書き込むためのライター
    // r: リクエスト情報を持つポインタ
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:]) // URLパスから名前を取得 (例: /Alice -> Hello, Alice!)
}

func headersHandler(w http.ResponseWriter, r *http.Request) {
    for name, headers := range r.Header {
        for _, h := range headers {
            fmt.Fprintf(w, "%v: %v\n", name, h)
        }
    }
}

func main() {
    // URLパスとハンドラ関数を登録
    http.HandleFunc("/hello/", helloHandler)
    http.HandleFunc("/headers", headersHandler)

    fmt.Println("Starting server on :8080")
    // サーバーを起動 (アドレスとデフォルトのServeMuxを指定)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe error: ", err)
    }
}

func main() {
    mux := http.NewServeMux() // 新しいServeMuxを作成
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Custom Server Root")
    })

    server := &http.Server{
        Addr:         ":8081",
        Handler:      mux, // カスタムServeMuxを指定
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    fmt.Println("Starting custom server on :8081")
    err := server.ListenAndServe()
    if err != nil && err != http.ErrServerClosed {
        log.Fatal("Server error: ", err)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr())
    buf := make([]byte, 1024)
    for {
        n, err := conn.Read(buf)
        if err != nil {
            if err != io.EOF {
                fmt.Println("Read error:", err)
            }
            break // EOF またはエラーでループ終了
        }
        fmt.Printf("Received: %s", string(buf[:n]))
        // エコーバック
        _, err = conn.Write([]byte("Echo: " + string(buf[:n])))
        if err != nil {
            fmt.Println("Write error:", err)
            break
        }
    }
    fmt.Printf("Connection closed from %s\n", conn.RemoteAddr())
}

func main() {
    listener, err := net.Listen("tcp", ":8888")
    if err != nil {
        log.Fatal("Listen error:", err)
    }
    defer listener.Close()
    fmt.Println("TCP Server listening on :8888")

    for {
        conn, err := listener.Accept() // 新しい接続を待機
        if err != nil {
            fmt.Println("Accept error:", err)
            continue // エラーが発生しても次の接続を待つ
        }
        go handleConnection(conn) // 各接続を個別のGoroutineで処理
    }
}

func main() {
    conn, err := net.Dial("tcp", "localhost:8888")
    if err != nil {
        log.Fatal("Dial error:", err)
    }
    defer conn.Close()
    fmt.Println("Connected to server.")

    // サーバーにメッセージを送信
    _, err = conn.Write([]byte("Hello from client!\n"))
    if err != nil {
        log.Fatal("Write error:", err)
    }

    // サーバーからの応答を受信
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        log.Fatal("Read error:", err)
    }
    fmt.Printf("Server response: %s", string(buf[:n]))
}