// app/Services/HogeSyncService.php
class HogeSyncService
{
    public function sync(array $payload): array
    {
        $xml = $this->buildXml($payload);

        // ✗ NG： dump するとヘッダーが確定してしまう
        // dump($xml);

        // 〇 OK： Log に残せばブラウザへは何も送られない
        Log::debug('Hoge XML payload', ['xml' => $xml]);

        Http::post(config('hoge.endpoint'), $xml);

        return ['status' => 'ok'];
    }
}

// EmailSender はメール送信を担当する構造体
type EmailSender struct{}

// SendEmail はメールを送信するメソッド
func (e *EmailSender) SendEmail(message string) {
	// メール送信処理
	fmt.Printf("メールを送信中: %s\n", message)
}

// NotificationService は通知サービスを提供する構造体
type NotificationService struct {
	emailSender *EmailSender
}

// NewNotificationService はNotificationServiceの新しいインスタンスを作成
func NewNotificationService() *NotificationService {
	return &NotificationService{
		emailSender: &EmailSender{},
	}
}

// Send はメッセージを送信するメソッド
func (n *NotificationService) Send(message string) {
	n.emailSender.SendEmail(message)
}

// 使用例
func main() {
	service := NewNotificationService()
	service.Send("テストメッセージです")
}

// MessageSender はメッセージ送信のインターフェース
type MessageSender interface {
	Send(message string)
}

// EmailSender はメール送信を実装する構造体
type EmailSender struct{}

// Send はMessageSenderインターフェースを実装
func (e *EmailSender) Send(message string) {
	// メール送信処理
	fmt.Printf("メールを送信中: %s\n", message)
}

// NotificationService は通知サービスを提供する構造体
type NotificationService struct {
	messageSender MessageSender
}

// NewNotificationService はNotificationServiceの新しいインスタンスを作成
func NewNotificationService(messageSender MessageSender) *NotificationService {
	return &NotificationService{
		messageSender: messageSender,
	}
}

// Send はメッセージを送信するメソッド
func (n *NotificationService) Send(message string) {
	n.messageSender.Send(message)
}

// 使用例
func main() {
	// EmailSenderを作成
	emailSender := &EmailSender{}

	// NotificationServiceに依存性を注入
	service := NewNotificationService(emailSender)

	// メッセージを送信
	service.Send("テストメッセージです")
}

// MessageSender はメッセージ送信のインターフェース
type MessageSender interface {
	Send(message string)
}

// ----------------------- 既存の実装 -----------------------

type EmailSender struct{}

func (e *EmailSender) Send(message string) {
	fmt.Printf("メールを送信中: %s\n", message)
}

// ----------------------- 追加する実装 ----------------------

type SmsSender struct{}

func (s *SmsSender) Send(message string) {
	// SMS 送信処理（ここではダミー）
	fmt.Printf("SMS を送信中: %s\n", message)
}

// -------------------- 共通サービス層 -----------------------

type NotificationService struct {
	messageSender MessageSender
}

func NewNotificationService(sender MessageSender) *NotificationService {
	return &NotificationService{messageSender: sender}
}

func (n *NotificationService) Send(message string) {
	n.messageSender.Send(message)
}

// ------------------------- 使用例 --------------------------

func main() {
	// 1) Email で通知
	emailSender := &EmailSender{}
	emailService := NewNotificationService(emailSender)
	emailService.Send("メールのテストメッセージです")

	// 2) SMS で通知
	smsSender := &SmsSender{}
	smsService := NewNotificationService(smsSender)
	smsService.Send("SMS のテストメッセージです")
}

Role arn:aws:iam::795600592301:role/CFn-cicd-CFnRole-yXR5dzw2KIcH is invalid or cannot be assumed

