6.30. Ruby exception

Exceptions and execution are always associated. If you open a file that does not exist and do not handle the situation properly, your program is considered to be of low quality.

If an exception occurs, the program stops. Exceptions are used to handle various types of errors that may occur during program execution, so take appropriate action without causing the program to stop completely.

Ruby provides a perfect mechanism for handling exceptions. We can do it in begin/end block with code that may throw an exception, and use the rescue clause tells Ruby the perfect type of exception to handle.

6.30.1. Grammar #

Begin # Start raising# Throw an exception, execute [ExceptionType=Standard
Exception] # The default value for capturing exceptions of the specified type is
StandardException $# Indicates exception information $@ # indicates the
code location where the exception occurred else # Other exceptions Ensure
#Enter the code block end # regardless of any exceptions

From begin to rescue Everything in is protected. If an exception occurs during the execution of the code block, control is passed to the rescue and end between the blocks.

For begin Each in the block rescue clause, Ruby takes turns comparing the thrown exception with each parameter. If rescue the exception named in the clause is the same as the type of exception currentlythrown, or is the parent of the exception, the match is successful.

If the exception does not match all the specified error types, we can use all the rescue clause with a else clause.

6.30.2. Example #

#!/usr/bin/rubybeginfile=open("/unexistant_file")iffileputs"File opened
successfully"endrescuefile=STDINendprintfile,"==",STDIN,"\\n"

The running output of the above example is. As you can see, STDIN replaced file because it failed to open

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

Use retry statement #

You can use the rescue block to catch an exception, and then use the retry the statement is executed from the beginning begin block.

6.30.3. Grammar #

Begin # The exception thrown by this code will be resolved by the following
Clause capture rescue # This block will capture all types of exception retries
#This will move control to begin
The beginning end of

6.30.4. Example #

#!/usr/bin/rubybeginfile=open("/unexistant_file")iffileputs"File opened
successfully"endrescuefname="existant_file"retryend

The following is the process flow:

An exception occurred when it was opened.
Skip to rescue . fname is reassigned.
Pass through retry skip to begin the beginning.
The file was opened successfully this time.
Continue the basic process.

Note: if the renamed file does not exist, this example code will try indefinitely. So when handling exceptions, use them cautiously retry .

Use `raise` statement #

You can use the raise statement throws an exception. The following method throws an exception when called. Its second message will be output.

6.30.5. Grammar #

raise or raise"Error Message" or raiseExceptionType,"Error
Message" or raiseExceptionType,"Error Message"condition

The first form simply re-throws the current exception (throwing a RuntimeError if there is no current exception). This is used in exception handlers that need to interpret the exception before passing in the exception.

The second form creates a new RuntimeError exception, set its message to the given string. The exception is then thrown to the call stack.

The third form uses the first parameter to create an exception, and then sets the related message to the second parameter.

The fourth form is similar to the third form, where you can add any additional conditional statements, such as unless to throw an exception

6.30.6. Example #

#!/usr/bin/rubybeginputs'I am before the raise.'raise'An error has
occurred.'puts'I am after the raise.'rescueputs'I am rescued.'endputs'I
am after the begin block.'

The output of the above instance is as follows:

I am before the raise.
I am rescued.
I am after the begin block.

Another demonstration. raise examples of usage:

6.30.7. Example #

#!/usr/bin/rubybeginraise'A test
exception.'rescueException=>eputse.messageputse.backtrace.inspectend

The output of the above instance is as follows:

A test exception.
["main.rb:4"]

Use `ensure` statement #

Sometimes, whether or not an exception is thrown, you need to make sure thatsome processing is done at the end of the code block. For example, you may open a file when you enter, and when you exit the block, you need to make sure that the file is closed.

This is what the ensure clause does. ensure put it on the last one``rescue`` clause and contains a block of code that is always executed when the block terminates. It has nothing to do with whether the block exitsnormally, whether an exception is thrown and handled, or whether it is terminated because of an uncaught exception. ensure block always runs.

6.30.8. Grammar #

Begin # Process # Throw exception rescue # Processing error ensure
#Finally, ensure the execution of #
This always executes end

6.30.9. Example #

beginraise'A test
exception.'rescueException=>eputse.messageputse.backtrace.inspectensureputs"Ensuring
execution"end

The output of the above instance is as follows:

A test exception.
["main.rb:4"]
Ensuring execution

Use `else` statement #

If provided else clause, which is usually placed in the rescue after the clause, any ensure before.

The body of the else clause executes only if the body of the code does not throw an exception.

6.30.10. Grammar #

Begin # Process # Throw exception rescue # Processing error else #
If there are no exceptions, execute ensure # Finally, ensure the
execution of # This always executes end

6.30.11. Example #

begin#Throw 'A test exception.'puts"I'm not raising
exception"rescueException=>eputse.messageputse.backtrace.inspectelseputs"Congratulations--
no errors!"ensureputs"Ensuring execution"end

The output of the above instance is as follows:

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

Use $! variables can catch thrown error messages.

Catch and Throw #

raise and rescue exception mechanism can abort execution when an error occurs, and sometimes need to jump out of some deeply nested structureduring normal processing. At this time catch and throw it comes in handy.

catch defines a block that uses a given name (which can be Symbol or String) as a label. Block will execute normally until one is encountered. throw .

6.30.12. Grammar #

Throw: lablename # This will not be executed by catch: lablenamedo
# When encountering a throw
The catchend or throw that will be executed after matching: lablenamecondition #
This will not be executed by catch: lablenamedo # Matching will be executed after encountering a throw
Catchend

Example #

In the following example, if the user types '!' in response to any prompts, use a throw terminates interaction with the user.

6.30.13. Example #

defpromptAndGet(prompt)printpromptres=readline.chompthrow:quitRequestedifres=="!"
returnresendcatch:quitRequesteddoname=promptAndGet("Name:")age=promptAndGet("Age:")
sex=promptAndGet("Sex:")#..#process information endpromptAndGet("Name:")

The above program requires human interaction, and you can try it on your computer. The output of the above instance is as follows:

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

Class `Exception` #

Ruby’s standard classes and modules throw exceptions. All exception classes form a hierarchy, including the top Exception including the class. The next layer is seven different types:

Interrupt
NoMemoryError
SignalException
ScriptError
StandardError
SystemExit

Fatal is another exception in this layer, but the Ruby interpreter uses it only internally.

ScriptError and StandardError there are some subclasses, but we don’t need to know these details here. The most important thing is to createour own exception classes, which must be classes Exception or a subclass of its descendants.

Let’s look at an example:

6.30.14. Example #

classFileSaveError<StandardErrorattr_reader:reasondefinitialize(reason)@reason=reasonendend

Now, looking at the following example, you will use the above exception:

Example #

File.open(path,"w")do\|file\|begin# Write data
...rescue# An error occurred raiseFileSaveError.new($!)endend

The most important line here is raise FileSaveError.new($!) . We call raise to indicate that the exception has occurred and pass it on to FileSaveError fails to write data due to a specific exception