Custom exception classes in Ruby - Time & Space Complexity

Time Complexity: Custom exception classes

O(n)

Understanding Time Complexity

When we create custom exception classes in Ruby, we want to know how this affects the program's speed.

We ask: How does the time to run change as the program grows or uses these exceptions?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class MyError < StandardError
end

def check_value(x)
  raise MyError, "Value too small" if x < 10
  return x
end

values = [5, 15, 8, 20]
values.each do |v|
  begin
    puts check_value(v)
  rescue MyError => e
    puts e.message
  end
end

This code defines a custom error and uses it to check values in a list, raising the error if a value is too small.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the array with each and calling check_value for each item.
• How many times: Once for each element in the array (n times).

How Execution Grows With Input

As the number of values grows, the program checks each one in turn.

Input Size (n)	Approx. Operations
10	10 checks and possible exceptions
100	100 checks and possible exceptions
1000	1000 checks and possible exceptions

Pattern observation: The work grows directly with the number of items; doubling items doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of values checked.

Common Mistake

[X] Wrong: "Creating a custom exception makes the program slower in a way that changes the overall time complexity."

[OK] Correct: Defining a custom exception class is a one-time setup and does not add repeated work per item; it does not change how the program scales with input size.

Interview Connect

Understanding how exceptions affect program speed helps you write clear and efficient error handling, a skill valued in real projects and interviews.

Self-Check

"What if we raised the exception inside a nested loop over the array? How would the time complexity change?"

Practice

1. What is the main purpose of creating a custom exception class in Ruby?

easy

A. To define specific error types for clearer error handling

B. To speed up the program execution

C. To replace all built-in exceptions

D. To automatically fix errors in the code

Solution

1. Step 1: Understand the role of exceptions

   Exceptions represent errors or unexpected events in a program.

2. Step 2: Purpose of custom exceptions

   Custom exceptions let you create specific error types to handle different problems clearly.

3. Final Answer:

   To define specific error types for clearer error handling -> Option A

4. Quick Check:

   Custom exceptions = clearer error handling [OK]

Hint: Custom exceptions clarify error types for better handling [OK]

Common Mistakes:

• Thinking custom exceptions speed up code
• Believing they replace built-in exceptions
• Assuming they fix errors automatically

2. Which of the following is the correct way to define a custom exception class in Ruby?

easy

A. class MyError < StandardError; end

B. class MyError < Exception; end

C. def MyError; end

D. exception MyError inherits StandardError

Solution

1. Step 1: Check Ruby syntax for class inheritance

   In Ruby, custom exceptions inherit from StandardError for best practice.

2. Step 2: Identify correct class definition

   class MyError < StandardError; end correctly defines a class inheriting from StandardError using Ruby syntax.

3. Final Answer:

   class MyError < StandardError; end -> Option A

4. Quick Check:

   Custom exception syntax = class MyError < StandardError [OK]

Hint: Custom exceptions inherit StandardError with class syntax [OK]

Common Mistakes:

• Inheriting directly from Exception (not recommended)
• Using def instead of class
• Wrong inheritance syntax

3. What will be the output of this Ruby code?

class MyError < StandardError; end

begin
  raise MyError, "Something went wrong"
rescue MyError => e
  puts e.message
end

medium

A. MyError

B. StandardError

C. No output

D. Something went wrong

Solution

1. Step 1: Understand raise and rescue

   The code raises a MyError with message "Something went wrong" and rescues it as variable e.

2. Step 2: Output from exception message

   Inside rescue, puts e.message prints the error message string.

3. Final Answer:

   Something went wrong -> Option D

4. Quick Check:

   e.message prints error message string [OK]

Hint: e.message prints the error message string [OK]

Common Mistakes:

• Printing class name instead of message
• Expecting no output
• Confusing exception class with message

4. Identify the error in this Ruby code defining a custom exception:

class MyError
  def initialize(msg)
    super(msg)
  end
end

medium

A. Incorrect method name 'initialize'

B. Missing inheritance from StandardError

C. super should not be called in initialize

D. Class name should be lowercase

Solution

1. Step 1: Check class inheritance

   The class does not inherit from StandardError or any exception class, so it won't behave as an exception.

2. Step 2: Confirm other parts are correct

   Method name and super call are correct for passing message to parent class.

3. Final Answer:

   Missing inheritance from StandardError -> Option B

4. Quick Check:

   Custom exceptions must inherit StandardError [OK]

Hint: Always inherit StandardError for custom exceptions [OK]

Common Mistakes:

• Forgetting to inherit StandardError
• Thinking initialize method name is wrong
• Believing super call is unnecessary

5. You want to create a custom exception that stores an error code along with the message. Which code correctly implements this?

hard

A. class CodeError < StandardError
def initialize(msg)
@code = msg
end
end

B. class CodeError
def initialize(msg, code)
@code = code
super(msg)
end
end

C. class CodeError < StandardError
attr_reader :code
def initialize(msg, code)
super(msg)
@code = code
end
end

D. class CodeError < Exception
def initialize(code)
@code = code
end
end

Solution

1. Step 1: Check inheritance and attribute

   class CodeError < StandardError attr_reader :code def initialize(msg, code) super(msg) @code = code end end inherits from StandardError and defines attr_reader for code to access it.

2. Step 2: Verify initialize method

   It calls super(msg) to set the message and stores code in @code correctly.

3. Final Answer:

   class CodeError < StandardError with attr_reader and initialize(msg, code) -> Option C

4. Quick Check:

   Custom exception with extra data = class CodeError < StandardError attr_reader :code def initialize(msg, code) super(msg) @code = code end end [OK]

Hint: Use attr_reader and call super(msg) in initialize [OK]

Common Mistakes:

• Not inheriting from StandardError
• Calling super after instance variables
• Missing attr_reader for code