{
  "Effect": "Allow",
  "Principal": {
    "AWS": "arn:aws:iam::795600592301:root"
  },
  "Action": "sts:AssumeRole",
  "Condition": {}
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "cloudformation.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

aws iam update-assume-role-policy \
  --role-name CFn-cicd-CFnRole-yXR5dzw2KIcH \
  --policy-document '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Principal": {
          "Service": "cloudformation.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
      }
    ]
  }'

"Principal": {
  "AWS": "arn:aws:iam::795600592301:root",
  "Service": "cloudformation.amazonaws.com"
}

kaggle/
├── Dockerfile
├── docker-compose.yml
├── kaggle.json              # Kaggle API Key（手動で配置）
├── requirements.txt         # 必要なパッケージを記載
├── working/                 # Kaggleプロジェクト作業ディレクトリ
└── input/                   # コンペデータ配置用（自動でコンテナ内にマウント）

mkdir kaggle
cd kaggle

touch Dockerfile docker-compose.yml
mkdir working input

numpy
pandas
matplotlib
scikit-learn
seaborn

FROM gcr.io/kaggle-gpu-images/python:latest

# Kaggle CLI用APIキーを配置
COPY kaggle.json /root/.kaggle/kaggle.json
RUN chmod 600 /root/.kaggle/kaggle.json

# requirements.txt のコピーとインストール
COPY requirements.txt /kaggle/requirements.txt
RUN pip install --no-cache-dir -r /kaggle/requirements.txt

# Jupyter用のカーネルをインストール
RUN pip install ipykernel
RUN python -m ipykernel install --user --name kaggle-env --display-name "Python (Kaggle)"

# デフォルトディレクトリの作成
RUN mkdir -p /kaggle/input /kaggle/working

# 作業ディレクトリを設定（docker exec -it kaggle bash をした際に、このディレクトリが開かれる）
WORKDIR /kaggle/working

# Jupyterを起動できるようにポートを空けておく
EXPOSE 8888

# 起動時にJupyterを自動起動
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--NotebookApp.token=''", "--NotebookApp.password=''"]

version: "3.9"

services:
  kaggle:
    platform: linux/amd64 # Apple Siliconで起動する際に必要
    build: .
    container_name: kaggle
    ports:
      - "8888:8888"
    volumes:
      - ./working:/kaggle/working
      - ./input:/kaggle/input
    tty: true
    stdin_open: true

docker compose up -d

docker exec -it kaggle bash
jupyter notebook --ip=0.0.0.0 --port=8888 --allow-root --NotebookApp.token=''
# --ip=0.0.0.0 : すべてのIPからのアクセスを許可
# --port=8888 : ポート番号を指定
# --allow-root : ルートユーザーでの起動を許可（Dockerでは必要）
# --NotebookApp.token='' : 認証トークンなしでアクセス可（セキュリティ注意）

kaggle competitions download -c <コンペ名> -p <保存先パス>
kaggle competitions download -c titanic -p /kaggle/input/titanic
unzip ファイル名.zip -d 解凍先パス

kaggle competitions submit -c <コンペ名> -f <提出ファイル> -m "<コメント>"
kaggle competitions submit -c titanic -f submission.csv -m "1st submission"

kaggle competitions submissions -c <コンペ名>

kaggle kernels pull <username>/<notebook-name>

package main

import (
    "fmt"
    "os"
)

func main() {
    // 存在しない環境変数
    value1 := os.Getenv("NON_EXISTENT_VAR")
    fmt.Printf("NON_EXISTENT_VAR: '%s'\n", value1) // 出力: ''

    // 空文字列が設定された環境変数（事前にexport EMPTY_VAR=""で設定）
    value2 := os.Getenv("EMPTY_VAR")
    fmt.Printf("EMPTY_VAR: '%s'\n", value2) // 出力: ''

    // どちらも同じ結果になってしまう
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // 存在しない環境変数
    value1, exists1 := os.LookupEnv("NON_EXISTENT_VAR")
    fmt.Printf("NON_EXISTENT_VAR: value='%s', exists=%t\n", value1, exists1)
    // 出力: NON_EXISTENT_VAR: value='', exists=false

    // 空文字列が設定された環境変数
    value2, exists2 := os.LookupEnv("EMPTY_VAR")
    fmt.Printf("EMPTY_VAR: value='%s', exists=%t\n", value2, exists2)
    // 出力: EMPTY_VAR: value='', exists=true

    // 値が設定された環境変数
    value3, exists3 := os.LookupEnv("PATH")
    fmt.Printf("PATH exists: %t\n", exists3)
    // 出力: PATH exists: true
}

