R Academy · Leçon

Erreurs, avertissements et messages dans R

Comprenez les trois types de signaux et le moment où chacun est déclenché.

Erreurs, avertissements et messages dans R est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Le système de conditions de R

R possède un système de conditions formel pour communiquer les problèmes. Il existe trois grandes classes de conditions : les erreurs (fatales — interrompent l’exécution), les avertissements (non fatals — affichés après la fin du code) et les messages (informatifs — envoyés vers stderr).

# Each condition type behaves differently
message('This is a message')
warning('This is a warning')
# stop() would halt here, so wrap it
tryCatch(stop('This is an error'), error = function(e) print(e))

stop() — Générer des erreurs

stop(msg) signale une condition d’erreur. L’exécution s’arrête immédiatement et le message d’erreur est affiché. Cette fonction est utilisée dans les fonctions pour interrompre l’exécution lorsque les entrées sont invalides ou qu’une situation irrécupérable est détectée.

divide <- function(x, y) {
  if (y == 0) stop('Division by zero is not allowed')
  x / y
}
tryCatch(divide(10, 0), error = function(e) cat('Error:', conditionMessage(e), '\n'))
divide(10, 2)

warning() — Avertissements non fatals

warning(msg) signale une condition d’avertissement. Contrairement aux erreurs, les avertissements n’interrompent pas l’exécution : la fonction continue et l’avertissement est enregistré. Par défaut, les avertissements sont affichés après la fin de tout le code, ou immédiatement si options(warn=1) est défini.

safe_sqrt <- function(x) {
  if (x < 0) {
    warning('Negative input; returning NaN')
    return(NaN)
  }
  sqrt(x)
}
result <- safe_sqrt(-4)
cat('Result:', result, '\n')

message() — Conditions informatives

message(msg) signale une condition de type message. Elle est envoyée vers stderr, comporte un saut de ligne automatique et peut être supprimée avec suppressMessages(). Utilisez-la pour signaler la progression dans les fonctions, et non pour les erreurs ou les avertissements.

load_data <- function(n) {
  message('Loading ', n, ' records...')
  seq_len(n)
}
data <- suppressMessages(load_data(100))
cat('Got', length(data), 'records\n')

Objets simpleError et simpleWarning

Lorsque R crée une condition, elle encapsule le message dans un objet de condition. simpleError('msg') et simpleWarning('msg') créent manuellement des objets de condition. Vous pouvez les examiner avec conditionMessage().

e <- simpleError('something went wrong')
w <- simpleWarning('this looks suspicious')
cat('Error class   :', class(e), '\n')
cat('Warning class :', class(w), '\n')
cat('Error message :', conditionMessage(e), '\n')
cat('Warning msg   :', conditionMessage(w), '\n')

conditionMessage() et conditionCall()

conditionMessage(cond) extrait le message textuel de tout objet de condition. conditionCall(cond) extrait l’appel qui a déclenché la condition. Ces deux fonctions sont utiles dans les gestionnaires d’erreurs pour journaliser les conditions ou les signaler de nouveau.

tryCatch(
  log(-1),
  warning = function(w) {
    cat('Caught warning :', conditionMessage(w), '\n')
    cat('From call      :', deparse(conditionCall(w)), '\n')
  }
)

options(warn = 2) — Traiter les avertissements comme des erreurs

Définir options(warn = 2) convertit tous les avertissements en erreurs et provoque un arrêt immédiat. C’est utile pendant le développement pour repérer rapidement le code qui génère des avertissements. Rétablissez le comportement initial avec options(warn = 0).

old_warn <- options(warn = 0)  # default: collect warnings
log(-1)  # just a warning
options(warn = 0)
tryCatch({
  options(warn = 2)
  log(-1)   # now fatal
}, error = function(e) cat('Caught as error:', conditionMessage(e), '\n'),
finally = options(old_warn))

Avertissements immédiats ou différés

