Ruby Methods

Methods in Ruby

A method in Ruby is a block of code that performs some specific task and returns some result, it can be called numerous times to execute that task. It can take some arguments as input and then return a value after performing some operations. Methods make code easier to read, maintain, and debug.

Creating a Method

The methods in Ruby are defined by using the def keyword, which is then followed by the method name and the parameters inside a parenthesis. Syntax The basic syntax for creating a method in Ruby is as follows:

Conventions to Write Method Names in Ruby

In Ruby, there are mainly two conventions that are used while writing method names.

1. First convention is to use lowercase letters and separate multiple words with underscores.
2. For methods that return a Boolean value, question marks are used to mark the end of the method name.

Examples Here are a few examples of methods in Ruby:

In this example, the method finds the product of two numbers that are passed as parameters.

In this example, the method checks if all the characters of the string passed as a parameter is in uppercase.

In this example, the method returns the last element of the array that is passed as an argument.

Passing Parameters in a Method in Ruby

How to Pass Parameters to a Method in Ruby?

In Ruby, parameters can be passed to a method by enclosing them in parentheses after the method name. Here's an example of a method that takes two parameters and returns their sum:

Variable Number of Parameters in a Method

Ruby enables programmers to create methods with a variable number of parameters in a method. It is helpful when the user is defining a method but is unsure of how many parameters must be provided. Let's look at an example:

Default Parameters

In Ruby, you can provide default values for parameters in a method. This allows the method to be called with fewer arguments than the number of parameters specified. Here's an example of a method that takes two parameters, with the second parameter having a default value:

In this example, the first method call uses the default value of the num2 variable since only one argument is passed. In the second method call, both the variables are passed to the method.

Since the order of parameters is important when the method is called, the first parameters in the parameter list should be the most often redefined parameters. As a result, we won't have to send the same value every time the method is called.

Return Statement in Ruby Methods

In Ruby, you can use the return keyword to specify a value to return from a method. If the return keyword is not used, then the method will return the value of the last expression evaluated. Here's an example of a method that returns the sum of two numbers using the return keyword and a multiply two numbers method that does not use the keyword:

Class/Instance Methods in Ruby

In Ruby, we can define methods inside a class which can be accessed via objects of that class. The methods which are only accessible by the instances of a class are called instance methods. Similarly, we can also have class methods that are bound to a class and not the instance of the class. We can access such methods by directly using the classname followed by the method name.

In this example, we have a class with both types of methods. The initialize method is a constructor that gets called when a new object is created. The class contains a class variable @@count that is shared across all instances of the class. If we want to make a class method accessible outside the class without instantiating it, then we can define the method with the classname followed by a period(.) and then a method name like Rectangle.getCount.

Alias Statement in Ruby

In Ruby, we can create an alias for a method using the alias keyword. This allows us to define multiple names for the same method. Here is an example of a method with an alias statement:

In this example, the method area_of_square can also be called with the name area.

Undef Statement in Ruby

In Ruby, we can undefine a method using the undef keyword. This allows us to remove a method that was previously defined. Here's an example of undefining a method:

In this example, we have a method called area. When we call that method after undefining it, we get an error message that the method the undefined.

Chaining Multiple Methods in Ruby

In Ruby, you can chain multiple methods calls together using the dot (.) operator. This allows you to call multiple methods on the same object in a single statement. Here's an example of chaining multiple methods:

In this example, we chain methods two methods to_a and reverse. Firstly the hash h gets converted to an array due to to_a method and then the array gets reversed due to the reverse method.