რა სტილიტები ეხმარება async კოდის სამუშაოდ (promisify, AbortController)?

Question

Accepted Answer

Node უზრუნველყოფს რამდენიმე სტილიტებს, რომლებიც async კოდს უფრო깔끔სა და კონტროლირებადს ხდის — დაძველებული callback API-ების Promise-ებად გარდაქმნა, ოპერაციების გაუქმება და მრავალი async დავალების კოორდინაცია.

## promisify — callback API-ების Promise-ებად გარდაქმნა

```js
import { promisify } from "util";
import fs from "fs";

// turn an error-first callback function into a Promise-returning one
const readFileAsync = promisify(fs.readFile);
const data = await readFileAsync("file.txt", "utf8"); // now awaitable
```

`promisify` ჩამკვრელდება ნებისმიერი სტანდარტული `(args..., (err, result) => {})` callback ფუნქციაში, რათა თქვენ შეძლოთ მის `await` გამოყენება — სასარგებლო ძველი ბიბლიოთეკებისთვის, რომლებიც Promises-ის წინას არიან. (ბევრი ჩაშენებული პარამეტრი ახლა პირდაპირ promise ვერსიებს გთავაზობს, მაგ. `fs/promises`.)

## AbortController — async ოპერაციების გაუქმება

```js
const controller = new AbortController();

// pass the signal to a cancellable operation
const promise = fetch("https://api.example.com", { signal: controller.signal });

// cancel it (e.g. on timeout or user navigation)
setTimeout(() => controller.abort(), 5000); // abort after 5s

try {
  await promise;
} catch (err) {
  if (err.name === "AbortError") console.log("request cancelled");
}
```

`AbortController` უზრუნველყოფს სტანდარტულ გზას **გაუქმება** მფრენი ოპერაციები (fetch, timers, streams, მრავალი ბიბლიოთეკა) — აუცილებელი timeouts-ისა და უსაფუძვლო სამუშაოს თავიდან აცილებისთვის, როდესაც შედეგი აღარ გჭირდებათ.

## Promise კომბინატორები — მრავალი async დავალების კოორდინაცია

```js
// run in parallel, wait for ALL (fails fast if any rejects)
const [a, b, c] = await Promise.all([getA(), getB(), getC()]);

// wait for all, get each result OR error (never short-circuits)
const results = await Promise.allSettled([getA(), getB()]);

// the first to settle (resolve OR reject) wins
const fastest = await Promise.race([fetchPrimary(), fetchBackup()]);

// the first to FULFILL (ignores rejections until one succeeds)
const first = await Promise.any([source1(), source2()]);
```

ეს კომბინატორები გამოხატავენ საერთო ნიმუშებს: `all` პარალელური ელემენტებისა და ლოდინის জন্য, `allSettled` როდესაც დაგჭირდებათ ყველა შედეგი დამთხვევის აღმოფხვრის მიუხედავად, `race` timeouts-ისა და ყველაზე სწრაფი მოსახლეობისთვის, `any` საცავი წყაროებისთვის.

## setTimeout როგორც Promise (თანამედროვე)

```js
import { setTimeout as sleep } from "timers/promises";
await sleep(1000); // await a delay without wrapping in a Promise manually
```

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

ეს სტილიტები რეალური세계 async Node კოდს უფრო깔끔სა და უფრო მყარს ხდის: `promisify` დაძველებული callback API-ებს async/await-ში ხიდის, `AbortController` დამატებული გაუქმება და timeouts-ი (დაკიდებული ან უსაფუძვლო ოპერაციების თავიდან აცილება), და Promise კომბინატორები (`all`/`allSettled`/`race`/`any`) გამოხატავენ საერთო კოორდინაციის ნიმუშებს ლაკონიურად და სწორად.

მათი ცოდნა მოგცემთ უნარს პარალელიზმი, გაუქმება და საცავი ელეგანტურად შეასრულოთ ის გამოგონების ნაცვლად — საერთო მოთხოვნილებები ნებისმიერ არამდაბალ async აპლიკაციაში.