Untuk apa pakej `context` digunakan?

Question

Accepted Answer

Pakej **`context`** membawa **sinyal pembatalan, tenggat waktu, dan nilai bersisipan permintaan** merentasi sempadan API dan goroutine. Ini adalah mekanisme standard untuk mengawal seumur hidup operasi — terutamanya untuk membatalkan kerja dan menyebarkan masa muat melalui rantai panggilan fungsi.

## Masalah utama yang diselesaikan

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Membuat konteks

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` memperoleh konteks anak yang boleh dibatalkan; anda mesti `defer cancel()` untuk membebaskan sumbernya.

## Membalas pembatalan

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Fungsi menyemak `ctx.Done()` (saluran yang ditutup pada pembatalan) dan berhenti segera — inilah cara pembatalan sebenarnya merambat.

## Melewatkan konteks melalui rantai panggilan (konvensyen)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Konteks mengalir ke bawah tumpukan panggilan sebagai parameter pertama, jadi pembatalan mencapai setiap lapisan (termasuk panggilan DB/HTTP pustaka standard yang menerima konteks).

## Nilai bersisipan permintaan (gunakan dengan jimat)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## Mengapa ia penting

Pakej `context` adalah asas untuk menulis perkhidmatan Go yang tangguh dan gred pengeluaran — ia adalah cara standard dan idiomatik untuk mengendalikan **pembatalan dan masa muat** merentasi goroutine dan sempadan API.

Nilai utamanya adalah mencegah pemborosan kerja dan kebocoran sumber: apabila klien terputus, masa muat berlalu, atau pelayan dimatikan, konteks menyebarkan sinyal pembatalan supaya semua goroutine dan operasi yang dimulakan untuk permintaan itu berhenti dengan segera daripada berjalan berguna (pertahanan utama terhadap kebocoran goroutine).

Ia tersebar luas dalam Go sebenar — pelayan HTTP, panggilan pangkalan data, gRPC, dan kebanyakan perpustakaan rangkaian menerima `context.Context` sebagai parameter pertama.

Memahami cara membuat konteks (`WithTimeout`/`WithCancel`), cara membalas pembatalan (`<-ctx.Done()`), peraturan `cancel()` wajib dipanggil, dan konvensyen menyebarkan konteks melalui rantai panggilan adalah penting untuk sebarang kerja backend Go yang serius dan topik temu duga yang biasa.