package main

import (
    "fmt"
    "os"
)

func getConfig() {
    // os.Getenvの場合：デフォルト値を設定
    dbHost := os.Getenv("DB_HOST")
    if dbHost == "" {
        dbHost = "localhost" // 空文字列でもデフォルト値を使用
    }

    // os.LookupEnvの場合：存在チェック
    dbPort, exists := os.LookupEnv("DB_PORT")
    if !exists {
        dbPort = "5432"
        fmt.Println("DB_PORT not set, using default")
    } else if dbPort == "" {
        fmt.Println("DB_PORT is set but empty!")
        // 空文字列が明示的に設定された場合の処理
    }

    fmt.Printf("DB_HOST: %s, DB_PORT: %s\n", dbHost, dbPort)
}

package main

import (
    "fmt"
    "log"

    "github.com/caarlos0/env/v10"
)

type Config struct {
    // 必須の環境変数
    DatabaseURL string `env:"DATABASE_URL,required"`

    // デフォルト値付き
    Port int `env:"PORT" envDefault:"8080"`

    // オプション（デフォルト値なし）
    RedisURL string `env:"REDIS_URL"`

    // bool型
    Debug bool `env:"DEBUG" envDefault:"false"`
}

func main() {
    cfg := Config{}
    if err := env.Parse(&cfg); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Config: %+v\n", cfg)
}

package main

import (
    "fmt"
    "os"
    "strconv"
)

type Config struct {
    DatabaseURL string
    Port        int
    RedisURL    string
    Debug       bool
}

func loadConfigManual() Config {
    cfg := Config{}

    // 必須チェックを手動で行う
    cfg.DatabaseURL = os.Getenv("DATABASE_URL")
    if cfg.DatabaseURL == "" {
        panic("DATABASE_URL is required")
    }

    // 型変換を手動で行う
    portStr := os.Getenv("PORT")
    if portStr == "" {
        cfg.Port = 8080 // デフォルト値
    } else {
        port, err := strconv.Atoi(portStr)
        if err != nil {
            panic("Invalid PORT value")
        }
        cfg.Port = port
    }

    // オプション値
    cfg.RedisURL = os.Getenv("REDIS_URL")

    // bool変換
    debugStr := os.Getenv("DEBUG")
    cfg.Debug = debugStr == "true" || debugStr == "1"

    return cfg
}

package main

import (
    "log"
    "github.com/caarlos0/env/v10"
)

type Config struct {
    DatabaseURL string `env:"DATABASE_URL,required"`
    Port        int    `env:"PORT" envDefault:"8080"`
    RedisURL    string `env:"REDIS_URL"`
    Debug       bool   `env:"DEBUG" envDefault:"false"`
}

func loadConfigWithEnv() Config {
    cfg := Config{}
    if err := env.Parse(&cfg); err != nil {
        log.Fatal(err)
    }
    return cfg
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/caarlos0/env/v10"
)

type DatabaseConfig struct {
    Host     string `env:"DB_HOST" envDefault:"localhost"`
    Port     int    `env:"DB_PORT" envDefault:"5432"`
    Username string `env:"DB_USER,required"`
    Password string `env:"DB_PASS,required"`
}

type Config struct {
    // ネストした構造体
    Database DatabaseConfig `envPrefix:"DB_"`

    // スライス型
    AllowedHosts []string `env:"ALLOWED_HOSTS" envSeparator:","`

    // 時間型
    Timeout time.Duration `env:"TIMEOUT" envDefault:"30s"`

    // カスタムパーサー
    LogLevel string `env:"LOG_LEVEL" envDefault:"info"`

    // 環境変数の存在チェック
    SecretKey string `env:"SECRET_KEY,required,unset"`
}

