What does inspect do in Ruby?

In Ruby, the inspect method returns a developer-friendly, human-readable string representation of an object, primarily used for debugging and introspection. It provides a detailed look at an object's internal state, making it an indispensable tool for understanding how an object is structured and what data it holds.

Default Behavior of inspect

By default, the inspect method, inherited by all objects, generates a string that provides specific details about the object. This default output typically includes:

• The object's class name: Identifying its type.
• An encoding of its memory address (object ID): A unique hexadecimal identifier for that specific object instance.
• A list of its instance variables and their values: inspect recursively calls inspect on each instance variable's value to ensure a comprehensive representation of nested objects.

This detailed default representation helps developers quickly grasp an object's identity and its current state, especially when dealing with complex data structures or during debugging sessions.

Example of Default inspect Output

Consider the following examples demonstrating inspect's default behavior:

# For a basic String object
"Hello, Ruby!".inspect # => "\"Hello, Ruby!\""

# For an Array containing various types
[1, 2, "three", :four].inspect # => "[1, 2, \"three\", :four]"

# For a custom class instance before overriding inspect
class Gadget
  def initialize(name, serial_number)
    @name = name
    @serial_number = serial_number
  end
end

my_gadget = Gadget.new("Smartwatch", "SN12345")
puts my_gadget.inspect
# Output (memory address will vary): #<Gadget:0x00007fbe01046d50 @name="Smartwatch", @serial_number="SN12345">

As seen in the Gadget example, the output clearly shows the class name (Gadget), a unique object ID (memory address), and the values of its instance variables (@name and @serial_number), with string values also being inspected.

inspect vs. to_s

While both inspect and to_s convert an object into a string, they serve distinct purposes:

Feature	inspect	to_s
Primary Goal	Debugging, developer introspection	User-friendly display, general string conversion
Default Content	Class name, object ID, detailed instance variables (recursive inspect)	Often a simpler or generic description (e.g., class and object ID for custom objects), or specific display string for built-ins
Audience	Developers, system logs	End-users, application output
String Literal	Includes quotes for strings, making output unambiguous	Generally omits quotes for strings unless part of the custom implementation

• Use inspect when you need a comprehensive, unambiguous representation of an object's internal state, particularly during development, testing, or detailed logging.
• Use to_s when you need a simple, human-readable string for display purposes, such as printing to the console for an end-user or for string interpolation.

Overriding inspect for Custom Classes

For user-defined classes, it is a common and recommended practice to override the default inspect method. This allows you to provide a more meaningful, concise, and context-relevant string representation of your objects, significantly improving the debugging experience. Instead of a generic output, you can highlight the most important attributes or a summary of the object's purpose.

Example of Overriding inspect

Let's enhance our Gadget class by overriding inspect:

class Gadget
  def initialize(name, serial_number, color)
    @name = name
    @serial_number = serial_number
    @color = color
  end

  # Override the inspect method
  def inspect
    "#<Gadget: '#{@name}' (SN: #{@serial_number}), Color: #{@color}>"
  end
end

my_new_gadget = Gadget.new("E-Reader", "ER-98765", "Black")
puts my_new_gadget.inspect
# Output: #<Gadget: 'E-Reader' (SN: ER-98765), Color: Black>

By overriding inspect, the output now directly provides the most useful information about the Gadget object in a clear, custom format, making it much easier to identify and understand in development environments.

For more information on Ruby's core Object methods, refer to the official Ruby-Doc for Object#inspect.