რის აგებად გამოიყენება `context` პაკეტი?

Question

Accepted Answer

**`context`** პაკეტი გადააქვს **გაუქმების სიგნალებს, ვადებს და მოთხოვნის სფეროს მნიშვნელობებს** API საზღვრებისა და goroutine-ების მეშვეობით. ეს არის ოპერაციების ცხოვრების ხანგრძლივობის კონტროლის სტანდარტული მექანიზმი — განსაკუთრებით სამუშაოს გაუქმებისა და timeout-ების ფუნქციის გამოძახების ჯაჭვის მეშვეობით გავრცელების მიზნით.

## ძირითადი პრობლემა, რომელიც მას ხსნის

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

## 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` წარმოშობს შვილი context-ს, რომელიც შეიძლება გაუქმდეს; უნდა შეასრულოთ `defer cancel()` მის რესურსების გასათავისუფლებლად.

## გაუქმების საპასუხოდ რეაგირება

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

ფუნქციები ამოწმებენ `ctx.Done()` (არხი, რომელიც იხურება გაუქმების დროს) და დაუყოვნებლივ ჩერდებიან — ეს არის ის, თუ როგორ ვრცელდება გაუქმება სინამდვილეში.

## Context-ის გადაცემა გამოძახების ჯაჭვის მეშვეობით (კონვენცია)

```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 ნაკადი იცვლება ზევზე გამოძახების სტეკის პირველი პარამეტრის სახით, ასე რომ გაუქმება ღწაფობს ყველა ფენამდე (მათ შორის სტანდარტული ბიბლიოთეკის DB/HTTP გამოძახები, რომლებიც მეიძახებენ context-ს).

## მოთხოვნის სფეროს მნიშვნელობები (გამოიყენეთ თანმიმდევრობით)

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

## რატომ არის ეს მნიშვნელოვანი

`context` პაკეტი არის მყარი, წარმოსაბანი Go სერვისების დაწერის საფუძველი — ეს არის სტანდარტული, იდიომატური გზა **გაუქმების და timeout-ების** სამართავად goroutine-ებისა და API საზღვრების მეშვეობით.

მის ძირითადი მნიშვნელობა არის ფლანგური სამუშაოს და რესურსების გაჟონვის შეჩერება: როდესაც კლიენტი კავშირგაწყვეტს, ვადა ამოიწურება ან სერვერი თოვიდან, context ვრცელი ხდება გაუქმების სიგნალი ისე, რომ ყველა goroutine და ოპერაციები, რომლებიც იმ მოთხოვნისთვის დაიწყო, დაუყოვნებლივ გაჩერდებიან იმის ნაცვლად, რომ უსარგებლოდ გაგრძელდეს (goroutine გაჟონვის წინააღმდეგ მნიშვნელოვანი დაცვა).

ეს ხშირი რეალურ Go-ში — HTTP სერვერი, მონაცემთა ბაზის გამოძახებები, gRPC და უმეტეს ქსელური ბიბლიოთეკები კი `context.Context` პირველი პარამეტრის სახით.

გაგება, თუ როგორ შექმნან context (`WithTimeout`/`WithCancel`), როგორ იპასუხოთ გაუქმებას (`<-ctx.Done()`), `cancel()` გამოძახების სავალდებულო წესი, და კონვენცია context-ის გამოძახების ჯაჭვის მეშვეობით დენიფიკაცია აუცილებელია ნებისმიერი სერიოზული Go ბეკენდის მუშაობისა და გარკვევილი ინტერვიუს თემის ერთდროულობისთვის.