func main() {
    cfg := Config{}

    // パースオプション
    opts := env.Options{
        RequiredIfNoDef: true, // デフォルト値がない場合は必須
    }

    if err := env.Parse(&cfg, opts); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Config: %+v\n", cfg)
}

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/caarlos0/env/v10"
)

type AppConfig struct {
    // サーバー設定
    ServerPort int    `env:"SERVER_PORT" envDefault:"8080"`
    ServerHost string `env:"SERVER_HOST" envDefault:"0.0.0.0"`

    // データベース設定
    DatabaseURL      string `env:"DATABASE_URL,required"`
    DatabasePoolSize int    `env:"DB_POOL_SIZE" envDefault:"10"`

    // 外部サービス
    RedisURL    string `env:"REDIS_URL"`
    RedisPrefix string `env:"REDIS_PREFIX" envDefault:"myapp"`

    // セキュリティ
    JWTSecret string `env:"JWT_SECRET,required"`

    // 機能フラグ
    EnableMetrics bool `env:"ENABLE_METRICS" envDefault:"true"`
    EnableDebug   bool `env:"DEBUG" envDefault:"false"`

    // 配列設定
    TrustedProxies []string `env:"TRUSTED_PROXIES" envSeparator:"," envDefault:"127.0.0.1"`
}

func main() {
    // 環境変数の例を設定
    os.Setenv("DATABASE_URL", "postgres://user:pass@localhost/db")
    os.Setenv("JWT_SECRET", "my-secret-key")
    os.Setenv("TRUSTED_PROXIES", "192.168.1.1,10.0.0.1")

    cfg := AppConfig{}
    if err := env.Parse(&cfg); err != nil {
        log.Fatal("設定の読み込みに失敗:", err)
    }

    fmt.Printf("サーバー: %s:%d\n", cfg.ServerHost, cfg.ServerPort)
    fmt.Printf("データベース: %s\n", cfg.DatabaseURL)
    fmt.Printf("デバッグモード: %t\n", cfg.EnableDebug)
    fmt.Printf("信頼できるプロキシ: %v\n", cfg.TrustedProxies)
}

func TestWithSetenv(t *testing.T) {
    // Go 1.17以降で利用可能
    t.Setenv("DATABASE_URL", "postgres://test@localhost/testdb")
    t.Setenv("SERVER_PORT", "8080")

    // テスト終了時に自動的に元の値に復元される
    cfg, err := LoadConfig()
    if err != nil {
        t.Fatal(err)
    }

    if cfg.DatabaseURL != "postgres://test@localhost/testdb" {
        t.Errorf("期待値と異なります")
    }
}

func TestOldWay(t *testing.T) {
    // 手動でバックアップと復元
    original := os.Getenv("DATABASE_URL")
    defer func() {
        if original == "" {
            os.Unsetenv("DATABASE_URL")
        } else {
            os.Setenv("DATABASE_URL", original)
        }
    }()

    os.Setenv("DATABASE_URL", "postgres://test@localhost/testdb")

    // テスト実行
}

func TestNewWay(t *testing.T) {
    // 自動的にバックアップと復元が行われる
    t.Setenv("DATABASE_URL", "postgres://test@localhost/testdb")
    t.Setenv("SERVER_PORT", "8080")
    t.Setenv("DEBUG", "true")

    // テスト実行
    cfg, err := LoadConfig()
    if err != nil {
        t.Fatal(err)
    }

    // アサーション
    if cfg.DatabaseURL != "postgres://test@localhost/testdb" {
        t.Errorf("DATABASE_URL: 期待値=%s, 実際=%s",
            "postgres://test@localhost/testdb", cfg.DatabaseURL)
    }
}

