Ruby 2 Writing Own Ruby Methods

Let's look at writing one's own methods in Ruby with the help of a simple program p008mymethods.rb. Observe that we use def and end to declare a method. Parameters are simply a list of local variable names in parentheses.

We do not declare the return type; a method returns the value of the last statement executed in the method. It is recommended that you leave a single blank line between each method definition. The parentheses around a method's arguments are optional; our convention is to use them when a method has arguments and omit them when it doesn't. In Rails, you will see methods calls with no parentheses.

1. # p008mymethods.rb  
2. # A method returns the value of the last line  
3. # Methods that act as queries are often named with a trailing ?  
4. # Methods that are "dangerous," or modify the receiver, might be named  
5. # with a trailing ! (Bang methods)  
6. # A simple method  
7. def hello  
8.   'Hello'  
9. end  
10. #use the method  
11. puts hello  
12.   
13. # Method with an argument - 1  
14. def hello1(name)  
15.   'Hello ' + name  
16. end  
17. puts(hello1('satish'))  
18.   
19. # Method with an argument - 2  
20. def hello2 name2  
21.   'Hello ' + name2  
22. end  
23. puts(hello2 'talim')  

The output when I ran the program on my PC was:

1. >ruby p008mymethods.rb  
2. Hello  
3. Hello satish  
4. Hello talim  
5. >Exit code: 0  

Ruby lets you specify default values for a method's arguments-values that will be used if the caller doesn't pass them explicitly. You do this using the assignment operator. See example p009mymethods1.rb

1. # p009mymethods1.rb  
2. # interpolation refers to the process of inserting the result of an  
3. # expression into a string literal  
4. # the interpolation operator #{...} gets calculated separately  
5. def mtd(arg1="Dibya", arg2="Shashank", arg3="Shashank")  
6.   "#{arg1}, #{arg2}, #{arg3}."  
7. end  
8. puts mtd  
9. puts mtd("ruby")  

The output when I ran the program on my PC was:

1. >ruby p009mymethods1.rb  
2. Dibya, Shashank, Shashank.  
3. ruby, Shashank, Shashank.  
4. >Exit code: 0  

Please note that as of now, there is no way, to specify a value for the second parameter and use the default value of the first parameter.

In the above program the interpolation operator #{...} gets calculated separately and the results of the calculation are pasted automatically into the string. When you run these lines, you don't see the #{...} operator on your screen; instead, you see the results of calculating or evaluating what was inside that operator.

Note: Interpolation refers to the process of inserting the result of an expression into a string literal. The way to interpolate within a string is to place the expression within #{ and } symbols. An example demonstrates this:

1. puts "100 * 5 = #{100 * 5}"  

This displays:

1. 100 * 5 = 500  

The #{100 * 5} section interpolates the result of 100 * 5 into the string at that position, resulting in the output (500) as shown.

The example p010aliasmtd.rb talks about Aliasing a method.

1. alias new_name old_name  

creates a new name that refers to an existing method. When a method is aliased, the new name refers to a copy of the original method's body. If the method is subsequently redefined, the aliased name will still invoke the original implementation.

1. # p010aliasmtd.rb  
2. # alias new_name old_name  
3. # When a method is aliased, the new name refers  
4. # to a copy of the original method's body  
5.   
6. def oldmtd  
7.   "old method"  
8. end  
9. alias newmtd oldmtd  
10. def oldmtd  
11.   "old improved method"  
12. end  
13. puts oldmtd  
14. puts newmtd  

The output is:

1. >ruby p010aliasmtd.rb  
2. old improved method  
3. old method  
4. >Exit code: 0  

alias creates a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). Local variables, instance variables, class variables, and constants may not be aliased. The parameters to alias may be names or symbols.

Does Ruby allow us to write functions that can accept variable number of parameters? Yes, see the following example - p011vararg.rb

1. # p011vararg.rb  
2. # variable number of parameters example  
3. # The asterisk is actually taking all arguments you send to the method  
4. # and assigning them to an array named my_string as shown below  
5. # The do end is a Ruby block which we talk in length later  
6. def foo(*my_string)  
7.   my_string.inspect  
8. end  
9. puts foo('hello','world')  
10. puts foo()  

The asterisk (called the splat argument) is actually taking all arguments you send to the method and assigning them to an array named my_string. As you can see, by making use of the asterisk, we're even able to pass in zero arguments. The code above will result in the Array ['hello', 'world'] written in the first method call and an empty Array being written on the second call, as you can see in the following output:

1. >ruby p011vararg.rb  
2. ["hello", "world"]  
3. []  
4. >Exit code: 0  

In Ruby, you can put the splat argument anywhere in a method's parameter list:

1. def opt_args(a,*x,b)  

What is the maximum number of parameters we can pass in Ruby? There's no limit to the number of parameters.

What is the sequence in which the parameters are put on to the stack? Left to right like C or right to left like Pascal? The answer is Left to right as you can see in this example p012mtdstack.rb

1. # p012mtdstack.rb  
2. # Sequence in which the parameters are put on to the stack is left to right  
3. def mtd(a=99, b=a+1)  
4.   [a,b]  
5. end  
6. puts mtd # displays 99, 100  

Are the parameters passed by value or reference? Observe the following example:

1. def downer(string)  
2.   string.downcase  
3. end  
4. a = "HELLO"  
5. downer(a)      # -> "hello"  
6. puts a         # -> "HELLO"  
7.   
8. def downer(string)  
9.   string.downcase!  
10. end  
11. a = "HELLO"  
12. downer(a)      # -> "hello"  
13. puts a         # -> "hello"  

Gary Wright in the Ruby forum posted in reply to some posts: "It is confusing to me to even think about methods returning objects unless you are using that as a very specific shorthand for saying that methods return *references* to objects. That is the unifying idea that helped me understand how Ruby manipulates data -- it is all references and not the objects themselves. The objects themselves are almost completely hidden from the programmer (excluding C extensions) in Ruby. Everything is a reference to an object."

Bang (!) Methods

Ruby methods that modify an object in-place and end in an exclamation mark are known as bang methods. By convention, the bang labels a method as dangerous - specifically, as the dangerous equivalent of a method with the same name but without the bang.

You'll find a number of pairs of methods, one with the bang and one without. Those without the bang perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). The bang versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, chomp/chomp! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-bang version of the method on the object, you get a new object. If you call the bang version, you operate in-place on the same object to which you sent the message.

In Ruby you can define a method name that ends with an exclamation point or bang. The bang methods are called and executed just like any other method. However, by convention, a method with an exclamation point or bang is considered dangerous.

Normally for the built-in classes, dangerous usually (although not always) means this method, unlike its non-bang equivalent, permanently modifies its receiver.

You'll find a number of methods, one with the bang and one without. Those without the bang perform an action and return a new object. The bang versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

A few non-bang methods perform changes on the original string. The names of these methods make it clear that this is happening (such as replace), even though there's no ! on the name.

Method names ending with ?

The question mark has no special meaning to the Ruby interpreter. However, by convention, any method whose name ends with ? returns a value that answers the question posed by the method invocation. The empty? method of an array, for example, returns true if the array has no elements. Mostly such methods return one of the Boolean valuestrue or false, but this is not required, as any value other than false or nil works like true when a Boolean value is required. The Numeric method nonzero?, for example, returns nil if the number it is invoked on is zero, and just returns the number otherwise.