R Academy · Pelajaran

tryCatch() untuk Pemulihan dari Error

Tangkap dan tangani error, peringatan, serta pesan dengan tryCatch().

tryCatch() untuk Pemulihan dari Error adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Apa itu tryCatch()?

tryCatch() memungkinkan Anda menjalankan ekspresi dan mencegat kondisi apa pun (galat, peringatan, atau pesan) yang dihasilkannya. Jika ekspresi berhasil, nilainya dikembalikan. Jika ekspresi memberi sinyal kondisi, penangan yang sesuai akan dipanggil sebagai gantinya.

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

Menangkap Galat

Ketika ekspresi di dalam tryCatch() memanggil stop(), eksekusi berpindah ke penangan error. Penangan menerima objek kondisi dan mengembalikan nilainya sebagai hasil dari seluruh pemanggilan 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')

Menangkap Peringatan

Penangan warning bekerja dengan cara yang sama seperti error, tetapi mencegat kondisi peringatan. Catatan: setelah penangan warning ditetapkan dalam tryCatch(), peringatan menyebabkan keluar dari alur saat ini secara non-lokal, sama seperti galat — eksekusi tidak dilanjutkan setelah peringatan.

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

Menangkap Pesan

Anda juga dapat menangkap kondisi message(). Dengan demikian, Anda dapat mencegat dan memformat ulang keluaran informatif dari fungsi yang tidak Anda kendalikan. Penangan menerima objek kondisi, dan teks pesan menyertakan baris baru di bagian akhir.

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

Klausa finally

Blok finally selalu dijalankan setelah ekspresi selesai — baik ekspresi tersebut berhasil, menghasilkan error, maupun peringatan. Gunakan blok ini untuk kode pembersihan, seperti menutup koneksi, mengatur ulang opsi, atau mencatat penyelesaian.

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

Beberapa Penangan

Anda dapat menyediakan penangan untuk beberapa jenis kondisi dalam satu pemanggilan tryCatch(). R mencocokkan penangan pertama yang sesuai. Jika penangan error dan warning sama-sama ditentukan, peringatan ditangkap sebelum berubah menjadi error.

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

Pemulihan Error dalam Perulangan

Pola yang sangat praktis adalah membungkus isi perulangan dalam tryCatch() agar satu iterasi yang gagal tidak menghentikan seluruh perulangan. Ini penting saat memproses file, pemanggilan API, atau masukan pengguna yang mungkin gagal secara tidak terduga.

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

Mengembalikan Nilai Bawaan yang Bermakna saat Terjadi Error

Pola yang rapi adalah mengembalikan nilai bawaan yang masuk akal dari penangan error. Nilai kembalian penangan menjadi hasil dari tryCatch(). Mengembalikan NA, NULL, 0, atau daftar bawaan semuanya dapat digunakan dengan baik.

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

Mengekstrak Pesan Error

Di dalam penangan error, gunakan conditionMessage(e) atau bentuk singkat e$message untuk mendapatkan teks error. Gunakan conditionCall(e) atau e$call untuk mendapatkan pemanggilan yang memicunya.

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

tryCatch() vs try()

R juga memiliki fungsi try(expr) yang lebih sederhana. Saat terjadi error, fungsi ini mengembalikan objek kelas 'try-error' alih-alih berhenti. Gunakan try() untuk satu baris kode sederhana; gunakan tryCatch() saat Anda memerlukan kendali penuh atas penangan atau 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')
}

Menumpuk Pemanggilan tryCatch()

Pemanggilan tryCatch() dapat ditumpuk. tryCatch() bagian dalam menangkap kondisi terlebih dahulu; jika kondisi tersebut dilemparkan kembali (menggunakan stop(e)), penangan bagian luar akan menangkap kondisi yang dilemparkan kembali itu.

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

Pemeriksaan Singkat

Dalam tryCatch(), klausa mana yang selalu dijalankan, terlepas dari apakah error terjadi atau tidak?

tryCatch(): Inti Pembelajaran

Inti pembelajaran tentang tryCatch():

Mencegat error dengan error = function(e) {...}, dan peringatan dengan warning = function(w) {...}
Nilai kembalian penangan menjadi hasil dari tryCatch()
finally selalu dijalankan — ideal untuk pembersihan
Bungkus isi perulangan dalam tryCatch() agar iterasi pada masukan yang tidak andal tetap tangguh
e$message atau conditionMessage(e) mengekstrak teks error
try(expr, silent=TRUE) adalah alternatif satu baris yang lebih sederhana

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “tryCatch() untuk Pemulihan dari Error” gratis?

Ya — teks lengkap “tryCatch() untuk Pemulihan dari Error” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “tryCatch() untuk Pemulihan dari Error”?

Tangkap dan tangani error, peringatan, serta pesan dengan tryCatch(). Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “tryCatch() untuk Pemulihan dari Error” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Error, Peringatan, dan Pesan dalam R
tryCatch() untuk Pemulihan dari Error
withCallingHandlers() dan Restart
Menulis Fungsi Tangguh dengan stop() dan warning()

← Kembali ke R Academy