package config

import (
    "testing"
    "github.com/caarlos0/env/v10"
)

type AppConfig struct {
    DatabaseURL string   `env:"DATABASE_URL,required"`
    ServerPort  int      `env:"SERVER_PORT" envDefault:"8080"`
    Debug       bool     `env:"DEBUG" envDefault:"false"`
    Features    []string `env:"FEATURES" envSeparator:","`
}

func TestAppConfig(t *testing.T) {
    tests := []struct {
        name     string
        envVars  map[string]string
        expected AppConfig
        wantErr  bool
    }{
        {
            name: "すべての環境変数が設定されている",
            envVars: map[string]string{
                "DATABASE_URL": "postgres://user:pass@localhost/testdb",
                "SERVER_PORT":  "3000",
                "DEBUG":        "true",
                "FEATURES":     "auth,logging,metrics",
            },
            expected: AppConfig{
                DatabaseURL: "postgres://user:pass@localhost/testdb",
                ServerPort:  3000,
                Debug:       true,
                Features:    []string{"auth", "logging", "metrics"},
            },
        },
        {
            name: "デフォルト値が使用される",
            envVars: map[string]string{
                "DATABASE_URL": "postgres://user:pass@localhost/testdb",
            },
            expected: AppConfig{
                DatabaseURL: "postgres://user:pass@localhost/testdb",
                ServerPort:  8080, // デフォルト値
                Debug:       false, // デフォルト値
                Features:    nil,
            },
        },
        {
            name: "必須項目が不足",
            envVars: map[string]string{
                "SERVER_PORT": "3000",
            },
            wantErr: true,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // t.Setenvで環境変数を設定
            for key, value := range tt.envVars {
                t.Setenv(key, value)
            }

            cfg := AppConfig{}
            err := env.Parse(&cfg)

            if tt.wantErr {
                if err == nil {
                    t.Error("エラーが期待されていましたが発生しませんでした")
                }
                return
            }

            if err != nil {
                t.Fatalf("予期しないエラー: %v", err)
            }

            // 構造体の比較
            if cfg.DatabaseURL != tt.expected.DatabaseURL {
                t.Errorf("DatabaseURL: 期待値=%s, 実際=%s",
                    tt.expected.DatabaseURL, cfg.DatabaseURL)
            }
            if cfg.ServerPort != tt.expected.ServerPort {
                t.Errorf("ServerPort: 期待値=%d, 実際=%d",
                    tt.expected.ServerPort, cfg.ServerPort)
            }
            if cfg.Debug != tt.expected.Debug {
                t.Errorf("Debug: 期待値=%t, 実際=%t",
                    tt.expected.Debug, cfg.Debug)
            }
        })
    }
}

func TestComplexConfig(t *testing.T) {
    t.Run("本番環境設定", func(t *testing.T) {
        t.Setenv("ENV", "production")
        t.Setenv("DATABASE_URL", "postgres://prod@prod-db:5432/proddb")
        t.Setenv("REDIS_URL", "redis://redis-cluster:6379")
        t.Setenv("LOG_LEVEL", "warn")
        t.Setenv("RATE_LIMIT", "1000")

        cfg, err := LoadConfig()
        if err != nil {
            t.Fatal(err)
        }

        if cfg.Env != "production" {
            t.Errorf("環境設定が正しくありません: %s", cfg.Env)
        }
    })

    t.Run("開発環境設定", func(t *testing.T) {
        t.Setenv("ENV", "development")
        t.Setenv("DATABASE_URL", "postgres://dev@localhost:5432/devdb")
        t.Setenv("LOG_LEVEL", "debug")
        t.Setenv("HOT_RELOAD", "true")

        cfg, err := LoadConfig()
        if err != nil {
            t.Fatal(err)
        }

        if cfg.Env != "development" {
            t.Errorf("環境設定が正しくありません: %s", cfg.Env)
        }
        if !cfg.HotReload {
            t.Error("開発環境ではホットリロードが有効になっている必要があります")
        }
    })
}

