Fel, varningar och meddelanden i R
Förstå de tre signaltyperna och när var och en utlöses.
Fel, varningar och meddelanden i R är en gratis lektion i R Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.
R:s tillståndssystem
R har ett formellt tillståndssystem för att kommunicera problem. Det finns tre huvudklasser av tillstånd: fel (allvarliga — avbryter körningen), varningar (icke-allvarliga — skrivs ut när koden har körts klart) och meddelanden (informativa — skickas till 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() — Generera fel
stop(msg) signalerar ett feltillstånd. Körningen avbryts omedelbart och felmeddelandet visas. Funktionen används inuti funktioner för att avbryta när indata är ogiltiga eller när en situation som inte kan återställas upptäcks.
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() — Icke-allvarliga varningar
warning(msg) signalerar ett varningstillstånd. Till skillnad från fel avbryter varningar inte körningen — funktionen fortsätter och varningen samlas in. Som standard skrivs varningar ut när all kod har körts klart, eller omedelbart om options(warn=1) har angetts.
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() — Informativa tillstånd
message(msg) signalerar ett meddelandetillstånd. Det skickas till stderr, innehåller en automatisk radbrytning och kan undertryckas med suppressMessages(). Använd det för förloppsuppdateringar i funktioner, inte för fel eller varningar.
load_data <- function(n) {
message('Loading ', n, ' records...')
seq_len(n)
}
data <- suppressMessages(load_data(100))
cat('Got', length(data), 'records\n')Objekten simpleError och simpleWarning
När R skapar ett tillstånd omsluter programmet meddelandet i ett tillståndsobjekt. simpleError('msg') och simpleWarning('msg') skapar tillståndsobjekt manuellt. Ni kan granska dem med 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() och conditionCall()
conditionMessage(cond) hämtar textmeddelandet från valfritt tillståndsobjekt. conditionCall(cond) hämtar anropet som utlöste tillståndet. Båda är användbara i felhanterare för loggning eller för att signalera tillstånd på nytt.
tryCatch(
log(-1),
warning = function(w) {
cat('Caught warning :', conditionMessage(w), '\n')
cat('From call :', deparse(conditionCall(w)), '\n')
}
)options(warn = 2) — Behandla varningar som fel
Om Ni anger options(warn = 2) omvandlas alla varningar till fel, vilket leder till omedelbara avbrott. Detta är användbart under utveckling för att upptäcka kod som genererar varningar tidigt. Återställ med 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))Omedelbara jämfört med uppskjutna varningar
Med options(warn = 0) (standard) samlas varningar in och skrivs ut i slutet. Med options(warn = 1) skrivs varje varning ut omedelbart när den uppstår. Med warn = 2 omvandlas de till fel.
# 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)Fel jämfört med varning: allvarligt jämfört med icke-allvarligt
Den avgörande skillnaden är att ett fel stoppar körningen helt om det inte fångas av en hanterare. En varning registreras, men körningen fortsätter. Det innebär att felaktig indata i tysthet kan ge felaktiga resultat om Ni använder varningar där Ni borde använda fel.
# 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'))Kapslade tillstånd
Tillstånd kan utlösas inuti andra tillståndshanterare. En varningshanterare kan anropa stop() för att omvandla en varning till ett fel. Detta är ett vanligt mönster för att göra kod från tredje part striktare.
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() och suppressMessages()
suppressWarnings(expr) utvärderar uttrycket samtidigt som alla varningar fångas och ignoreras utan utskrift. suppressMessages(expr) gör samma sak för meddelandetillstånd. Använd dessa sparsamt — om varningar undertrycks kan verkliga problem döljas.
# 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')Snabbkontroll
Vilket av följande påståenden om warning() jämfört med stop() är korrekt?
Tillstånd: viktiga slutsatser
Viktiga slutsatser om R:s tillstånd:
stop()= fel = allvarligt, avbryter omedelbart;warning()= icke-allvarligt, körningen fortsätter;message()= informativt, skickas till stderr- Alla tre skapar tillståndsobjekt med en klasshierarki
conditionMessage(e)hämtar texten från valfritt tillståndoptions(warn=1)skriver ut varningar omedelbart;warn=2behandlar dem som felsuppressWarnings()/suppressMessages()tystar tillstånd- Föredra
stop()för ogiltig indata när det vore fel att fortsätta
# 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'))
Lär dig R med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 43
- Lektioner
- 159
Vanliga frågor
Är lektionen ”Fel, varningar och meddelanden i R” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Fel, varningar och meddelanden i R”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Fel, varningar och meddelanden i R”?
Förstå de tre signaltyperna och när var och en utlöses. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig R Academy?
Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Fel, varningar och meddelanden i R”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här R Academy-lektionen?
Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Fel, varningar och meddelanden i R
- tryCatch() för felåterställning
- withCallingHandlers() och omstarter
- Skriv robusta funktioner med stop() och warning()