R Academy · Lektion

Fehlerbehandlung mit tryCatch()

Fangen und behandeln Sie Fehler, Warnungen und Meldungen mit tryCatch().

Lektion 2 von 413 Schritte

Fehlerbehandlung mit tryCatch() ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Was ist tryCatch()?

tryCatch() ermöglicht die Ausführung eines Ausdrucks und das Abfangen aller von ihm signalisierten Conditions (Fehler, Warnungen, Meldungen). Wenn der Ausdruck erfolgreich ist, wird sein Wert zurückgegeben. Signalisiert er eine Condition, wird stattdessen der passende Handler aufgerufen.

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

Einen Fehler abfangen

Wenn der Ausdruck innerhalb von tryCatch() stop() aufruft, springt die Ausführung zum error-Handler. Der Handler erhält das Condition-Objekt und gibt dessen Wert als Ergebnis des gesamten Aufrufs von tryCatch() zurück.

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

Eine Warnung abfangen

Der warning-Handler funktioniert wie der error-Handler, fängt jedoch Warnungs-Conditions ab. Hinweis: Sobald ein warning-Handler in tryCatch() definiert ist, führen Warnungen zu einem nichtlokalen Ausstieg wie Fehler – die Ausführung wird nach der Warnung nicht fortgesetzt.

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

Eine Nachricht abfangen

Sie können auch Bedingungen von message() abfangen. So können Sie informative Ausgaben von Funktionen, die Sie nicht kontrollieren, abfangen und neu formatieren. Der Handler erhält das Bedingungsobjekt, und der Text der Nachricht enthält einen abschließenden Zeilenumbruch.

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

Die finally-Klausel

Der finally-Block wird nach dem Ausdruck immer ausgeführt – unabhängig davon, ob er erfolgreich war, einen Fehler verursacht oder eine Warnung ausgegeben hat. Verwenden Sie ihn für Aufräumarbeiten wie das Schließen von Verbindungen, das Zurücksetzen von Optionen oder das Protokollieren des Abschlusses.

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

Mehrere Handler

Sie können in einem einzigen Aufruf von tryCatch() Handler für mehrere Bedingungstypen angeben. R verwendet den ersten passenden Handler. Wenn sowohl Handler für error als auch für warning definiert sind, werden Warnungen abgefangen, bevor sie zu Fehlern werden können.

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

Fehlerbehandlung in einer Schleife

Ein sehr praktisches Muster: Umschließen Sie den Schleifenrumpf mit tryCatch(), damit eine fehlgeschlagene Iteration nicht die gesamte Schleife beendet. Das ist besonders wichtig bei der Verarbeitung von Dateien, API-Aufrufen oder Benutzereingaben, die unvorhersehbar fehlschlagen können.

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

Sinnvolle Standardwerte bei Fehlern zurückgeben

Ein sauberes Muster besteht darin, im Fehler-Handler einen sinnvollen Standardwert zurückzugeben. Der Rückgabewert des Handlers wird zum Ergebnis von tryCatch(). Die Rückgabe von NA, NULL, 0 oder einer Standardliste funktioniert gut.

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

Die Fehlermeldung extrahieren

Verwenden Sie innerhalb eines Fehler-Handlers conditionMessage(e) oder die Kurzform e$message, um den Fehlertext abzurufen. Mit conditionCall(e) oder e$call rufen Sie den Aufruf ab, der den Fehler ausgelöst hat.

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

tryCatch() im Vergleich zu try()

R bietet auch die einfachere Funktion try(expr). Bei einem Fehler gibt sie ein Objekt der Klasse 'try-error' zurück, anstatt die Ausführung anzuhalten. Verwenden Sie try() für schnelle Einzeiler und tryCatch(), wenn Sie vollständige Kontrolle über Handler oder einen finally-Block benötigen.

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

tryCatch()-Aufrufe verschachteln

tryCatch()-Aufrufe können verschachtelt werden. Ein inneres tryCatch() fängt Bedingungen zuerst ab. Wenn es die Bedingung mit stop(e) erneut auslöst, fängt der äußere Handler die erneut ausgelöste Bedingung ab.

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

Kurze Überprüfung

Welche Klausel in tryCatch() wird immer ausgeführt, unabhängig davon, ob ein Fehler aufgetreten ist?

Beantworte es in der interaktiven Lektion

tryCatch(): Wichtigste Erkenntnisse

Wichtigste Erkenntnisse zu tryCatch():

Fangen Sie Fehler mit error = function(e) {...} und Warnungen mit warning = function(w) {...} ab
Der Rückgabewert des Handlers wird zum Ergebnis von tryCatch()
finally wird immer ausgeführt – ideal für Aufräumarbeiten
Umschließen Sie Schleifenrümpfe mit tryCatch(), um zuverlässig über fehleranfällige Eingaben zu iterieren
Mit e$message oder conditionMessage(e) extrahieren Sie den Fehlertext
try(expr, silent=TRUE) ist eine einfachere Alternative als Einzeiler

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

Kostenlos starten

Lerne R mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 43
Lektionen: 159

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Fehlerbehandlung mit tryCatch()“ kostenlos?

Ja — der vollständige Text von „Fehlerbehandlung mit tryCatch()“ 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 „Fehlerbehandlung mit tryCatch()“?

Fangen und behandeln Sie Fehler, Warnungen und Meldungen mit tryCatch(). 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 2 von 4.

Wie lange dauert die Lektion „Fehlerbehandlung mit tryCatch()“?

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

Fehler, Warnungen und Meldungen in R
Fehlerbehandlung mit tryCatch()
withCallingHandlers() und Restarts
Robuste Funktionen mit stop() und warning() schreiben

← Zurück zu R Academy