0Pricing
R Academy · Lektion

Fehler, Warnungen und Meldungen in R

Verstehen Sie die drei Signaltypen und wann jeder von ihnen ausgelöst wird.

Fehler, Warnungen und Meldungen in R ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Condition-System von R

R verfügt über ein formales Condition-System zur Kommunikation von Problemen. Es gibt drei wesentliche Condition-Klassen: Fehler (fatal – brechen die Ausführung ab), Warnungen (nicht fatal – werden nach Abschluss des Codes ausgegeben) und Meldungen (informativ – werden nach stderr geschrieben).

# 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() — Fehler erzeugen

stop(msg) signalisiert eine Fehler-Condition. Die Ausführung wird sofort beendet und die Fehlermeldung angezeigt. Die Funktion wird innerhalb von Funktionen verwendet, um bei ungültigen Eingaben oder einer nicht behebbaren Situation abzubrechen.

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() — Nicht fatale Warnungen

warning(msg) signalisiert eine Warnungs-Condition. Anders als Fehler beenden Warnungen die Ausführung nicht – die Funktion wird fortgesetzt und die Warnung gesammelt. Standardmäßig werden Warnungen nach Abschluss des gesamten Codes ausgegeben oder sofort, wenn options(warn=1) gesetzt ist.

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 Conditions

message(msg) signalisiert eine Nachrichten-Condition. Sie wird nach stderr geschrieben, enthält einen automatischen Zeilenumbruch und kann mit suppressMessages() unterdrückt werden. Verwenden Sie sie für Fortschrittsmeldungen in Funktionen, nicht für Fehler oder Warnungen.

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

Objekte simpleError und simpleWarning

Wenn R eine Condition erstellt, verpackt es die Meldung in einem Condition-Objekt. simpleError('msg') und simpleWarning('msg') erstellen Condition-Objekte manuell. Sie können diese mit conditionMessage() untersuchen.

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() und conditionCall()

conditionMessage(cond) extrahiert die Textmeldung aus einem beliebigen Condition-Objekt. conditionCall(cond) extrahiert den Aufruf, der die Condition ausgelöst hat. Beide Funktionen sind innerhalb von Fehlerbehandlungen nützlich, um Conditions zu protokollieren oder erneut zu signalisieren.

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

options(warn = 2) — Warnungen als Fehler behandeln

Das Setzen von options(warn = 2) wandelt alle Warnungen in Fehler um und führt zu einem sofortigen Abbruch. Das ist während der Entwicklung nützlich, um Code, der Warnungen erzeugt, frühzeitig zu erkennen. Zurücksetzen können Sie die Option mit 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))

Sofortige und verzögerte Warnungen

Mit options(warn = 0) (Standard) werden Warnungen gesammelt und am Ende ausgegeben. Mit options(warn = 1) wird jede Warnung sofort beim Auftreten ausgegeben. Mit warn = 2 werden sie zu Fehlern.

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

Fehler und Warnung: fatal und nicht fatal

Der entscheidende Unterschied: Ein Fehler stoppt die Ausführung vollständig, sofern er nicht von einer Fehlerbehandlung abgefangen wird. Eine Warnung wird aufgezeichnet, aber die Ausführung wird fortgesetzt. Daher können ungültige Eingaben unbemerkt falsche Ergebnisse erzeugen, wenn Sie Warnungen verwenden, obwohl Fehler erforderlich wären.

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

Verschachtelte Conditions

Conditions können innerhalb anderer Condition-Handler ausgelöst werden. Ein Warnungs-Handler kann stop() aufrufen, um eine Warnung zu einem Fehler hochzustufen. Dies ist ein übliches Muster, um Code von Drittanbietern strenger zu behandeln.

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

suppressWarnings(expr) wertet den Ausdruck aus und fängt dabei alle Warnungen stillschweigend ab und verwirft sie. suppressMessages(expr) macht dasselbe mit Nachrichten-Conditions. Verwenden Sie diese Funktionen sparsam – das Unterdrücken von Warnungen kann echte Probleme verbergen.

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

Schnelltest

Welche der folgenden Aussagen über warning() im Vergleich zu stop() ist korrekt?

Conditions: Die wichtigsten Punkte

Die wichtigsten Punkte zu R-Conditions:

  • stop() = Fehler = fatal, bricht sofort ab; warning() = nicht fatal, Ausführung wird fortgesetzt; message() = informativ, schreibt nach stderr
  • Alle drei erstellen Condition-Objekte mit einer Klassenhierarchie
  • conditionMessage(e) extrahiert den Text aus jeder Condition
  • options(warn=1) gibt Warnungen sofort aus; warn=2 behandelt sie als Fehler
  • suppressWarnings() / suppressMessages() unterdrücken Conditions
  • Bevorzugen Sie stop() bei ungültigen Eingaben, wenn eine Fortsetzung zu falschen Ergebnissen führen würde
# 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'))

Häufig gestellte Fragen

Ist die Lektion „Fehler, Warnungen und Meldungen in R“ kostenlos?

Ja — der vollständige Text von „Fehler, Warnungen und Meldungen in R“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fehler, Warnungen und Meldungen in R“?

Verstehen Sie die drei Signaltypen und wann jeder von ihnen ausgelöst wird. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Fehler, Warnungen und Meldungen in R“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Fehler, Warnungen und Meldungen in R
  2. Fehlerbehandlung mit tryCatch()
  3. withCallingHandlers() und Restarts
  4. Robuste Funktionen mit stop() und warning() schreiben
← Zurück zu R Academy