0Pricing
R Academy · Leçon

tryCatch() pour récupérer les erreurs

Interceptez et gérez les erreurs, les avertissements et les messages avec tryCatch().

tryCatch() pour récupérer les erreurs est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Qu’est-ce que tryCatch() ?

tryCatch() permet d’exécuter une expression et d’intercepter les conditions qu’elle signale (erreurs, avertissements ou messages). Si l’expression réussit, sa valeur est renvoyée. Si elle signale une condition, le gestionnaire correspondant est appelé à la place.

result <- tryCatch({
  sqrt(16)
}, error = function(e) {
  NA
})
cat('Result:', result, '\n')

Intercepter une erreur

Lorsque l’expression située dans tryCatch() appelle stop(), l’exécution passe au gestionnaire error. Le gestionnaire reçoit l’objet de condition et renvoie sa valeur comme résultat de l’appel complet à tryCatch().

safe_divide <- function(x, y) {
  tryCatch({
    if (y == 0) stop('division by zero')
    x / y
  }, error = function(e) {
    cat('Caught error:', conditionMessage(e), '\n')
    NA
  })
}
cat(safe_divide(10, 2), '\n')
cat(safe_divide(10, 0), '\n')

Intercepter un avertissement

Le gestionnaire warning fonctionne comme le gestionnaire error, mais intercepte les conditions d’avertissement. Remarque : dès qu’un gestionnaire warning est défini dans tryCatch(), les avertissements provoquent une sortie non locale, comme les erreurs ; l’exécution ne reprend pas après l’avertissement.

result <- tryCatch({
  log(-1)
}, warning = function(w) {
  cat('Warning caught:', conditionMessage(w), '\n')
  -999
})
cat('Result:', result, '\n')

Intercepter un message

Vous pouvez également intercepter les conditions message(). Cela vous permet de récupérer et de reformater les sorties informatives de fonctions que vous ne contrôlez pas. Le gestionnaire reçoit l’objet de condition, et le texte du message comprend un saut de ligne final.

result <- tryCatch({
  message('Loading data...')
  42
}, message = function(m) {
  cat('Intercepted message:', trimws(conditionMessage(m)), '\n')
  -1
})
cat('Result:', result, '\n')

La clause finally

Le bloc finally s’exécute toujours après l’expression, qu’elle ait réussi, produit une erreur ou généré un avertissement. Utilisez-le pour le code de nettoyage, par exemple pour fermer des connexions, réinitialiser des options ou consigner la fin de l’opération.

result <- tryCatch({
  cat('Trying...\n')
  stop('oops')
}, error = function(e) {
  cat('Handled:', e$message, '\n')
  -1
}, finally = {
  cat('Finally block always runs\n')
})
cat('Result:', result, '\n')

Plusieurs gestionnaires

Vous pouvez fournir des gestionnaires pour plusieurs types de conditions dans un même appel à tryCatch(). R utilise le premier gestionnaire applicable. Si des gestionnaires error et warning sont tous deux définis, les avertissements sont interceptés avant de pouvoir devenir des erreurs.

handle_it <- function(expr_result) {
  tryCatch(expr_result,
    error   = function(e) paste('ERROR:', e$message),
    warning = function(w) paste('WARN:', w$message),
    message = function(m) paste('MSG:', trimws(m$message))
  )
}
cat(handle_it(stop('bad input')), '\n')
cat(handle_it(log(-1)), '\n')

Récupération après une erreur dans une boucle

Voici un modèle très pratique : encapsulez le corps d’une boucle dans tryCatch() afin qu’une itération échouée n’interrompe pas toute la boucle. C’est essentiel lors du traitement de fichiers, d’appels d’API ou de saisies utilisateur susceptibles d’échouer de manière imprévisible.

inputs <- list(4, -1, 0, 16, 'x')
results <- vector('list', length(inputs))
for (i in seq_along(inputs)) {
  results[[i]] <- tryCatch(
    sqrt(as.numeric(inputs[[i]])),
    warning = function(w) NA,
    error   = function(e) NA
  )
}
cat('Results:', unlist(results), '\n')