func TestAutoCleanup(t *testing.T) {
    // テスト前の値
    originalValue := os.Getenv("TEST_VAR")

    t.Setenv("TEST_VAR", "test_value")

    // テスト中
    if os.Getenv("TEST_VAR") != "test_value" {
        t.Error("環境変数が設定されていません")
    }

    // テスト終了後、自動的に元の値に復元される
    // 手動でのクリーンアップは不要
}

func TestParallelSafe(t *testing.T) {
    t.Run("テスト1", func(t *testing.T) {
        t.Parallel()
        t.Setenv("TEST_VAR", "value1")

        // このテストは他のテストと並列実行されても安全
        if os.Getenv("TEST_VAR") != "value1" {
            t.Error("値が正しくありません")
        }
    })

    t.Run("テスト2", func(t *testing.T) {
        t.Parallel()
        t.Setenv("TEST_VAR", "value2")

        // 他のテストの環境変数設定に影響されない
        if os.Getenv("TEST_VAR") != "value2" {
            t.Error("値が正しくありません")
        }
    })
}

func TestSimpleCode(t *testing.T) {
    // 従来の方法（煩雑）
    /*
    original := os.Getenv("DB_HOST")
    defer func() {
        if original == "" {
            os.Unsetenv("DB_HOST")
        } else {
            os.Setenv("DB_HOST", original)
        }
    }()
    os.Setenv("DB_HOST", "test-host")
    */

    // t.Setenvを使用（シンプル）
    t.Setenv("DB_HOST", "test-host")
    t.Setenv("DB_PORT", "5432")
    t.Setenv("DB_NAME", "testdb")

    // テスト実行
    config := loadDatabaseConfig()
    if config.Host != "test-host" {
        t.Error("ホスト名が正しくありません")
    }
}

//go:build go1.17
// +build go1.17

func TestWithSetenv(t *testing.T) {
    t.Setenv("VAR", "value") // Go 1.17以降でのみ利用可能
}

func TestSubtests(t *testing.T) {
    t.Run("サブテスト1", func(t *testing.T) {
        t.Setenv("ENV", "test1")
        // この設定はサブテスト終了時に自動クリーンアップされる
    })

    t.Run("サブテスト2", func(t *testing.T) {
        t.Setenv("ENV", "test2")
        // 前のサブテストの設定は影響しない
    })
}

package main

import "fmt"

// クロージャーは、関数が定義されたときの環境（スコープ）を「覚えている」仕組み
// つまり、関数の外側にある変数にアクセスできる関数のこと
func store() func(int) int {
	// 外側の関数の変数
	sum := 0
	// ↓ クロージャー関数
	return func(i int) int {
		// 内側の関数が外側の変数xを参照している
		sum += i
		return sum
	}
}

func main() {
	// クロージャーを変数に束縛する
	s1 := store()
	s2 := store()

	// クロージャーを呼び出す
	fmt.Println(s1(1))
	fmt.Println(s1(2))
	fmt.Println(s1(3))
	fmt.Println("別のクロージャー")
	fmt.Println(s2(4))
	fmt.Println(s2(5))
	fmt.Println(s2(6))
}

// 既存のビジネスロジック関数
func calculatePrice(productID string, quantity int) (float64, error) {
    // 商品価格計算のロジック
    basePrice := 100.0
    total := basePrice * float64(quantity)
    return total, nil
}

func getUserProfile(userID string) (string, error) {
    // ユーザープロファイル取得のロジック
    return fmt.Sprintf("User profile for ID: %s", userID), nil
}

func main() {
    // これはコンパイルエラーになる
    // calculatePriceのシグネチャ: func(string, int) (float64, error)
    // 期待されるシグネチャ: func(http.ResponseWriter, *http.Request)

    http.HandleFunc("/price", calculatePrice) // ❌ エラー！
    //                        ^^^^^^^^^^^
    // cannot use calculatePrice (type func(string, int) (float64, error))
    // as type func(http.ResponseWriter, *http.Request) in argument

    http.HandleFunc("/user", getUserProfile) // ❌ エラー！
    //                       ^^^^^^^^^^^^^^
    // 同様のエラー
}

