Method in Ruby

A method allows us to write the piece of code at one place which get executed many times. This encourages modularity in the programs since writing the same code at different places tend to create more errors.

NOTE: Ruby methods are similar to functions in other languages.

Defining Method

In order to use a method, we need to first define it. A method is defined with the def keyword followed by method name and at the end we need to use end keyword to denote end of that method.


def method_name
  # code ...

NOTE: The Ruby method name should be written as snake_case. See Naming Conventions.

Method with arguments

As like other programming languages, we may pass arguments to a method in Ruby.

def hello(name)
  puts "Hello, #{name}"

hello("Ruby")   # output: Hello, Ruby

Default arguments

Ruby method can have default arguments. This arguments is used when call the method without passing any argument.

def hello(name = 'Foo')
  puts "Hello, #{name}"

hello()        # or just `hello` which is usually preferred with no argument


# output
Hello, Foo
Hello, Ruby
The parentheses are usually not used when using a method without arguments.

Return Values

By default, a method returns the result of the last statement evaluated in the body of the method. However, you can explicitly use the return keyword anywhere in the body to return from that point.

def hello(name)
  return "Returned" # our early return
  puts "Hello, #{name}" # this expression is never evaluated

def add(number1, number2)
  number1 + number2     # no need of 'return' keyword

add(10, 5)  # output: 15

Multiple Return values

In Ruby, only a single object may be returned. If we need multiple values from a method call, then we store those in an Array.

def swap(number1, number2)
  [number2, number1]

number1 = 10
number2 = 5

number1, number2 = swap(number1, number2)
puts number1 # output: 5
puts number2  # output: 10

Chaining Methods

We can chain methods together if we know the return value properly. This will help us to write expressive code.

def add(number1, number2)
  number1 + number2

add(2, 3).times { |i| puts "#{i} Hello" }


0 Hello
1 Hello
2 Hello
3 Hello
4 Hello

Method calls as arguments

In Ruby, we can use a method call as an argument to other methods.

def add(number1, number2)
  number1 + number2

def subtract(number1, number2)
  number1 - number2

def multiply(number1, number2)
  number1 * number2

puts multiply(add(3, 7), subtract(10, 5)) # output: 50

Local Variable Scope in Method

A method creates its own scope. A variable defined in the method are only accessible within that method and cannot be invoked from outside of method definition.

# we might assume that the 'update_name' will
# update the name variable from 'Foo' to 'Ruby'
name = "Foo"

def update_name
  name = "Ruby"

puts name # output: Foo

However, we are able to access some of the data if passed as argument.

languages = ['Ruby', 'C', 'Python', 'Go']

def update_language(languages)
  languages << 'JavaScript'

puts languages



NOTE: We can update the array here since it is passed as reference to method.

Help me to improve Code To Earn (c2e).