Renvoyer des valeurs par défaut pertinentes en cas d’erreur

Un modèle clair consiste à renvoyer une valeur par défaut raisonnable depuis le gestionnaire d’erreurs. La valeur renvoyée par le gestionnaire devient le résultat de tryCatch(). Renvoyer NA, NULL, 0 ou une liste par défaut fonctionne très bien.

safe_parse <- function(x) {
  tryCatch(
    as.numeric(x),
    warning = function(w) {
      cat('Cannot parse:', x, '-> using 0\n')
      0
    }
  )
}
cat(safe_parse('3.14'), '\n')
cat(safe_parse('abc'), '\n')
cat(safe_parse('99'), '\n')

Extraire le message d’erreur

Dans un gestionnaire d’erreurs, utilisez conditionMessage(e) ou l’abréviation e$message pour obtenir le texte de l’erreur. Utilisez conditionCall(e) ou e$call pour obtenir l’appel qui l’a déclenchée.

tryCatch(
  stop('file not found: data.csv'),
  error = function(e) {
    cat('Message:', conditionMessage(e), '\n')
    cat('Class  :', paste(class(e), collapse=', '), '\n')
  }
)

tryCatch() ou try()

R propose également la fonction plus simple try(expr). En cas d’erreur, elle renvoie un objet de classe 'try-error' au lieu de s’arrêter. Utilisez try() pour des instructions courtes ; utilisez tryCatch() lorsque vous avez besoin d’un contrôle complet des gestionnaires ou d’un bloc finally.

# try() returns try-error object on failure
result <- try(log('x'), silent = TRUE)
if (inherits(result, 'try-error')) {
  cat('try() caught error\n')
} else {
  cat('Result:', result, '\n')
}

Imbriquer des appels à tryCatch()

Les appels à tryCatch() peuvent être imbriqués. L’appel interne à tryCatch() intercepte d’abord les conditions ; s’il les relance, avec stop(e), le gestionnaire externe intercepte la condition relancée.

outer_result <- tryCatch({
  tryCatch({
    stop('inner error')
  }, error = function(e) {
    cat('Inner handler, re-throwing\n')
    stop(paste('Wrapped:', e$message))
  })
}, error = function(e) {
  cat('Outer handler:', e$message, '\n')
  'recovered'
})
cat('Final:', outer_result, '\n')

Vérification rapide

Dans tryCatch(), quelle clause s’exécute toujours, qu’une erreur se soit produite ou non ?

tryCatch() : points essentiels

Points essentiels concernant tryCatch() :

  • Interceptez les erreurs avec error = function(e) {...} et les avertissements avec warning = function(w) {...}
  • La valeur renvoyée par le gestionnaire devient le résultat de tryCatch()
  • finally s’exécute toujours : c’est idéal pour le nettoyage
  • Encapsulez le corps des boucles dans tryCatch() pour parcourir de manière robuste des entrées peu fiables
  • e$message ou conditionMessage(e) extrait le texte de l’erreur
  • try(expr, silent=TRUE) constitue une solution plus simple sur une seule ligne
safe_op <- function(x) {
  tryCatch({
    if (!is.numeric(x)) stop('not numeric')
    sqrt(x)
  }, error = function(e) {
    cat('Error:', e$message, '\n')
    NA
  }, finally = {
    cat('Done processing', x, '\n')
  })
}
cat(safe_op(9), '\n')
cat(safe_op('a'), '\n')

Questions Fréquemment Posées

La leçon « tryCatch() pour récupérer les erreurs » est-elle gratuite ?

Oui — le texte complet de « tryCatch() pour récupérer les erreurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « tryCatch() pour récupérer les erreurs » ?

Interceptez et gérez les erreurs, les avertissements et les messages avec tryCatch(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « tryCatch() pour récupérer les erreurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Erreurs, avertissements et messages dans R
  2. tryCatch() pour récupérer les erreurs
  3. withCallingHandlers() et redémarrages
  4. Écrire des fonctions robustes avec stop() et warning()
← Retour à R Academy