Gestion des Erreurs et des Exceptions en Typescript

Sommaire

Les Bases de la Gestion des Erreurs
Typage des Exceptions
Utilisation d'Assertions et de Gardes
Gestion Asynchrone des Erreurs

Salut à tous ! Après avoir exploré les tableaux et les objets, plongeons dans la gestion des erreurs et des exceptions en Typescript.

Imaginons une quête médiévale où nous devons gérer des situations imprévues et des dangers cachés. 🏰🛡️

Les Bases de la Gestion des Erreurs

En Typescript, comme en JavaScript, les erreurs sont gérées à l'aide des blocs try, catch et finally. Cela nous permet de capturer les erreurs et de les traiter de manière appropriée.

Blocs `try`, `catch` et `finally`

Imaginons que nous sommes des chevaliers en quête d'un trésor. Parfois, la quête peut échouer, et nous devons gérer ces situations :

function findTreasure() {
  try {
    let success = Math.random() > 0.5 // 50% de chances de succès
    if (!success) {
      throw new Error('Le dragon a brûlé la carte au trésor !')
    }
    console.log('Vous avez trouvé le trésor !')
  } catch (error) {
    console.error(`Erreur : ${error.message}`)
  } finally {
    console.log("La quête est terminée, quelle que soit l'issue.")
  }
}

findTreasure()

Créer des Erreurs Personnalisées

Nous pouvons créer des erreurs personnalisées pour mieux gérer les différents types d'erreurs qui peuvent survenir dans notre quête.

class DragonError extends Error {
  constructor(message: string) {
    super(message)
    this.name = 'DragonError'
  }
}

function battleDragon() {
  try {
    let success = Math.random() > 0.5 // 50% de chances de succès
    if (!success) {
      throw new DragonError('Le dragon vous a vaincu !')
    }
    console.log('Vous avez vaincu le dragon !')
  } catch (error) {
    if (error instanceof DragonError) {
      console.error(`Erreur spécifique : ${error.message}`)
    } else {
      console.error(`Erreur : ${error.message}`)
    }
  }
}

battleDragon()

Typage des Exceptions

En Typescript, nous pouvons typer les exceptions pour améliorer la sécurité et la clarté de notre code.

Fonction de Quête Typée

Définissons une fonction de quête typée qui peut lancer différentes erreurs :

interface QuestResult {
  success: boolean
  message: string
}

function embarkOnQuest(): QuestResult {
  try {
    let success = Math.random() > 0.5
    if (!success) {
      throw new DragonError('La quête a échoué à cause du dragon !')
    }
    return { success: true, message: 'La quête a été couronnée de succès !' }
  } catch (error) {
    if (error instanceof DragonError) {
      return { success: false, message: error.message }
    }
    return { success: false, message: 'Une erreur inconnue est survenue.' }
  }
}

let questResult = embarkOnQuest()
console.log(questResult)

Utilisation d'Assertions et de Gardes

Les assertions de type et les gardes de type nous permettent de vérifier les types à l'exécution et de gérer les erreurs plus précisément.

Assertions de Type

Imaginons que nous avons une fonction qui peut retourner différents types de résultats :

type QuestOutcome = QuestResult | { treasure: string }

function completeQuest(): QuestOutcome {
  let success = Math.random() > 0.5
  if (success) {
    return {
      success: true,
      message: 'Vous avez trouvé le trésor !',
      treasure: 'Or et bijoux',
    }
  }
  return { success: false, message: 'La quête a échoué.' }
}

let outcome = completeQuest()

if ((outcome as QuestResult).success) {
  console.log((outcome as QuestResult).message)
} else {
  console.log((outcome as QuestOutcome).message)
}

Gardes de Type

Les gardes de type permettent de vérifier les types plus élégamment :

function isQuestResult(outcome: QuestOutcome): outcome is QuestResult {
  return (outcome as QuestResult).success !== undefined
}

if (isQuestResult(outcome)) {
  console.log(outcome.message)
} else {
  console.log(outcome.message)
}

Gestion Asynchrone des Erreurs

Les quêtes peuvent également impliquer des opérations asynchrones. Typescript facilite la gestion des erreurs asynchrones avec async et await.

Gestion des Erreurs Asynchrones

Imaginons une quête qui nécessite une attente (comme chercher un trésor caché) :

async function searchForTreasure(): Promise<QuestResult> {
  try {
    let success = Math.random() > 0.5
    await new Promise((resolve) => setTimeout(resolve, 1000)) // Simule une attente
    if (!success) {
      throw new DragonError('Le dragon a gardé le trésor !')
    }
    return { success: true, message: 'Vous avez trouvé le trésor caché !' }
  } catch (error) {
    if (error instanceof DragonError) {
      return { success: false, message: error.message }
    }
    return { success: false, message: 'Une erreur inconnue est survenue.' }
  }
}

searchForTreasure().then((result) => console.log(result))