R Academy · Lezione

tryCatch() per il recupero dagli errori

Catturi e gestisca errori, avvisi e messaggi con tryCatch().

tryCatch() per il recupero dagli errori è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 2 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 R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cos'è tryCatch()?

tryCatch() consente di eseguire un'espressione e intercettare le condizioni che segnala, inclusi errori, avvisi e messaggi. Se l'espressione ha esito positivo, ne viene restituito il valore. Se segnala una condizione, viene chiamato il gestore corrispondente.

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

Intercettare un errore

Quando l'espressione all'interno di tryCatch() chiama stop(), l'esecuzione passa al gestore error. Il gestore riceve l'oggetto condizione e restituisce il proprio valore come risultato dell'intera chiamata a 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')

Intercettare un avviso

Il gestore warning funziona come quello error, ma intercetta le condizioni di avviso. Nota: una volta definito un gestore warning in tryCatch(), gli avvisi causano un'uscita non locale proprio come gli errori: l'esecuzione non riprende dopo l'avviso.

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

Intercettare un messaggio

È possibile intercettare anche le condizioni message(). Questo consente di intercettare e riformattare l'output informativo delle funzioni che non si controllano. Il gestore riceve l'oggetto condizione e il testo del messaggio include un carattere di nuova riga finale.

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

La clausola finally

Il blocco finally viene sempre eseguito dopo l'espressione, sia che abbia avuto esito positivo, sia che abbia generato un errore o un avviso. Lo si utilizza per il codice di pulizia, ad esempio per chiudere connessioni, ripristinare opzioni o registrare il completamento.

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')

Più gestori

È possibile fornire gestori per più tipi di condizione in una singola chiamata a tryCatch(). R utilizza il primo gestore applicabile. Se sono definiti sia un gestore error sia un gestore warning, gli avvisi vengono intercettati prima che possano diventare errori.

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')

Recupero dagli errori in un ciclo

Un modello molto pratico consiste nel racchiudere il corpo di un ciclo in tryCatch(), così che un'iterazione non riuscita non interrompa l'intero ciclo. Questo è essenziale quando si elaborano file, chiamate API o input dell'utente che possono fallire in modo imprevedibile.

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')

Restituire valori predefiniti significativi in caso di errore

Un modello ordinato consiste nel restituire un valore predefinito sensato dal gestore degli errori. Il valore restituito dal gestore diventa il risultato di tryCatch(). Restituire NA, NULL, 0 o una lista predefinita funziona bene.

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')

Estrarre il messaggio di errore

All'interno di un gestore degli errori, utilizzi conditionMessage(e) o la forma abbreviata e$message per ottenere il testo dell'errore. Utilizzi conditionCall(e) o e$call per ottenere la chiamata che lo ha generato.

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

tryCatch() e try()

R dispone anche della funzione più semplice try(expr). In caso di errore, restituisce un oggetto di classe 'try-error' invece di interrompere l'esecuzione. Utilizzi try() per espressioni rapide su una sola riga; utilizzi tryCatch() quando sono necessari un controllo completo dei gestori o un blocco 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')
}

Annidare chiamate a tryCatch()

Le chiamate a tryCatch() possono essere annidate. Un tryCatch() interno intercetta per primo le condizioni; se le rilancia (utilizzando stop(e)), il gestore esterno intercetta la condizione rilanciata.

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')

Verifica rapida

In tryCatch(), quale clausola viene eseguita sempre, indipendentemente dal fatto che si sia verificato o meno un errore?

tryCatch(): punti chiave

Punti chiave di tryCatch():

Intercetti gli errori con error = function(e) {...} e gli avvisi con warning = function(w) {...}
Il valore restituito dal gestore diventa il risultato di tryCatch()
finally viene sempre eseguito: è ideale per la pulizia
Racchiuda i corpi dei cicli in tryCatch() per iterare in modo affidabile su input inaffidabili
e$message o conditionMessage(e) estrae il testo dell'errore
try(expr, silent=TRUE) è un'alternativa più semplice su una sola riga

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')

Domande Frequenti

La lezione «tryCatch() per il recupero dagli errori» è gratuita?

Sì — il testo completo di «tryCatch() per il recupero dagli errori» è 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 R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «tryCatch() per il recupero dagli errori»?

Catturi e gestisca errori, avvisi e messaggi con tryCatch(). Eserciti R 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 R Academy?

Non è richiesta alcuna esperienza precedente. R 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 2 di 4.

Quanto tempo richiede la lezione «tryCatch() per il recupero dagli errori»?

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 R Academy?

Sì. Ogni lezione R 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

Errori, avvisi e messaggi in R
tryCatch() per il recupero dagli errori
withCallingHandlers() e i restart
Scrittura di funzioni robuste con stop() e warning()

← Torna a R Academy