TypeScript Academy · Lezione

Gestione degli errori nel codice TypeScript asincrono

Gestisca gli errori asincroni con wrapper e utility tipizzati.

Lezione 4 di 413 passaggi

Gestione degli errori nel codice TypeScript asincrono è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. 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 4 lezioni in totale.

Benvenuto

Le funzioni asincrone rendono più complessa la gestione degli errori. TypeScript garantisce che le rejections delle Promise vengano gestite correttamente.

Try-catch con async/await

Racchiuda le chiamate await in try-catch per gestire le rejections delle Promise.

async function loadUser(id: number): Promise<User> {
  try {
    return await api.getUser(id);
  } catch (err: unknown) {
    if (err instanceof Error) throw new AppError(err.message);
    throw new AppError('Unknown error');
  }
}

Errori di Promise.all

Promise.all viene rifiutata alla prima rejection. La racchiuda in try-catch.

try {
  const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);
} catch (err) { /* one or both failed */ }

Promise.allSettled

allSettled restituisce sia i risultati riusciti sia gli errori senza generare eccezioni.

const results = await Promise.allSettled([getUser(1), getPosts(1)]);
results.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value);
  else console.error(r.reason);
});

Result asincrono tipizzato

Combini l'asincronia con il pattern Result per gestire esplicitamente gli errori.

async function safeGet<T>(fn: () => Promise<T>): Promise<Result<T>> {
  try { return { ok: true, value: await fn() }; }
  catch (e) { return { ok: false, error: e as Error }; }
}

Rejections non gestite

Ascolti le rejections non gestite in Node.js per evitare arresti anomali.

process.on('unhandledRejection', (reason: unknown) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Timeout con Promise.race

Implementi un pattern di timeout tipizzato con Promise.race.

function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), ms));
  return Promise.race([promise, timeout]);
}

Pattern di retry

Implementi un retry asincrono tipizzato con errori tipizzati.

async function retry<T>(fn: () => Promise<T>, times: number): Promise<T> {
  for (let i = 0; i < times; i++) {
    try { return await fn(); } catch (e) { if (i === times - 1) throw e; }
  }
  throw new Error('Unreachable');
}

Gestione degli errori concorrenti

Gestisca gli errori durante l'esecuzione di operazioni asincrone concorrenti.

const [userResult, postsResult] = await Promise.allSettled([
  getUser(id).then(u => ({ ok: true, value: u })).catch(e => ({ ok: false, error: e })),
  getPosts(id).then(p => ({ ok: true, value: p })).catch(e => ({ ok: false, error: e })),
]);

Propagazione degli errori con AsyncQueue

Gli errori negli iteratori asincroni vengono propagati correttamente con for-await.

async function* generate() {
  yield await fetchA();
  yield await fetchB(); // error here stops the loop
}
for await (const item of generate()) { process(item); }

Middleware per errori tipizzati in Next.js

Utilizzi error boundary tipizzati nelle server action.

'use server';
async function createUser(data: CreateUserDto): Promise<Result<User>> {
  return safeGet(() => db.user.create({ data }));
}

Verifica rapida

Che cosa accade se non cattura una Promise rifiutata in una funzione async/await?

Rispondi nella lezione interattiva

Riepilogo

Gestione degli errori nel codice TypeScript asincrono: ha appreso i concetti chiave di questo argomento e come applicarli in progetti TypeScript reali.

Gratis per iniziare

Impara TypeScript con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 101
Lezioni: 352

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Gestione degli errori nel codice TypeScript asincrono» è gratuita?

Sì — il testo completo di «Gestione degli errori nel codice TypeScript asincrono» è 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 4 lezioni in totale.

Cosa imparerò in «Gestione degli errori nel codice TypeScript asincrono»?

Gestisca gli errori asincroni con wrapper e utility tipizzati. 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 4 di 4.

Quanto tempo richiede la lezione «Gestione degli errori nel codice TypeScript asincrono»?

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

Classi e gerarchie di errori tipizzate
Il pattern Result: Ok ed Err
Restringimento degli errori intercettati (unknown o Error)
Gestione degli errori nel codice TypeScript asincrono

← Torna a TypeScript Academy