Package `context` kanggo apa?

Question

Accepted Answer

Package **`context`** nggawa **sinyal pembatalan, tenggat waktu, lan nilai-nilai lingkup permintaan** minangka rambat ing watesing API lan goroutine. Iku mekanisme standar kanggo ngontrol umur operasi — khususe kanggo mbatalne kerja lan nyebar timeout ing sarana panggilan fungsi.

## Masalah utama sing 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.
```

## Nggawe context

```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` nggawe context anak sing bisa dibatale; sampeyan kudu `defer cancel()` kanggo mbebasno sumber dayane.

## Nanggapi 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 mriksa `ctx.Done()` (saluran sing nutup nalika pembatalan) lan mandheg cepet — iki cara pembatalan nyebur sabenere.

## Ngirim context liwat sarana panggilan (konvensi)

```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
}
```

Context mili mudhun ing tumpukan panggilan minangka parameter pisanan, supaya pembatalan tekan saben lapisan (kalebu panggilan standard-library DB/HTTP sing nampa context).

## Nilai lingkup permintaan (dipundhak ngati-ngati)

```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 penting

Package `context` dadi panggeran kanggo nulis layanan Go sing teguh lan kelas produksi — iku cara standar lan idiomatik kanggo nangani **pembatalan lan timeout** liwat goroutine lan wates API.

Nilai utamane kanggo nyegah pemborosan kerja lan kebocoran sumber daya: nalika klien putus sambung, tenggat wektu mudhun, utawa server mandheg, context nyebar sinyal pembatalan supaya kabeh goroutine lan operasi sing diawali kanggo permintaan kuwi mandheg cepet tinimbang tumindak tanpa gunane (pertahanan utama marang kebocoran goroutine).

Di Go nyoto iku ana ing mana-mana — server HTTP, panggilan basis data, gRPC, lan paling akeh pustaka jaringan nampa `context.Context` minangka parameter pisanan.

Paham carane nggawe context (`WithTimeout`/`WithCancel`), nanggapi pembatalan (`<-ctx.Done()`), aturan kudu-saut-`cancel()`, lan konvensi ngrangkai context liwat sarana panggilan dadi penting kanggo kerja backend Go serius lan topik wawancara umum.