Optional arguments and default values

[Surgeon]

Hi,

How do I give a method optional arguments and default values?

Exmpl:

foo is a function that multiplies all of its arguments together. If
there is not any argument, a default value of "qwerty" returns.

foo(2,3) ----> 6
foo(2,3,5) ----> 30
foo(2,3,5,2) -> 60

foo() -----------> "qwerty"

 

[gabriele renzi]

Surgeon ha scritto:

Hi,

How do I give a method optional arguments and default values?

=> 5

Exmpl:

foo is a function that multiplies all of its arguments together. If
there is not any argument, a default value of "qwerty" returns.

foo(2,3) ----> 6
foo(2,3,5) ----> 30
foo(2,3,5,2) -> 60

foo() -----------> "qwerty"

maybe you want to get all the "rest" arguments with the "*"
declaration in the method like this:
=> 24


But I suggest you take a look at some ruby tutorial, this are basic things.

 

[Ross Bamford]

Hi,

How do I give a method optional arguments and default values?

Exmpl:

foo is a function that multiplies all of its arguments together. If
there is not any argument, a default value of "qwerty" returns.

foo(2,3) ----> 6
foo(2,3,5) ----> 30
foo(2,3,5,2) -> 60

foo() -----------> "qwerty"

Maybe:
def foo(*args)
args.empty? && "qwerty" or args.inject(0) { |s,i| s * i }
end

or:

def foo(*args)
if args.empty?
"qwerty"
else
args.inject(0) { |s,i| s * i }
end
end

Default values are slightly different:

def sum(v1 = 10, v2 = 5)
v1 + v2
end

Once you give a default value to an arg, you must also give defaults to
all following args (except any &block arg).

Defaults don't have to be literal - you can use anything

def foo(arg = somemethod('c')) ... end

even another arg

def foo(a1, a2 = a1) ... end

I believe they're evaluated in the scope of the method itself. It's quite
cool.

Cheers,

 

[Robert Klemme]

Maybe:
def foo(*args)
args.empty? && "qwerty" or args.inject(0) { |s,i| s * i }
end

or:

def foo(*args)
if args.empty?
"qwerty"
else
args.inject(0) { |s,i| s * i }
end
end

The implementation of Enumerable#inject allows for an even more elegant
solution

def foo(*args)
args.inject {|a,b| a*b} || "qwerty"
end
=> "qwerty"

Note: if args is empty this inject returns nil, if there is just one element
that is returned.

Another solution would be to implement things like this in Enumerable:

module Enumerable
def sum() inject(0) {|a,b| a+b} end
def product() inject(1) {|a,b| a*b} end
end

or

module Enumerable
def sum() inject {|a,b| a+b} end
def product() inject {|a,b| a*b} end
end

Allowing for invocations like these

[1,2,3,4].sum => 10
(1..4).sum => 10
(1...5).sum => 10
(1..10).map { rand 20 }.sum

=> 91

Kind regards

robert

 

[Ross Bamford]

The implementation of Enumerable#inject allows for an even more elegant
solution

def foo(*args)
args.inject {|a,b| a*b} || "qwerty"
end

=> "qwerty"

Note: if args is empty this inject returns nil, if there is just one
element that is returned.

Cool, I didn't know that, thanks for pointing it out

Cheers,