R Academy · leksjon

Feil, advarsler og meldinger i R

Forstå de tre signaltypene og når hver av dem utløses.

Leksjon 1 av 413 trinn

Feil, advarsler og meldinger i R er en gratis leksjon i R Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i R Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i R Academy inneholder totalt 4 leksjoner.

R sitt betingelsessystem

R har et formelt betingelsessystem for å kommunisere problemer. Det finnes tre hovedklasser av betingelser: feil (fatale — stopper kjøringen), advarsler (ikke-fatale — skrives ut etter at koden er ferdig) og meldinger (informative — sendes til 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() — Generere feil

stop(msg) signaliserer en feilbetingelse. Kjøringen stopper umiddelbart, og feilmeldingen vises. Den brukes inne i funksjoner for å avbryte når inndataene er ugyldige eller en situasjon som ikke kan gjenopprettes, blir oppdaget.

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() — Ikke-fatale advarsler

warning(msg) signaliserer en advarselsbetingelse. I motsetning til feil stopper ikke advarsler kjøringen — funksjonen fortsetter, og advarselen samles opp. Som standard skrives advarsler ut etter at all kode er ferdig, eller umiddelbart hvis options(warn=1) er angitt.

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() — Informative betingelser

message(msg) signaliserer en meldingsbetingelse. Den sendes til stderr, inkluderer et automatisk linjeskift og kan undertrykkes med suppressMessages(). Bruk den til fremdriftsoppdateringer i funksjoner, ikke til feil eller advarsler.

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

Objektene simpleError og simpleWarning

Når R oppretter en betingelse, pakker den meldingen inn i et betingelsesobjekt. simpleError('msg') og simpleWarning('msg') oppretter betingelsesobjekter manuelt. De kan inspiseres 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() og conditionCall()

conditionMessage(cond) henter tekstmeldingen fra et hvilket som helst betingelsesobjekt. conditionCall(cond) henter kallet som utløste betingelsen. Begge er nyttige i feilhåndterere for logging eller for å signalere betingelser på nytt.

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

options(warn = 2) — Behandle advarsler som feil

Hvis De angir options(warn = 2), konverteres alle advarsler til feil, slik at kjøringen stopper umiddelbart. Dette er nyttig under utvikling for å oppdage kode som genererer advarsler, tidlig. Gjenopprett 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))

Umiddelbare og utsatte advarsler

Med options(warn = 0) (standard) samles advarsler opp og skrives ut til slutt. Med options(warn = 1) skrives hver advarsel ut umiddelbart når den oppstår. Med warn = 2 blir de til feil.

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

Feil kontra advarsel: fatal kontra ikke-fatal

Det avgjørende skillet er at en feil stopper kjøringen helt, med mindre den fanges opp av en håndterer. En advarsel registreres, men kjøringen fortsetter. Det betyr at ugyldige inndata i stillhet kan føre til feil resultater hvis De bruker advarsler der De burde bruke feil.

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

Nesting av betingelser

Betingelser kan utløses inne i andre betingelseshåndterere. En advarselshåndterer kan kalle stop() for å oppgradere en advarsel til en feil. Dette er et vanlig mønster for å gjøre kode fra tredjeparter strengere.

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() og suppressMessages()

suppressWarnings(expr) evaluerer uttrykket samtidig som alle advarsler fanges opp og forkastes i stillhet. suppressMessages(expr) gjør det samme for meldingsbetingelser. Bruk disse med måte — undertrykking av advarsler kan skjule reelle problemer.

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

Hurtigsjekk

Hvilket av følgende utsagn om warning() kontra stop() er riktig?

Besvar den i den interaktive leksjonen

Betingelser: Viktige poenger

Viktige poenger om R-betingelser:

stop() = feil = fatal, stopper umiddelbart; warning() = ikke-fatal, kjøringen fortsetter; message() = informativ, sendes til stderr
Alle tre oppretter betingelsesobjekter med et klassehierarki
conditionMessage(e) henter teksten fra en hvilken som helst betingelse
options(warn=1) skriver ut advarsler umiddelbart; warn=2 behandler dem som feil
suppressWarnings() / suppressMessages() undertrykker betingelser
Foretrekk stop() for ugyldige inndata når det ville være feil å fortsette

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

Gratis å komme i gang

Lær deg R med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 43
Leksjoner: 159

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feil, advarsler og meldinger i R» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien R Academy, inkludert «Feil, advarsler og meldinger i R», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i R Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feil, advarsler og meldinger i R»?

Forstå de tre signaltypene og når hver av dem utløses. Du øver på R Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med R Academy?

Ingen tidligere erfaring er nødvendig. R Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Feil, advarsler og meldinger i R»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne R Academy-leksjonen?

Ja. Alle R Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Feil, advarsler og meldinger i R
tryCatch() for feilhåndtering
withCallingHandlers() og restarter
Skrive robuste funksjoner med stop() og warning()

← Tilbake til R Academy