Send for calling methods dynamically in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call the method dynamically using send.

Ruby

class Greeter
  def hello
    "Hello!"
  end
end

g = Greeter.new
puts g.[1](:hello)

Drag options to blanks, or click blank then click option'

Asend

Bcall

Cinvoke

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'call' instead of 'send' causes a NoMethodError.

Using 'invoke' or 'execute' are not valid Ruby methods for this purpose.

The send method in Ruby allows you to call a method by name dynamically.

2fill in blank

medium

Complete the code to call the method with an argument dynamically using send.

Ruby

class Calculator
  def square(n)
    n * n
  end
end

calc = Calculator.new
result = calc.[1](:square, 4)
puts result

Drag options to blanks, or click blank then click option'

Acall

Binvoke

Capply

Dsend

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'call' or 'apply' which are not Ruby methods for dynamic calls.

Forgetting to pass the argument after the method name.

send allows calling a method with arguments dynamically by passing the method name and arguments.

3fill in blank

hard

Fix the error in calling a private method dynamically using send.

Ruby

class Secret
  private
  def whisper
    "This is a secret"
  end
end

s = Secret.new
puts s.[1](:whisper)

Drag options to blanks, or click blank then click option'

Apublic_send

Bsend

Ccall

Dinvoke

Attempts:

3 left

💡 Hint

Common Mistakes

Using public_send causes NoMethodError for private methods.

Using call or invoke are not valid Ruby methods.

send can call private methods dynamically, while public_send cannot.

4fill in blank

hard

Fill both blanks to call a method dynamically and pass two arguments.

Ruby

class Multiplier
  def multiply(a, b)
    a * b
  end
end

m = Multiplier.new
result = m.[1](:multiply, [2], 5)
puts result

Drag options to blanks, or click blank then click option'

Asend

Bcall

C3

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Using call instead of send causes errors.

Passing wrong argument values.

send calls the method :multiply with arguments 3 and 5.

5fill in blank

hard

Fill all three blanks to call a method dynamically, pass an argument, and convert the result to a string.

Ruby

class Repeater
  def repeat(word, times)
    word * times
  end
end

r = Repeater.new
output = r.[1](:repeat, [2], 3).[3]

Drag options to blanks, or click blank then click option'

Asend

B"Hi"

Cto_s

Drepeat

Attempts:

3 left

💡 Hint

Common Mistakes

Using method name 'repeat' instead of send to call dynamically.

Not converting the result to string with to_s.

send calls :repeat with "Hi" and 3, then to_s converts the result to string.

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