Go

func fetchUser(id string) (*User, error) {
    row := db.QueryRow("SELECT ... WHERE id = ?", id)
    var user User
    if err := row.Scan(&user.ID, &user.Name); err != nil {
        return nil, err
    }
    return &user, nil
}

user, err := fetchUser("42")
if err != nil {
    return fmt.Errorf("ユーザーの取得に失敗: %w", err)
}
// ここから先では user が使える
fmt.Println(user.Name)

// 悪い: 元のエラー情報が失われる
return fmt.Errorf("ユーザーの取得に失敗: %v", err)
 
// 良い: 元のエラーを辿れる
return fmt.Errorf("ユーザーの取得に失敗: %w", err)

if errors.Is(err, sql.ErrNoRows) {
    // 「見つからなかった」場合の処理
}

■ %v でラップした場合
  メッセージ: プロフィールの取得に失敗: ユーザーが見つかりません
  errors.Is(err, errUserNotFound) = false <- 判定できない
 
■ %w でラップした場合
  メッセージ: プロフィールの取得に失敗: ユーザーが見つかりません
  errors.Is(err, errUserNotFound) = true  <- 判定できる

var user *User        // nil ポインタ
fmt.Println(user.Name) // 実行時に panic（クラッシュ）

user, err := fetchUser(id)
if err != nil {
    return err
}
if user == nil {
    return errors.New("ユーザーが見つかりません")
}

■ nil マップ / nil スライス（挙動が違う）
  nil マップの読み取り: 0 (ゼロ値が返る。落ちない)
  nil マップへの書き込み -> panic: assignment to entry in nil map
  nil スライスへの append: [1 2] (こちらは落ちない)
 
■ nil インターフェースの罠（Go で最も有名な事故）
  findUserBad("found")  == nil ? false <- nil を返したはずなのに false
  findUserGood("found") == nil ? true

type Order struct {
    ID       string
    UserID   string
    Subtotal int
}
 
// レシーバ (o Order) が「このメソッドは Order のもの」を表す
func (o Order) Total() int {
    return o.Subtotal + o.tax()
}
 
func (o Order) tax() int {     // 小文字始まり = パッケージ外から見えない
    return o.Subtotal / 10
}

func (o Order) SetSubtotal(v int)  { o.Subtotal = v }   // コピーを変更（元に影響しない）
func (o *Order) SetSubtotal(v int) { o.Subtotal = v }   // 元を変更する

  値レシーバで3回呼んだあと     : 0 <- 増えていない
  ポインタレシーバで3回呼んだあと: 3

type UserStore interface {
    Get(ctx context.Context, id string) (*User, error)
}

type SpannerUserStore struct { ... }
 
func (s *SpannerUserStore) Get(ctx context.Context, id string) (*User, error) { ... }
// これだけで UserStore として扱える

// service パッケージ（使う側）が、必要なものだけを定義する
package service
 
type UserStore interface {
    Get(ctx context.Context, id string) (*User, error)
}
 
func NewOrderService(users UserStore) *OrderService { ... }

go sendEmail(user)    // 完了を待たずに次へ進む

results := make(chan int)
 
go func() { results <- heavyCalculation() }()   // 送る
 
value := <-results                              // 受け取る（届くまで待つ）

counter := 0
var wg sync.WaitGroup
 
for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        counter++          // データ競合
    }()
}
wg.Wait()
fmt.Println(counter)       // 1000 にならない

var mu sync.Mutex
 
go func() {
    defer wg.Done()
    mu.Lock()
    defer mu.Unlock()
    counter++
}()

  期待値            : 100000
  保護なし          : 45478 <- 実行するたびに変わる
  sync.Mutex で保護 : 100000
  channel で集約    : 100000

func (s *OrderService) Get(ctx context.Context, id string) (*Order, error) {
    // ctx を下流にそのまま渡していく
    user, err := s.users.Get(ctx, id)
    ...
}

ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
defer cancel()
 
result, err := externalAPI.Call(ctx, payload)

■ 300ms で終わる処理に 500ms のタイムアウト
  300ms で成功: user-service の結果
 
■ 800ms かかる処理に 500ms のタイムアウト
  500ms で失敗: user-service の呼び出しを中断: context deadline exceeded
  errors.Is(err, context.DeadlineExceeded) = true