R Academy · Les

tryCatch() voor foutafhandeling

Vang fouten, waarschuwingen en berichten op en handel ze af met tryCatch().

Les 2 van 413 stappen

tryCatch() voor foutafhandeling is een gratis R Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.

Wat is tryCatch()?

Met tryCatch() kun je een expressie uitvoeren en alle condities (fouten, waarschuwingen en berichten) onderscheppen die de expressie signaleert. Als de expressie slaagt, wordt de waarde ervan geretourneerd. Als de expressie een conditie signaleert, wordt in plaats daarvan de overeenkomende afhandelaar aangeroepen.

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

Een fout opvangen

Wanneer de expressie binnen tryCatch() stop() aanroept, springt de uitvoering naar de afhandelaar voor error. De afhandelaar ontvangt het conditieobject en retourneert de waarde ervan als resultaat van de volledige aanroep van tryCatch().

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

Een waarschuwing opvangen

De afhandelaar voor warning werkt op dezelfde manier als die voor error, maar onderschept waarschuwingscondities. Let op: zodra in tryCatch() een afhandelaar voor warning is gedefinieerd, veroorzaken waarschuwingen een niet-lokale exit, net als fouten — de uitvoering wordt na de waarschuwing niet hervat.

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

Een bericht opvangen

Je kunt ook voorwaarden van message() opvangen. Daarmee kun je informatieve uitvoer van functies waar je geen controle over hebt onderscheppen en opnieuw formatteren. De verwerker ontvangt het voorwaardobject en de tekst van het bericht bevat een afsluitende regeleinde.

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

De finally-component

Het blok finally wordt altijd uitgevoerd nadat de expressie is uitgevoerd — of deze nu is geslaagd, een fout heeft veroorzaakt of een waarschuwing heeft gegeven. Gebruik dit voor opruimcode, zoals het sluiten van verbindingen, het terugzetten van opties of het loggen van de voltooiing.

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

Meerdere verwerkers

Je kunt verwerkers voor meerdere voorwaardetypen opgeven in één aanroep van tryCatch(). R gebruikt de eerste toepasselijke verwerker. Als zowel verwerkers voor error als voor warning zijn gedefinieerd, worden waarschuwingen opgevangen voordat ze fouten kunnen worden.

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

Foutherstel in een lus

Een zeer praktisch patroon: plaats de inhoud van een lus in tryCatch(), zodat één mislukte iteratie niet de hele lus stopt. Dit is essentieel bij het verwerken van bestanden, API-aanroepen of gebruikersinvoer die onvoorspelbaar kan mislukken.

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

Zinvolle standaardwaarden retourneren bij fouten

Een goed patroon is om vanuit de foutverwerker een verstandige standaardwaarde te retourneren. De retourwaarde van de verwerker wordt het resultaat van tryCatch(). Het retourneren van NA, NULL, 0 of een standaardlijst werkt allemaal goed.

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

De foutmelding ophalen

Gebruik binnen een foutverwerker conditionMessage(e) of de verkorte notatie e$message om de fouttekst op te halen. Gebruik conditionCall(e) of e$call om de aanroep op te halen die de fout heeft veroorzaakt.

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

tryCatch() versus try()

R heeft ook de eenvoudigere functie try(expr). Bij een fout retourneert deze een object van de klasse 'try-error' in plaats van te stoppen. Gebruik try() voor snelle eenregelige bewerkingen; gebruik tryCatch() wanneer je volledige controle over verwerkers of een blok finally nodig hebt.

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

Aanroepen van tryCatch() nesten

Aanroepen van tryCatch() kunnen worden genest. Een innerlijke tryCatch() vangt voorwaarden als eerste op; als deze de voorwaarde opnieuw doorgeeft (met stop(e)), vangt de buitenste verwerker de opnieuw doorgegeven voorwaarde op.

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

Snelle controle

Welke component in tryCatch() wordt altijd uitgevoerd, ongeacht of er een fout is opgetreden?

Beantwoord dit in de interactieve les

tryCatch(): belangrijkste punten

Belangrijkste punten voor tryCatch():

Vang fouten op met error = function(e) {...} en waarschuwingen met warning = function(w) {...}
De retourwaarde van de verwerker wordt het resultaat van tryCatch()
finally wordt altijd uitgevoerd — ideaal voor opruimwerk
Plaats de inhoud van lussen in tryCatch() voor robuuste iteratie over onbetrouwbare invoer
Met e$message of conditionMessage(e) haal je de fouttekst op
try(expr, silent=TRUE) is een eenvoudiger eenregelig alternatief

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

Gratis beginnen

Leer R met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 43
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “tryCatch() voor foutafhandeling” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “tryCatch() voor foutafhandeling”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.

Wat leer ik in “tryCatch() voor foutafhandeling”?

Vang fouten, waarschuwingen en berichten op en handel ze af met tryCatch(). Je oefent met R Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met R Academy te beginnen?

Ervaring vooraf is niet nodig. R Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “tryCatch() voor foutafhandeling”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over R Academy?

Ja. Elke les over R Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Fouten, waarschuwingen en berichten in R
tryCatch() voor foutafhandeling
withCallingHandlers() en restarts
Robuuste functies schrijven met stop() en warning()

← Terug naar R Academy