withCallingHandlers() et redémarrages
Utilisez withCallingHandlers() pour gérer les conditions non locales.
withCallingHandlers() et redémarrages est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
tryCatch ou withCallingHandlers
La différence essentielle est la suivante : tryCatch() établit une sortie non locale : une fois la condition interceptée, le contrôle sort de l’expression et n’y revient pas. withCallingHandlers() conserve la pile d’appels intacte et peut reprendre l’exécution après le traitement.
# tryCatch: execution does NOT continue after warning
tryCatch({
warning('first')
cat('This line is never reached\n')
}, warning = function(w) cat('tryCatch caught:', w$message, '\n'))withCallingHandlers conserve l’exécution
Avec withCallingHandlers(), le gestionnaire s’exécute, mais l’exécution se poursuit après le signalement de la condition, sauf si le gestionnaire lui-même génère une erreur ou invoque une reprise. La pile d’appels n’est pas déroulée.
withCallingHandlers({
warning('first warning')
cat('Execution continues here\n')
warning('second warning')
cat('And here too\n')
}, warning = function(w) {
cat('Handler saw:', w$message, '\n')
invokeRestart('muffleWarning')
})Reprise muffleWarning
L’appel à invokeRestart('muffleWarning') dans un gestionnaire d’avertissements empêche l’avertissement d’être affiché par le gestionnaire par défaut de R. Sans cet appel, après l’exécution de votre gestionnaire, R afficherait tout de même l’avertissement via son mécanisme par défaut.
# Without muffleWarning: warning still shows after handler
withCallingHandlers({
warning('test')
}, warning = function(w) {
cat('Handler ran\n')
# no muffleWarning: default handler still fires
})Reprise muffleMessage
De même, invokeRestart('muffleMessage') dans un gestionnaire de messages réduit au silence le message après son traitement par votre gestionnaire personnalisé. C’est le mécanisme utilisé par suppressMessages().
withCallingHandlers({
message('Progress: 50%')
message('Progress: 100%')
}, message = function(m) {
cat('[LOG]', trimws(m$message), '\n')
invokeRestart('muffleMessage')
})Consigner les avertissements sans interrompre l’exécution
Une utilisation pratique de withCallingHandlers() consiste à recueillir les avertissements dans un vecteur de journalisation tout en laissant le code aller jusqu’à son terme. tryCatch() s’arrêterait au premier avertissement ; withCallingHandlers() les recueille tous.
warnings_log <- character(0)
result <- withCallingHandlers({
x <- log(-1)
y <- sqrt(-4)
c(x, y)
}, warning = function(w) {
warnings_log <<- c(warnings_log, w$message)
invokeRestart('muffleWarning')
})
cat('Warnings logged:', length(warnings_log), '\n')
cat(warnings_log, sep = '\n')Le concept d’invokeRestart()
Les reprises sont des stratégies de récupération prédéfinies que le code signalant la condition peut proposer. invokeRestart(name) sélectionne l’une de ces stratégies. Les reprises intégrées comprennent 'muffleWarning' et 'muffleMessage' ; vous pouvez en définir de personnalisées avec withRestarts().
# withRestarts() offers named recovery options
divide_safe <- function(x, y) {
withRestarts(
{
if (y == 0) stop('division by zero')
x / y
},
use_zero = function() 0,
use_na = function() NA
)
}
# A handler can pick a restart
withCallingHandlers(
divide_safe(10, 0),
error = function(e) invokeRestart('use_zero')
)Combiner withCallingHandlers et tryCatch
Vous pouvez imbriquer les deux : utilisez withCallingHandlers() à l’extérieur pour journaliser ou compter les conditions, et tryCatch() à l’intérieur pour fournir une valeur de remplacement. Le gestionnaire externe voit la condition en premier.
n_warnings <- 0L
result <- withCallingHandlers(
tryCatch(log(-1), warning = function(w) -999),
warning = function(w) {
n_warnings <<- n_warnings + 1L
cat('Logged warning #', n_warnings, '\n')
}
)
cat('Result:', result, '\n')Classes de conditions personnalisées
Vous pouvez créer des classes de conditions personnalisées en appelant structure() sur une liste dont la classe est c('myError', 'error', 'condition'). Les gestionnaires effectuent la correspondance selon la classe ; les classes personnalisées vous permettent donc d’intercepter certains types d’erreurs sans intercepter toutes les erreurs.
my_error <- function(msg, data = NULL) {
structure(
class = c('my_error', 'error', 'condition'),
list(message = msg, data = data)
)
}
tryCatch(
stop(my_error('custom error', data = 42)),
my_error = function(e) cat('Custom handler, data=', e$data, '\n'),
error = function(e) cat('Generic handler\n')
)Quand utiliser withCallingHandlers
Utilisez withCallingHandlers() lorsque vous souhaitez observer ou journaliser des conditions sans interrompre l’exécution. Utilisez tryCatch() lorsque vous voulez récupérer une condition et renvoyer une autre valeur. Ces fonctions répondent à des besoins différents.
# withCallingHandlers: observe all, continue
withCallingHandlers(
for (x in c(4, -1, 9, -4)) cat(suppressWarnings(sqrt(x)), ''),
warning = function(w) cat('[warn]', '')
)
cat('\n')La chaîne de signalement des conditions
Lorsqu’une condition est signalée, R remonte la pile d’appels à la recherche de gestionnaires. Les gestionnaires de withCallingHandlers() s’exécutent dans le contexte dynamique, avec la pile d’appels intacte. Les gestionnaires de tryCatch() s’exécutent après le déroulement de la pile : le contexte d’origine a disparu.
# Demonstrate: withCallingHandlers handler can see full stack
f <- function() {
withCallingHandlers(
g(),
warning = function(w) {
cat('Caught in f, stack length:', sys.nframe(), '\n')
invokeRestart('muffleWarning')
}
)
}
g <- function() warning('from g')
f()Implémentation de suppressWarnings()
suppressWarnings(expr) équivaut essentiellement à withCallingHandlers(expr, warning = function(w) invokeRestart('muffleWarning')). Comprendre cela vous permet de créer vos propres variantes qui réduisent au silence uniquement certains types d’avertissements.
# Suppress only NaN warnings, not others
suppress_nan_warn <- function(expr) {
withCallingHandlers(expr, warning = function(w) {
if (grepl('NaN', conditionMessage(w)))
invokeRestart('muffleWarning')
})
}
suppress_nan_warn(log(-1)) # NaN warning suppressed
tryCatch(
suppress_nan_warn(warning('other issue')),
warning = function(w) cat('Other warning kept:', w$message, '\n')
)Vérification rapide
Quelle est la principale différence entre withCallingHandlers() et tryCatch() ?
Reprises : points essentiels
Points essentiels concernant withCallingHandlers et les reprises :
withCallingHandlers()= gestionnaire local, pile d’appels intacte, poursuite possible de l’exécutiontryCatch()= sortie non locale, pile déroulée, possibilité de renvoyer une autre valeurinvokeRestart('muffleWarning')empêche l’affichage par défaut de l’avertissementinvokeRestart('muffleMessage')empêche l’affichage par défaut du message- Utilisez
withCallingHandlers()pour recueillir ou journaliser toutes les conditions sans interrompre l’exécution - Les classes de conditions personnalisées permettent d’intercepter sélectivement certains types d’erreurs
log_vec <- character(0)
withCallingHandlers({
message('start')
warning('low memory')
message('end')
}, message = function(m) {
log_vec <<- c(log_vec, paste('MSG:', trimws(m$message)))
invokeRestart('muffleMessage')
}, warning = function(w) {
log_vec <<- c(log_vec, paste('WARN:', w$message))
invokeRestart('muffleWarning')
})
cat(log_vec, sep = '\n')
Apprends R avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 43
- Leçons
- 159
Questions Fréquemment Posées
La leçon « withCallingHandlers() et redémarrages » est-elle gratuite ?
Oui — le texte complet de « withCallingHandlers() et redémarrages » 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 « withCallingHandlers() et redémarrages » ?
Utilisez withCallingHandlers() pour gérer les conditions non locales. 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 3 sur 4.
Combien de temps prend la leçon « withCallingHandlers() et redémarrages » ?
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()