2 Objects, methods, and local variables

This chapter orients you to Ruby’s object-first mindset: everything you do is done by sending messages (calling methods) to objects. You can create generic objects and “teach” them behaviors with methods, including singleton methods defined on a single object. Method calls may take arguments, and a call always returns a value (by default, the last evaluated expression). Ruby favors readable code: parentheses are often optional, and string interpolation helps compose output succinctly. Predicate methods that end with a question mark communicate Boolean queries cleanly, and Ruby’s truthiness rules are simple—only false and nil are treated as false.

It also shows how to explore and leverage built-in capabilities and flexible calling conventions. Objects come with innate methods you can inspect, and tools like object_id (identity), respond_to? (capability checks), and send/__send__/public_send (dynamic message dispatch) enable introspection and safe, dynamic behavior—especially when validating user input. Method parameters are covered in depth: required arguments, optional defaults, and variable-length “splat” parameters can be mixed; required parameters on either end get priority, splat gathers the rest, and defaults live in the middle. You learn the ordering rules, what combinations are invalid, and that every call binds parameters to local variables and returns a value.

Finally, the chapter clarifies local variables, scope, and references. Local variables are scoped (a method’s x is not another method’s x), and most variables hold references to objects rather than the objects themselves—so in-place mutations are visible through all references, while reassignment retargets only the reassigned variable. Because arguments are passed as references, called methods can mutate passed objects; you can protect data with dup/clone and freeze (noting that freezing a collection doesn’t freeze its elements). The chapter closes with how Ruby resolves bare identifiers—keyword, local variable, or method call—and how unresolved names raise informative errors, preparing you to move on to class-based object construction.

Anatomy of a method definition.

Argument assignment logic in action.

• Create a new object and define methods for it.
• The basics of the message-sending mechanism by which you send requests to objects for information or action.
• The process of mapping elements of a domain (even a modest one-entity domain like “a ticket to an event”) onto a system of objects so that those objects can store information and perform relevant tasks.
• Several of the important built-in methods that every Ruby object comes with: object_id, respond_to?, and send.
• Details of the syntax for method argument lists, including the use of required, optional, and default-valued arguments.
• How local variables and variable assignment work.
• Ruby’s use of references to objects and how references play out when multiple variables refer to the same object.
• The role of “real world” modeling in the process of thinking about object-oriented program design—and why it’s important not to overemphasize real-world parallels and analogies.
• The language offers lots of facilities for developing program structure. Creating objects one by one, as we’ve done in this chapter, is little more than the tip of the iceberg.

FAQ