Avec options(warn = 0) (valeur par défaut), les avertissements sont enregistrés et affichés à la fin. Avec options(warn = 1), chaque avertissement est affiché immédiatement lorsqu’il survient. Avec warn = 2, ils deviennent des erreurs.

# warn=1: print warnings immediately as they happen
old <- options(warn = 1)
result1 <- log(-1)
result2 <- sqrt(-4)
cat('Results:', result1, result2, '\n')
options(old)

Erreur ou avertissement : fatal ou non fatal

La distinction essentielle est la suivante : une erreur interrompt entièrement l’exécution, sauf si elle est interceptée par un gestionnaire. Un avertissement est enregistré, mais l’exécution continue. Ainsi, de mauvaises entrées peuvent produire silencieusement des résultats erronés si vous utilisez des avertissements là où des erreurs seraient nécessaires.

# With warning: execution continues
f_warn <- function(x) { if (x < 0) warning('negative'); x^2 }
cat('warn result:', f_warn(-3), '\n')  # still computes 9

# With error: execution stops
f_stop <- function(x) { if (x < 0) stop('negative'); x^2 }
tryCatch(f_stop(-3), error = function(e) cat('stopped:', e$message, '\n'))

Imbrication des conditions

Des conditions peuvent être déclenchées dans d’autres gestionnaires de conditions. Un gestionnaire d’avertissement peut appeler stop() pour transformer un avertissement en erreur. C’est un modèle courant pour rendre plus strict le code provenant de tiers.

strict_log <- function(x) {
  withCallingHandlers(
    log(x),
    warning = function(w) {
      stop(paste('Strict mode: warning treated as error:', conditionMessage(w)))
    }
  )
}
tryCatch(strict_log(-1), error = function(e) cat('Error:', e$message, '\n'))
cat('log(4) =', strict_log(4), '\n')

suppressWarnings() et suppressMessages()

suppressWarnings(expr) évalue l’expression tout en interceptant et en supprimant silencieusement tous les avertissements. suppressMessages(expr) fait de même pour les conditions de type message. Utilisez ces fonctions avec modération : supprimer les avertissements peut masquer de vrais problèmes.

# Without suppression: warning shown
result1 <- log(-1)
# With suppression: warning hidden
result2 <- suppressWarnings(log(-1))
cat('Both are NaN:', is.nan(result1), is.nan(result2), '\n')

Vérification rapide

Laquelle des affirmations suivantes concernant warning() et stop() est correcte ?

Conditions : points essentiels

Points essentiels concernant les conditions de R :

stop() = erreur = fatal, arrêt immédiat ; warning() = non fatal, l’exécution continue ; message() = informatif, envoyé vers stderr
Les trois fonctions créent des objets de condition organisés selon une hiérarchie de classes
conditionMessage(e) extrait le texte de toute condition
options(warn=1) affiche immédiatement les avertissements ; warn=2 les traite comme des erreurs
suppressWarnings() et suppressMessages() réduisent les conditions au silence
Préférez stop() pour les entrées invalides lorsque poursuivre l’exécution serait incorrect

# Summary of the three condition functions
tryCatch({
  message('Step 1 starting')
  warning('something looks odd')
  stop('cannot continue')
}, message = function(m) cat('MSG:', conditionMessage(m)),
   warning = function(w) cat('WARN:', conditionMessage(w), '\n'),
   error   = function(e) cat('ERR:', conditionMessage(e), '\n'))

Questions Fréquemment Posées

La leçon « Erreurs, avertissements et messages dans R » est-elle gratuite ?

Oui — le texte complet de « Erreurs, avertissements et messages dans R » 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 « Erreurs, avertissements et messages dans R » ?

Comprenez les trois types de signaux et le moment où chacun est déclenché. 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 1 sur 4.

Combien de temps prend la leçon « Erreurs, avertissements et messages dans R » ?

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

Erreurs, avertissements et messages dans R
tryCatch() pour récupérer les erreurs
withCallingHandlers() et redémarrages
Écrire des fonctions robustes avec stop() et warning()

← Retour à R Academy