func main() {
    // 無名関数でシグネチャを合わせる
    http.HandleFunc("/price", func(w http.ResponseWriter, r *http.Request) {
        // HTTPリクエストからパラメータを取得
        productID := r.URL.Query().Get("product_id")
        quantityStr := r.URL.Query().Get("quantity")
        quantity, err := strconv.Atoi(quantityStr)
        if err != nil {
            http.Error(w, "Invalid quantity", http.StatusBadRequest)
            return
        }

        // 既存関数を呼び出し
        price, err := calculatePrice(productID, quantity)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // レスポンスを返す
        fmt.Fprintf(w, "Total price: %.2f", price)
    })

    http.HandleFunc("/user", func(w http.ResponseWriter, r *http.Request) {
        // HTTPリクエストからパラメータを取得
        userID := r.URL.Query().Get("user_id")

        // 既存関数を呼び出し
        profile, err := getUserProfile(userID)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // レスポンスを返す
        fmt.Fprintln(w, profile)
    })

    http.ListenAndServe(":8080", nil)
}

// 既存の認証関数
func authenticate(username, password string) bool {
    return username == "admin" && password == "secret"
}

// 既存のデータ取得関数
func getSecretData(userID string) (map[string]interface{}, error) {
    return map[string]interface{}{
        "data": "secret information",
        "user": userID,
    }, nil
}

func main() {
    // これらは全てコンパイルエラー
    http.HandleFunc("/login", authenticate)    // ❌ エラー
    http.HandleFunc("/secret", getSecretData)  // ❌ エラー
}

func main() {
    // ログインハンドラー
    http.HandleFunc("/login", func(w http.ResponseWriter, r *http.Request) {
        username := r.FormValue("username")
        password := r.FormValue("password")

        // 既存の認証関数を使用
        if authenticate(username, password) {
            fmt.Fprintln(w, "Login successful")
        } else {
            http.Error(w, "Login failed", http.StatusUnauthorized)
        }
    })

    // シークレットデータハンドラー
    http.HandleFunc("/secret", func(w http.ResponseWriter, r *http.Request) {
        userID := r.Header.Get("User-ID")

        // 既存のデータ取得関数を使用
        data, err := getSecretData(userID)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // JSONレスポンス
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(data)
    })

    http.ListenAndServe(":8080", nil)
}

package main

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

// ❌ 問題のあるコード
func badExample() {
    var counter int
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter++ // 複数のゴルーチンが同じ変数に同時アクセス
        }()
    }

    wg.Wait()
    fmt.Printf("Counter: %d\n", counter) // 期待値1000だが、実際は不定
}

// ✅ 改善されたコード
func goodExample() {
    var counter int
    var wg sync.WaitGroup
    var mu sync.Mutex

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++ // ミューテックスで保護
            mu.Unlock()
        }()
    }

    wg.Wait()
    fmt.Printf("Counter: %d\n", counter) // 正確に1000
}

// ❌ 問題のあるコード：ループ変数の共有
func badLoopExample() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Printf("Value: %d\n", i) // 全て同じ値（5）を出力する可能性
        }()
    }

    wg.Wait()
}

// ✅ 改善されたコード：値を明示的に渡す
func goodLoopExample() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(val int) { // パラメータとして渡す
            defer wg.Done()
            fmt.Printf("Value: %d\n", val) // 期待通りの値を出力
        }(i)
    }

    wg.Wait()
}

// ❌ 問題のあるコード
func badSliceExample() {
    data := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup

    for i := 0; i < len(data); i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            data[i] = data[i] * 2 // 競合状態 + インデックス範囲外エラーの可能性
        }()
    }

    wg.Wait()
}

