Send for calling methods dynamically in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the send method do in Ruby?

The send method calls another method by name dynamically, allowing you to invoke methods using a symbol or string representing the method's name.

beginner

How do you use send to call a method named greet on an object obj?

You write obj.send(:greet). This calls the greet method on obj dynamically.

intermediate

Can send pass arguments to the method it calls? How?

Yes. You pass arguments after the method name symbol. For example, obj.send(:add, 5, 3) calls add(5, 3) on obj.

intermediate

What is the difference between send and public_send?

send can call any method, including private ones. public_send only calls public methods and will raise an error if the method is private.

beginner

Why is send useful in Ruby programming?

It allows flexible and dynamic method calls, useful when method names are not known until runtime, like in metaprogramming or when handling user input.

What argument type does send expect for the method name?

A Symbol or String

B Integer

C Boolean

D Array

send expects the method name as a symbol or string to call it dynamically.

Which method allows calling private methods: send or public_send?

A Neither

B public_send

C send

D Both

send can call private methods, but public_send cannot.

What happens if you use public_send to call a private method?

A It calls the method successfully

B It calls the method but warns

C It returns nil

D It raises a NoMethodError

public_send raises a NoMethodError if the method is private.

How do you pass arguments to a method called with send?

A As a hash after the method name

B As additional parameters after the method name

C You cannot pass arguments with <code>send</code>

D Only one argument is allowed

Arguments are passed as additional parameters after the method name symbol or string.

Why might you use send instead of calling a method directly?

A To call methods dynamically when the method name is stored in a variable

B To improve performance

C To avoid syntax errors

D To make code shorter

send is useful for dynamic method calls when the method name is not known until runtime.

Explain how the send method works in Ruby and give an example of calling a method with arguments.

Think about how you can call a method when you only have its name as a string or symbol.

Describe the difference between send and public_send and when you might use each.

Consider which method respects Ruby's method visibility rules.

Practice

1. What does the Ruby method send do when used like obj.send(:method_name)?

easy

A. Calls the method named method_name on obj dynamically.

B. Creates a new method called method_name on obj.

C. Deletes the method named method_name from obj.

D. Returns the name of the method as a string.

Solution

1. Step 1: Understand send usage

   The send method calls a method on an object using the method's name given as a symbol or string.

2. Step 2: Analyze the example obj.send(:method_name)

   This calls the method named method_name on obj dynamically at runtime.

3. Final Answer:

   Calls the method named method_name on obj dynamically. -> Option A

4. Quick Check:

   send calls methods dynamically [OK]

Hint: Remember: send calls methods by name on objects [OK]

Common Mistakes:

• Thinking send creates or deletes methods
• Confusing send with method name retrieval
• Assuming send returns method names as strings

2. Which of the following is the correct syntax to call a method named greet on object user using send?

easy

A. user.send(greet)

B. user.send('greet')()

C. user.send['greet']

D. user.send(:greet)

Solution

1. Step 1: Recall send syntax

   The method name should be passed as a symbol or string without parentheses after send.

2. Step 2: Check each option

   user.send(greet) misses quotes or symbol, causing error. user.send(:greet) correctly uses a symbol :greet. user.send('greet')() wrongly adds parentheses after send call. user.send['greet'] uses incorrect bracket syntax.

3. Final Answer:

   user.send(:greet) -> Option D

4. Quick Check:

   Use symbol for method name in send [OK]

Hint: Use colon before method name symbol in send [OK]

Common Mistakes:

• Passing method name without quotes or colon
• Adding parentheses after send call
• Using brackets [] instead of parentheses ()

3. What is the output of this Ruby code?

class Person
  def greet(name)
    "Hello, #{name}!"
  end
end

p = Person.new
puts p.send(:greet, "Alice")

medium

A. Hello, Alice!

B. greet

C. NoMethodError

D. Hello, name!

Solution

1. Step 1: Understand the method call with send

   The send method calls greet on p with argument "Alice".

2. Step 2: Evaluate the method output

   The greet method returns "Hello, Alice!" which is printed by puts.

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   send calls greet with argument "Alice" [OK]

Hint: send passes arguments after method name [OK]

Common Mistakes:

• Expecting method name string as output
• Confusing argument passing with no arguments
• Thinking send returns method object

4. Identify the error in this Ruby code snippet:

class Calculator
  def add(a, b)
    a + b
  end
end

calc = Calculator.new
calc.send(:add, 5)

medium

A. send cannot be used with arguments

B. Method add does not exist

C. Missing second argument for method add

D. Syntax error in method definition

Solution

1. Step 1: Check method definition

   The method add requires two arguments: a and b.

2. Step 2: Analyze the send call

   The send call provides only one argument (5), missing the second argument.

3. Final Answer:

   Missing second argument for method add -> Option C

4. Quick Check:

   Method arguments must match when using send [OK]

Hint: Match method arguments count when using send [OK]

Common Mistakes:

• Passing fewer arguments than method requires
• Assuming send works without correct arguments
• Thinking send changes method signature

5. You want to call different arithmetic methods (add, subtract, multiply) on a Calculator object dynamically based on user input stored in operation. Which Ruby code correctly uses send to achieve this?

class Calculator
  def add(a, b); a + b; end
  def subtract(a, b); a - b; end
  def multiply(a, b); a * b; end
end

calc = Calculator.new
operation = :multiply
# Fill in the blank below to call the method dynamically
result = ???
puts result

hard

A. calc.send(:operation, 4, 5)

B. calc.send(operation, 4, 5)

C. calc.send('operation', 4, 5)

D. calc.send(operation())

Solution

1. Step 1: Understand dynamic method calling

   The variable operation holds the symbol of the method to call.

2. Step 2: Use send with variable method name and arguments

   Passing operation as the first argument to send calls the correct method with arguments 4 and 5.

3. Final Answer:

   calc.send(operation, 4, 5) -> Option B

4. Quick Check:

   send uses variable method names with arguments [OK]

Hint: Pass method name variable and args directly to send [OK]

Common Mistakes:

• Passing method name as string literal instead of variable
• Adding parentheses after variable name incorrectly
• Using symbol literal instead of variable for method name