CODEWITHSUNDEEP
rubymetaprogramming
Christian Bankester
Christian Bankester

Reputation: 2124

What does send() do in Ruby?

Can someone please tell me what the following snippet

obj.send("#{method_name}")

is and does?

Upvotes: 152

Views: 154760

Answers (9)

prince_of_egipt
prince_of_egipt

Reputation: 1

I just stumbled upon a problem with parity check where #send can shorten the code by a significant amount, because it can serve as a placeholder for the method name using string interpolation.

Example:

number = 5
method_name = "odd"
number.send("#{method_name}?")

Result:

true

Upvotes: 0

Ravi Shekhar Thakur
Ravi Shekhar Thakur

Reputation: 23

I am pretty late to the topic. As a noob I just used it and wanted to be helpful to people like me who wanted straightforward answer. filter_hash.each{|k,v| order_additional_hash[send(method_name, k)] = v}

as seen above send(method_name) is the method, which we want to call. It matches the name and calls the method if the method name is passed as string in the params and k is the argument we want to pass in the method.

Upvotes: 1

Nikita Rybak
Nikita Rybak

Reputation: 68006

send is a Ruby method allowing to invoke another method by name passing it any arguments specified.

 class Klass
   def hello(*args)
     "Hello " + args.join(' ')
   end
 end
 k = Klass.new
 k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

Source

Upvotes: 138

BenKoshy
BenKoshy

Reputation: 35595

What does send do?

send is another way of "calling a method". Example:

o = Object.new
o.to_s # => "#<Object:0x00005614d7a24fa3>"
# is equivalent to:
o.send(:to_s) # => "#<Object:0x00005614d7a24fa3>"

Send lives in the Object class.

What is the benefit of this?

The benefit of this approach is that you can pass in the method you want to call as a parameter. Here is a simple example:

def dynamically_call_a_method(method_name)
    o = Object.new
    o.send method_name
end
dynamically_call_a_method(:to_s) # => "#<Object:0x00005614d7a24fa3>"

You can pass in the method you want to be called. In this case we passed in :to_s. This can be very handy when doing ruby metaprogramming, because this allows us to call different methods according to our different requirements.

Upvotes: 14

Chi Joel
Chi Joel

Reputation: 68

Send can also be used as a way of showing how everything in Ruby is an object

1.send(:+, 1)  ## -> 2
3.send(:*, 2)  ## -> 6

Upvotes: 5

JustAnotherRubyLover
JustAnotherRubyLover

Reputation: 21

Another use case for views:

    <%= link_to 
    send("first_part_of_path_#{some_dynamic_parameters}_end_path", 
    attr1, attr2), ....
    %>

Allow . you to write scalable view who work with all kind of objects with: 

    render 'your_view_path', object: "my_object"

Upvotes: 2

Antonio Jha
Antonio Jha

Reputation: 1309

One of the most useful feature I think with .send method is that it can dynamically call on method. This can save you a lot of typing. One of the most popular use of .send method is to assign attributes dynamically. For example:

class Car
  attr_accessor :make, :model, :year
end

To assign attributes regularly one would need to 

c = Car.new
c.make="Honda"
c.model="CRV"
c.year="2014"

Or using .send method:

c.send("make=", "Honda")
c.send("model=", "CRV")
c.send("year=","2014")

But it can all be replaced with the following:

Assuming your Rails app needs to assign attributes to your car class from user input, you can do

c = Car.new()
params.each do |key, value|
  c.send("#{key}=", value)
end

Upvotes: 81

Mike Vallano
Mike Vallano

Reputation: 326

Another example, similar to Antonio Jha's https://stackoverflow.com/a/26193804/1897857

is if you need to read attributes on an object.

For example, if you have an array of strings, if you try to iterate through them and call them on your object, it won't work.

atts = ['name', 'description']
@project = Project.first
atts.each do |a|
  puts @project.a
end
# => NoMethodError: undefined method `a'

However, you can send the strings to the object:

atts = ['name', 'description']
@project = Project.first
atts.each do |a|
  puts @project.send(a)
end
# => Vandalay Project
# => A very important project

Upvotes: 18

giraff
giraff

Reputation: 4711

send sends a message to an object instance and its ancestors in class hierarchy until some method reacts (because its name matches the first argument).

Practically speaking, those lines are equivalent:

1.send '+', 2
1.+(2)
1 + 2

Note that send bypasses visibility checks, so that you can call private methods, too (useful for unit testing).

If there is really no variable before send, that means that the global Object is used:

send :to_s    # "main"
send :class   # Object

Upvotes: 165

Related Questions