// ✅ 改善されたコード
func goodSliceExample() {
    data := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup

    for i := 0; i < len(data); i++ {
        wg.Add(1)
        go func(index int, slice []int) { // 値を明示的に渡す
            defer wg.Done()
            slice[index] = slice[index] * 2
        }(i, data)
    }

    wg.Wait()
}

// ❌ 危険なコード：HTTPハンドラーでの共有変数
func badWebExample() {
    requestCount := 0 // 共有変数

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go func() {
            requestCount++ // 競合状態
            fmt.Printf("Request count: %d\n", requestCount)
        }()

        fmt.Fprintln(w, "Hello World")
    })
}

// ✅ 安全なコード：適切な同期化
func goodWebExample() {
    var requestCount int64

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go func() {
            atomic.AddInt64(&requestCount, 1) // アトミック操作
            count := atomic.LoadInt64(&requestCount)
            fmt.Printf("Request count: %d\n", count)
        }()

        fmt.Fprintln(w, "Hello World")
    })
}

// ✅ チャネルを使った安全なアプローチ
func channelExample() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // ワーカーゴルーチン
    for w := 1; w <= 3; w++ {
        go func(id int) {
            for job := range jobs {
                result := job * 2 // 外部変数に依存しない
                results <- result
            }
        }(w)
    }

    // ジョブを送信
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 結果を受信
    for r := 1; r <= 9; r++ {
        <-results
    }
}

go func(val int) {
    // valは各ゴルーチンで独立
}(externalVar)

var mu sync.Mutex
go func() {
    mu.Lock()
    // 共有リソースへの安全なアクセス
    mu.Unlock()
}()

go func() {
    atomic.AddInt64(&counter, 1)
}()

ch := make(chan int)
go func() {
    ch <- computeValue() // チャネル経由で安全に通信
}()

jsonBytes, _ := json.Marshal(myStruct) // ← エンコード（Go → JSON）
json.Unmarshal(jsonBytes, &myStruct)   // ← デコード（JSON → Go）

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	// 構造体からJSONへ（エンコード）
	p := Person{Name: "Alice", Age: 30}
	jsonBytes, err := json.Marshal(p)
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON出力:", string(jsonBytes))

	// JSONから構造体へ（デコード）
	var decoded Person
	err = json.Unmarshal(jsonBytes, &decoded)
	if err != nil {
		panic(err)
	}
	fmt.Printf("構造体に戻した結果: %+v\n", decoded)
}

package main

import (
	"encoding/json"
	"fmt"
	"os"
)

type Product struct {
	ID    int     `json:"id"`
	Name  string  `json:"name"`
	Price float64 `json:"price"`
}

func main() {
	// ファイルにJSONを書き出す（エンコード）
	f, err := os.Create("product.json")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	encoder := json.NewEncoder(f)
	product := Product{ID: 1, Name: "Notebook", Price: 1299.99}
	if err := encoder.Encode(product); err != nil {
		panic(err)
	}
	fmt.Println("ファイルにJSONを書き出しました")

	// ファイルからJSONを読み込む（デコード）
	f2, err := os.Open("product.json")
	if err != nil {
		panic(err)
	}
	defer f2.Close()

	decoder := json.NewDecoder(f2)
	var p Product
	if err := decoder.Decode(&p); err != nil {
		panic(err)
	}
	fmt.Printf("読み込んだ構造体: %+v\n", p)
}

is_start = s.startswith('My')
print(is_start) # True
is_start = s.startswith('X')
print(is_start) # False

print(s.find('Mike')) # 11

print(s.rfind('Mike')) # 17

print(s.count('Mike')) # 2

print(s.capitalize()) # My name is mike. hi mike.

print(s.title()) # My Name Is Mike. Hi Mike.

print(s.upper()) # MY NAME IS MIKE. HI MIKE.

print(s.replace('Mike', 'Nancy')) # My name is Nancy. Hi Nancy.