0Pricing
TypeScript Academy · Lezione

Promise<T>, tipizzazione di async/await

Comprenda la struttura di Promise , annoti le funzioni async e lavori in sicurezza con i valori ottenuti tramite await.

Promise<T>, tipizzazione di async/await è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 3 lezioni in totale.

Introduzione

Obiettivo: leggere e scrivere codice basato su Promise<T>. Imparerà a tipizzare le funzioni asincrone, attendere i valori e mantenere gli errori tipizzati.

Nozioni di base sulle Promise

Promise<T> incapsula un valore che sarà disponibile in futuro. Usi Promise quando non viene risolto alcun valore.

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

const p: Promise<void> = delay(100);

p.then(() => console.log("done"));

Tipizzazione del valore restituito da async

Le funzioni async restituiscono sempre una Promise<U>. Il corpo restituisce U, che TS incapsula automaticamente.

async function fetchNumber(): Promise<number> {
  await delay(10);
  return 42; // inferred as Promise<number>
}

fetchNumber().then(n => console.log(n.toFixed(0)));

Tipizzazione di await

await estrae il valore dalla Promise e restituisce il tipo interno, qui string, così IntelliSense funziona correttamente.

async function readUserName(id: number): Promise<string> {
  await delay(5);
  return `user-${id}`;
}

async function main(): Promise<void> {
  const name = await readUserName(7); // name: string
  console.log(name.toUpperCase());
}

main();

Tipizzazione di Promise.all

Promise.all preserva i tipi delle tuple; ogni elemento viene atteso fino a ottenere il relativo tipo interno.

async function both() {
  const [n, s] = await Promise.all([
    fetchNumber(),
    readUserName(1),
  ]);
  console.log(n, s);
}

both();

Tipizzazione degli errori

In catch, preferisca unknown. Restringa il tipo con instanceof Error o controlli personalizzati prima di accedere ai campi.

async function safe() {
  try {
    await delay(1);
    throw new Error("boom");
  } catch (e: unknown) {
    if (e instanceof Error) {
      console.error("Handled:", e.message);
    } else {
      console.error("Unknown error", e);
    }
  }
}

safe();

Verifica del tipo restituito da async

Verifica rapida: qual è il tipo restituito da una funzione async che restituisce un valore di tipo U?

Riepilogo

Riepilogo: Promise<T> incapsula valori futuri, le funzioni async restituiscono Promise<U>, await estrae i tipi e gli errori in catch dovrebbero iniziare come unknown.

Domande Frequenti

La lezione «Promise<T>, tipizzazione di async/await» è gratuita?

Sì — il testo completo di «Promise<T>, tipizzazione di async/await» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 3 lezioni in totale.

Cosa imparerò in «Promise<T>, tipizzazione di async/await»?

Comprenda la struttura di Promise , annoti le funzioni async e lavori in sicurezza con i valori ottenuti tramite await. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «Promise<T>, tipizzazione di async/await»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Promise , tipizzazione di async/await
  2. Tipizzazione degli errori (unknown), restrizione nei blocchi catch
  3. Tipi dei pattern di concorrenza (all/settled/race)
← Torna a TypeScript Academy