Obsługa wyjątków w R [zamknięte]

Zasadniczo chcesz użyć funkcji tryCatch(). Więcej szczegółów znajdziesz w pomocy("tryCatch").

Oto trywialny przykład (pamiętaj, że możesz zrobić, co chcesz, z błędem):

vari <- 1
tryCatch(print("passes"), error = function(e) print(vari), finally=print("finished")) 
tryCatch(stop("fails"), error = function(e) print(vari), finally=print("finished")) 

Spójrz na te powiązane pytania:

• odpowiednik "rzutu" w R
• wyłapywanie błędu, a następnie rozgałęzianie logiki
• https://stackoverflow.com/search?q=[r] + trycatch

Ten wynik z powiązanej wyszukiwarki Google pomógł mi: http://biocodenv.com/wordpress/?p=15 .

for(i in 1:16){
result <- try(nonlinear_modeling(i));
if(class(result) == "try-error") next;
}

Funkcja restart jest bardzo ważna w R dziedziczonym z Lispu. Jest to przydatne, jeśli chcesz wywołać jakąś funkcję w ciele pętli i po prostu chcesz, aby program kontynuował, jeśli wywołanie funkcji zwija się. Wypróbuj ten kod:

for (i in 1:20) withRestarts(tryCatch(
if((a <- runif(1))>0.5) print(a) else stop(a),
finally = print("loop body finished!")), 
abort = function(){})

Funkcja trycatch() jest dość prosta i istnieje wiele dobrych samouczków na ten temat. Doskonałe wyjaśnienie obsługi błędów w R można znaleźć w książce Hadleya Wickhama Advanced-R , a poniżej znajduje się bardzo podstawowe intro do withCallingHandlers() i withRestarts() w tak niewielu słowach, jak to możliwe: {32]}

Powiedzmy, że programista niskiego poziomu pisze funkcję do obliczania bezwzględnego wartość. Nie jest pewien, jak to obliczyć, ale wie, jak skonstruować błąd oraz sumiennie przekazuje swoją naiwność:

low_level_ABS <- function(x){
    if(x<0){
        #construct an error
        negative_value_error <- structure(
                    # with class `negative_value`
                    class = c("negative_value","error", "condition"),
                    list(message = "Not Sure what to with a negative value",
                         call = sys.call(), 
                         # and include the offending parameter in the error object
                         x=x))
        # raise the error
        stop(negative_value_error)
    }
    cat("Returning from low_level_ABS()\n")
    return(x)
}

Programista średniego poziomu pisze również funkcję do obliczania wartości bezwzględnej, korzystając z nieszczęśliwie niekompletnej funkcji low_level_ABS. Wie, że kod niskiego poziomu rzuca negative_value błąd, gdy wartość x jest ujemna i sugeruje rozwiązanie problemu, przez utworzenie restart, która pozwala użytkownikom mid_level_ABS kontrolować sposób, w jaki mid_level_ABS odzyskuje (lub nie) błąd negative_value.

mid_level_ABS <- function(y){
    abs_y <- withRestarts(low_level_ABS(y), 
                          # establish a restart called 'negative_value'
                          # which returns the negative of it's argument
                          negative_value_restart=function(z){-z}) 
    cat("Returning from mid_level_ABS()\n")
    return(abs_y)
}

Wreszcie, a programator wysokiego poziomu wykorzystuje funkcję mid_level_ABS do obliczania wartości bezwzględnej, i ustanawia funkcję obsługi warunku, która mówi o mid_level_ABS aby odzyskać błąd negative_value za pomocą restartu handler.

high_level_ABS <- function(z){
    abs_z <- withCallingHandlers(
            # call this function
            mid_level_ABS(z) ,
            # and if an `error` occurres
            error = function(err){
                # and the `error` is a `negative_value` error
                if(inherits(err,"negative_value")){
                    # invoke the restart called 'negative_value_restart'
                    invokeRestart('negative_value_restart', 
                                     # and invoke it with this parameter
                                     err$x) 
                }else{
                    # otherwise re-raise the error
                    stop(err)
                }
            })
    cat("Returning from high_level_ABS()\n")
    return(abs_z)
}

Chodzi o to, że używając withRestarts() i withCallingHandlers(), Funkcja high_level_ABS był w stanie powiedzieć mid_level_ABS Jak odzyskać od błędów podniesiony przez low_level_ABS błąd bez zatrzymywania wykonania mid_level_ABS, czyli coś czego nie da się zrobić tryCatch():

> high_level_ABS(3)
Returning from low_level_ABS()
Returning from mid_level_ABS()
Returning from high_level_ABS()
[1] 3
> high_level_ABS(-3)
Returning from mid_level_ABS()
Returning from high_level_ABS()
[1] 3

W praktyce, low_level_ABS reprezentuje funkcję, która mid_level_ABS wywołuje wiele (może nawet miliony razy), dla których prawidłowa metoda błędu obsługa może się różnić w zależności od sytuacji, a wybór sposobu radzenia sobie z określonymi błędami jest od lewej do funkcji wyższego poziomu (high_level_ABS).