TypeScript Sleep: TypeScript'te Bekleme ve Gecikme

TypeScript'te yerleşik bir sleep yoktur. Gecikmeden sonra setTimeout'un resolve ettiği bir Promise<void> döndüren bir fonksiyon yazın, sonra onu bir async fonksiyonun içinde await edin:

const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

async function main() {
    console.log("start");
    await sleep(300); // pause this function for 300 ms
    console.log("300 ms later");
}
main();

await sleep(300) yalnızca main fonksiyonunu duraklatır. Program donmaz: o beklerken timer'lar, diğer async fonksiyonlar ve I/O çalışmaya devam eder.

sleep Fonksiyonu Nasıl Çalışır

setTimeout(resolve, ms), resolve fonksiyonunun ms milisaniye sonra çağrılmasını planlar ve resolve çağrısı promise'i sonuçlandırır. O promise üzerindeki await, async fonksiyonu o ana kadar askıya alır.

<void> tip argümanı önemlidir. Tek başına bir new Promise(...) tipini resolve çağrılarından çıkarmaz, bu yüzden bu argüman olmadan sleep, Promise<unknown> döndürürdü. void ise resolve fonksiyonunun değersiz çağrılmasına izin veren şeydir: bir Promise<number> içinde argümansız resolve() bir derleme hatasıdır. Fonksiyonun belirtilmiş bir dönüş tipi varsa tip argümanı oraya yazılabilir:

function sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
}

// A variant that resolves with a value after the delay.
function delay<T>(ms: number, value: T): Promise<T> {
    return new Promise((resolve) => setTimeout(() => resolve(value), ms));
}

async function main() {
    await sleep(100);
    const answer = await delay(100, 42); // answer: number
    console.log(answer + 1); // 43
}
main();

setTimeout kesin bir süre değil, bir alt sınır garanti eder: callback, gecikme geçtiğinde ve event loop boş olduğunda çalışır. Birkaç milisaniyelik sapma bekleyin.

Döngü İçinde Beklemek

Bir for ya da for...of döngüsünün içindeki await sleep(), iterasyonlar arasında duraklar; işin hızını böyle ayarlarsınız (rate limit'ler, polling, terminaldeki animasyonlar):

const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

async function countdown(from: number): Promise<void> {
    for (let i = from; i > 0; i--) {
        console.log(i);
        await sleep(200);
    }
    console.log("liftoff");
}

countdown(3);

Bu forEach içinde çalışmaz: forEach her async callback'in döndürdüğü promise'i yok sayar, bu yüzden bütün iterasyonlar aynı anda başlar ve hiçbir şey beklemez. async/await sayfasında anlatıldığı gibi bir for ya da for...of döngüsü kullanın.

Gecikmeyle Yeniden Deneme

Yaygın bir gerçek kullanım: bir işlemi deneyin, başarısız olursa bekleyip yeniden deneyin ve her seferinde bekleme süresini ikiye katlayın (exponential backoff).

const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

async function retry<T>(fn: () => Promise<T>, attempts: number, baseMs: number): Promise<T> {
    for (let i = 1; ; i++) {
        try {
            return await fn();
        } catch (e) {
            if (i >= attempts) throw e;
            const wait = baseMs * 2 ** (i - 1);
            console.log(`attempt ${i} failed, waiting ${wait} ms`);
            await sleep(wait);
        }
    }
}

let calls = 0;
async function flakyRequest(): Promise<string> {
    calls++;
    if (calls < 3) throw new Error("network error");
    return "response body";
}

async function main() {
    const body = await retry(flakyRequest, 5, 50);
    console.log(body); // response body
}
main();

try içindeki return await fn() önemlidir: await olmadan, reject olan bir promise catch onu göremeden döndürülürdü.

İptal Edilebilir sleep

Düz bir sleep kesilemez. Beklemeyi erken bitirmek için (kullanıcı İptal'e bastı, kapanış başladı) bir AbortSignal verin ve sinyal geldiğinde timer'ı temizleyin:

function sleep(ms: number, signal?: AbortSignal): Promise<void> {
    return new Promise((resolve, reject) => {
        if (signal?.aborted) return reject(new Error("aborted"));
        const timer = setTimeout(resolve, ms);
        signal?.addEventListener("abort", () => {
            clearTimeout(timer);
            reject(new Error("aborted"));
        }, { once: true });
    });
}

async function main() {
    const controller = new AbortController();
    setTimeout(() => controller.abort(), 50); // cancel after 50 ms

    try {
        await sleep(5000, controller.signal);
        console.log("slept the full 5 s");
    } catch (e) {
        if (e instanceof Error) console.log("woke early:", e.message); // woke early: aborted
    }
}
main();

Uzun timer temizlendiği için program abort'tan hemen sonra sonlanır. clearTimeout olmasaydı Node, 5 saniye dolana kadar çalışmaya devam ederdi.

Node'un Yerleşik Promise Timer'ları

Node, node:timers/promises modülünde setTimeout'un promise sürümünü sunar; bu yüzden Node kodunda yardımcı fonksiyonu yazmak yerine onu import edebilirsiniz. Resolve olacağı bir değeri ve bir AbortSignal'ı da kabul eder:

import { setTimeout as sleep } from "node:timers/promises";

async function main() {
    await sleep(1000);                              // wait one second
    const result = await sleep(500, "done");        // resolves with "done"
    const ac = new AbortController();
    await sleep(10_000, undefined, { signal: ac.signal }); // cancellable
}

Tipler @types/node paketinden gelir (npm i -D @types/node). Bu modül tarayıcılarda yoktur; orada taşınabilir seçim tek satırlık yardımcı fonksiyondur.

Bloklayan sleep Yoktur

Thread'leri olan dillerde mevcut thread'i bloklayan bir sleep bulunur. JavaScript ise kodunuzu bir event loop ile tek bir thread üzerinde çalıştırır, bu yüzden bloklayan bir sleep geri kalan her şeyi dondururdu: hiçbir timer tetiklenmez, hiçbir ağ yanıtı işlenmez ve tarayıcıda sayfa yanıt vermez olur. Saat belirli bir zamanı geçene kadar dönen meşgul bir döngü tam olarak bunu yapar ve asla doğru araç değildir.

JavaScript ve TypeScript'te bekleme async sleep ile olur: fonksiyon askıya alınır, thread serbest kalır ve timer tetiklendiğinde fonksiyon kaldığı yerden devam eder. Atomics.wait gerçekten bloklayabilir, ancak yalnızca bir SharedArrayBuffer üzerinde ve tarayıcılar bunu ana thread'de yasaklar; gecikme için değil, worker thread'lerini koordine etmek için vardır.