Ruby Exception Handling: rescue

An unexpected problem occurs in a running program. A file to be read does not exist. When you want to store some data, the disk is full. You may enter inappropriate data.

Ruby> file = open ("some_file ")
ERR: (eval): 1: in 'open': No such file or directory-some_file


A robust program will handle these problems reasonably and beautifully. dealing with exceptions is an annoying task. C programmers are required to check the return values of every system call that may cause errors and make immediate decisions.

FILE * file = fopen ("some_file", "r ");
If (file = NULL ){
Fprintf (stderr, "File doesn't exist. \ n ");
Exit (1 );
}
Bytes_read = fread (buf, 1, bytes_desired, file );
If (bytes_read! = Bytes_desired ){
/* Do more error handling here ...*/
}
...


This boring job will make programmers become sloppy and ignore it. As a result, the program cannot cope with exceptions. on the one hand, this will also reduce the readability of the program. too much error processing makes meaningful code messy.

In Ruby, like other modern languages, we can handle exceptions in code domains through isolation. Therefore, this has an amazing effect, but it will not cause excessive burden on programmers or others who want to read it later. the code field starts from begin until an exception occurs, which leads to a code field for error handling marked by rescue. if the exception does not occur, the rescue code will not be used. the following code returns the first line of the text file. If an exception exists, nil is returned.

Def first_line (filename)
Begin
File = open ("some_file ")
Info = file. gets
File. close
Info # Last thing evaluated is the return value
Rescue
Nil # Can't read the file? Then don't return a string
End
End


Sometimes we want to work creatively around the problem. Here, if the file does not exist, we use standard input instead:

Begin
File = open ("some_file ")
Rescue
File = STDIN
End
Begin
#... Process the input...
Rescue
#... And deal with any other exceptions here.
End


Retry is used for rescue code to re-execute the begin code. This allows us to compress the previous example:

Fname = "some_file"
Begin
File = open (fname)
#... Process the input...
Rescue
Fname = "STDIN"
Retry
End


But this is still a bit flawed. A non-existing file will cause retry without stopping. You should note this when using retry for exception handling.

Each Ruby library submits an exception when an error occurs. You can explicitly submit the exception in your code. use raise to submit an exception. it carries a parameter, that is, a string that describes the exception. the parameter is optional but should not be omitted. then it can use a special global variable $! Access.

Ruby> raise "test error"
Test error
Ruby> begin
| Raise "test2"
| Rescue
| Print "An error occurred:", $ !, "\ N"
| End
An error occurred: test2
Nil