Errori, avvisi e messaggi in R
Comprenda i tre tipi di segnali e quando viene generato ciascuno.
Errori, avvisi e messaggi in R è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 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.
Il sistema delle condizioni di R
R dispone di un sistema formale delle condizioni per comunicare i problemi. Esistono tre classi principali di condizioni: errori (fatali: interrompono l'esecuzione), avvisi (non fatali: vengono stampati al termine del codice) e messaggi (informativi: vengono inviati a 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() — Generazione di errori
stop(msg) segnala una condizione di errore. L'esecuzione si interrompe immediatamente e viene visualizzato il messaggio di errore. Viene utilizzata all'interno delle funzioni per interrompere l'esecuzione quando gli input non sono validi o viene rilevata una situazione irrecuperabile.
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() — Avvisi non fatali
warning(msg) segnala una condizione di avviso. A differenza degli errori, gli avvisi non interrompono l'esecuzione: la funzione continua e l'avviso viene raccolto. Per impostazione predefinita, gli avvisi vengono stampati al termine dell'esecuzione del codice, oppure immediatamente se è impostato options(warn=1).
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() — Condizioni informative
message(msg) segnala una condizione di messaggio. Viene inviata a stderr, include automaticamente una nuova riga e può essere soppressa con suppressMessages(). Utilizzatela per comunicare l'avanzamento nelle funzioni, non per gli errori o gli avvisi.
load_data <- function(n) {
message('Loading ', n, ' records...')
seq_len(n)
}
data <- suppressMessages(load_data(100))
cat('Got', length(data), 'records\n')Oggetti simpleError e simpleWarning
Quando R crea una condizione, racchiude il messaggio in un oggetto condizione. simpleError('msg') e simpleWarning('msg') creano manualmente oggetti condizione. Potete esaminarli con 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() e conditionCall()
conditionMessage(cond) estrae il messaggio testuale da qualsiasi oggetto condizione. conditionCall(cond) estrae la chiamata che ha attivato la condizione. Entrambe sono utili all'interno dei gestori degli errori per registrare o segnalare nuovamente le condizioni.
tryCatch(
log(-1),
warning = function(w) {
cat('Caught warning :', conditionMessage(w), '\n')
cat('From call :', deparse(conditionCall(w)), '\n')
}
)options(warn = 2) — Trattare gli avvisi come errori
Impostando options(warn = 2) si convertono tutti gli avvisi in errori, causando un'interruzione immediata. È utile durante lo sviluppo per individuare tempestivamente il codice che genera avvisi. Ripristinate il comportamento predefinito con 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))Avvisi immediati e differiti
Con options(warn = 0) (valore predefinito), gli avvisi vengono raccolti e stampati al termine. Con options(warn = 1), ogni avviso viene stampato immediatamente quando si verifica. Con warn = 2, vengono trasformati in errori.
# 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)Errore e avviso: fatale e non fatale
La distinzione fondamentale è la seguente: un errore interrompe completamente l'esecuzione, a meno che non venga intercettato da un gestore. Un avviso viene registrato, ma l'esecuzione continua. Di conseguenza, gli input errati possono produrre silenziosamente risultati non corretti se utilizzate avvisi dove dovreste usare errori.
# 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'))Annidamento delle condizioni
Le condizioni possono essere sollevate all'interno di altri gestori di condizioni. Un gestore di avvisi può chiamare stop() per trasformare un avviso in un errore. Questo è uno schema comune per rendere più rigoroso il codice di terze parti.
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() e suppressMessages()
suppressWarnings(expr) valuta l'espressione intercettando e ignorando silenziosamente tutti gli avvisi. suppressMessages(expr) fa lo stesso con le condizioni di messaggio. Utilizzatele con moderazione: la soppressione degli avvisi può nascondere problemi reali.
# 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')Verifica rapida
Quale delle seguenti affermazioni su warning() e stop() è corretta?
Condizioni: concetti chiave
Concetti chiave sulle condizioni di R:
stop()= errore = fatale, interrompe immediatamente;warning()= non fatale, l'esecuzione continua;message()= informativo, viene inviato a stderr- Tutte e tre creano oggetti condizione con una gerarchia di classi
conditionMessage(e)estrae il testo da qualsiasi condizioneoptions(warn=1)stampa immediatamente gli avvisi;warn=2li tratta come errorisuppressWarnings()/suppressMessages()silenziano le condizioni- Preferite
stop()per gli input non validi quando continuare produrrebbe risultati errati
# 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'))Domande Frequenti
La lezione «Errori, avvisi e messaggi in R» è gratuita?
Sì — il testo completo di «Errori, avvisi e messaggi in R» è 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 «Errori, avvisi e messaggi in R»?
Comprenda i tre tipi di segnali e quando viene generato ciascuno. 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 1 di 4.
Quanto tempo richiede la lezione «Errori, avvisi e messaggi in R»?
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()