R Academy · Lekcja

tryCatch() do obsługi błędów

Przechwytuj i obsługuj błędy, ostrzeżenia oraz komunikaty za pomocą tryCatch().

Lekcja 2 z 413 kroki

tryCatch() do obsługi błędów to bezpłatna lekcja R Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Czym jest tryCatch()?

tryCatch() umożliwia wykonanie wyrażenia i przechwycenie wszystkich sygnalizowanych przez nie warunków (błędów, ostrzeżeń i komunikatów). Jeśli wyrażenie zakończy się powodzeniem, zwracana jest jego wartość. Jeśli zasygnalizuje warunek, zamiast niego wywoływana jest pasująca procedura obsługi.

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

Przechwytywanie błędu

Gdy wyrażenie wewnątrz tryCatch() wywoła stop(), wykonanie przechodzi do procedury obsługi error. Procedura obsługi otrzymuje obiekt warunku, a zwracana przez nią wartość staje się wynikiem całego wywołania 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')

Przechwytywanie ostrzeżenia

Procedura obsługi warning działa tak samo jak procedura error, ale przechwytuje warunki ostrzeżeń. Uwaga: gdy w tryCatch() zdefiniowano procedurę obsługi warning, ostrzeżenia powodują wyjście nielokalne, podobnie jak błędy — wykonanie nie jest wznawiane po ostrzeżeniu.

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

Przechwytywanie komunikatu

Można także przechwytywać warunki message(). Pozwala to przechwytywać i formatować na nowo komunikaty informacyjne z funkcji, nad którymi nie ma Pan/Pani kontroli. Procedura obsługi otrzymuje obiekt warunku, a tekst komunikatu zawiera końcowy znak nowej linii.

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

Klauzula finally

Blok finally jest zawsze wykonywany po wyrażeniu — niezależnie od tego, czy zakończyło się ono powodzeniem, błędem czy ostrzeżeniem. Należy używać go do kodu porządkującego, takiego jak zamykanie połączeń, przywracanie opcji lub rejestrowanie zakończenia.

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

Wiele procedur obsługi

W jednym wywołaniu tryCatch() można podać procedury obsługi dla wielu typów warunków. R wybiera pierwszą pasującą procedurę obsługi. Jeśli zdefiniowano procedury obsługi zarówno dla error, jak i dla warning, ostrzeżenia są przechwytywane, zanim będą mogły stać się błędami.

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

Odzyskiwanie po błędzie w pętli

Bardzo praktyczny wzorzec polega na opakowaniu treści pętli w tryCatch(), aby jedna nieudana iteracja nie zatrzymała całej pętli. Jest to niezbędne podczas przetwarzania plików, wywołań API lub danych wprowadzanych przez użytkownika, które mogą nieprzewidywalnie powodować błędy.

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

Zwracanie sensownych wartości domyślnych po błędzie

Dobrym wzorcem jest zwracanie sensownej wartości domyślnej z procedury obsługi błędu. Wartość zwracana przez procedurę obsługi staje się wynikiem tryCatch(). Zwracanie NA, NULL, 0 lub listy domyślnej sprawdza się bardzo dobrze.

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

Pobieranie komunikatu błędu

W procedurze obsługi błędu należy użyć conditionMessage(e) lub skróconej postaci e$message, aby pobrać tekst błędu. Za pomocą conditionCall(e) lub e$call można pobrać wywołanie, które go wywołało.

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

tryCatch() a try()

R udostępnia także prostszą funkcję try(expr). W przypadku błędu zwraca ona obiekt klasy 'try-error' zamiast przerywać działanie. Należy używać try() do szybkich, jednowierszowych wywołań, a tryCatch(), gdy potrzebna jest pełna kontrola nad procedurami obsługi lub blok finally.

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

Zagnieżdżanie wywołań tryCatch()

Wywołania tryCatch() można zagnieżdżać. Wewnętrzne tryCatch() przechwytuje warunki jako pierwsze; jeśli przekaże warunek ponownie (za pomocą stop(e)), zewnętrzna procedura obsługi przechwytuje ponownie zgłoszony warunek.

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

Szybkie sprawdzenie

W funkcji tryCatch() która klauzula jest wykonywana zawsze, niezależnie od tego, czy wystąpił błąd?

Odpowiedz w interaktywnej lekcji

tryCatch(): najważniejsze informacje

Najważniejsze informacje dotyczące tryCatch():

Błędy przechwytuje się za pomocą error = function(e) {...}, a ostrzeżenia za pomocą warning = function(w) {...}
Wartość zwracana przez procedurę obsługi staje się wynikiem tryCatch()
finally jest zawsze wykonywane — idealnie nadaje się do porządkowania
Opakowanie treści pętli w tryCatch() zapewnia niezawodne przetwarzanie niepewnych danych wejściowych
e$message lub conditionMessage(e) pobiera tekst błędu
try(expr, silent=TRUE) jest prostszą alternatywą w jednym wierszu

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

Bezpłatny start

Ucz się R dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 43
Lekcje: 159

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „tryCatch() do obsługi błędów” jest bezpłatna?

Tak — pełny tekst „tryCatch() do obsługi błędów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „tryCatch() do obsługi błędów”?

Przechwytuj i obsługuj błędy, ostrzeżenia oraz komunikaty za pomocą tryCatch(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „tryCatch() do obsługi błędów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Błędy, ostrzeżenia i komunikaty w R
tryCatch() do obsługi błędów
withCallingHandlers() i restarty
Pisanie odpornych funkcji za pomocą stop() i warning()

← Powrót do R Academy