In Ruby, how can you call a method using the default argument or with the specified argument without repeating the code?

Question

Let's say I have a ruby ​​method:

def blah(foo=17)
   ...
end

In the code, I want to call blah with a specific argument "blah (a)" or call blah using my default argument "blah ()" Is there a way to do this without specifying the method name twice? I try to avoid:

if a.nil?
  blah()
else
  blah(a)
end

Because it makes the code more complex than it is. Best I can come up with (not a test):

args=[]
args << a unless a.nil?
a.send :blah, args

Answer 1

I just tried a few ways and didn't find it, but if you do so much, I wonder how to use the default setting. Try instead:

def blah(foo=nil)
  foo ||= 17
  puts foo
end

blah()
a = nil
blah(a)
a = 20
blah(a)

:

17
17
20

Answer 2

, , :

blah( *[a].compact )

Answer 3

, , , , - :

blah(a || 17)

, blah, , .

Answer 4

def blah(foo = nil)
    foo ||= 17
end

.

nil -value no-argument, , :

def blah
    foo = block_given? ? yield : 17
end

blah         #=> 17
blah { nil } #=> nil
blah { 71 }  #=> 71

Answer 5

. , if . . * , .

blah(*
  if a.nil?
    []
  else
    [a]
  end
)

You do not need to back off so, but it looked like indentation to make it clear.

Answer 6

I was looking for the same thing. (I think this is almost a mistake in the Ruby specs) I think I will resolve it in a different way using the hash option.

def foo(options={})
  bar = options.delete(:bar) || :default
  puts bar
end

foo 
#=> default

foo :bar => :something
#=> something

a = nil
foo :bar => a
#=> default

It is more extensible and readable for any rubist.