Methods

Learning Goals

• Explain the purpose of methods
• Use built-in methods on appropriate objects based on data type
• Define and call methods in Ruby
• Use and explain the flow of data with arguments and parameters
• Describe the purpose of a return value

Vocabulary

• method
• define
• execute or call
• return
• parameter
• argument

Methods

A Method is a package of instructions. Once a method is defined, it can be used as many times as needed. Ruby provides many built-in methods that developers can use.

Defining Our Own Methods

There are many methods that are built into the Ruby language. Those are great and you will use them regularly as a developer (and you’ll explore them later today!). There will also be times when you need to write your own method to solve a unique problem in the application you are building or maintaining.

Syntax for Defining a Method

To define our own method, we’ll use the following guidelines:

• The def and end keywords act like bookends for the code block.
• Following the keyword def, we assign our method a name. It’s best if the name describes what the method does.
• The code block is indented and contains all of the “instructions” for what the method should do when it is called.
• The value on the last line of the code block is the data that the method will return when it is called.

In the method below, the code block has only one line, but it’s important to note that there could be many lines of code within the code block, describing the steps that a method should follow. You can even include other things we’ve learned like conditionals and built-in methods within your code block.

# method definition
def greet_a_texan
  "Howdy, partner!"
end

After defining a method, nothing will appear to happen. The interpreter that reads the Ruby code will read it, and be aware of that set of instructions, but it won’t carry out those instructions until it is explicitly told to do so.

Syntax for Calling a Method

To instruct the interpreter to carry out the instructions in a method, the developer must write code to call or execute that method. Simply writing the name of the method, greet_a_texan in this example, calls or executes the method. When we call this method by writing the name of the method, it triggers the “instructions” held within the code block of that method. Now, this method by itself only returns the string “Howdy, partner!” - we still need to use a puts command to see that return value in the console.

# method call
greet_a_texan

Naming Conventions

Since methods provide action to a program, they should be named accordingly; it’s best practice to start them with a verb. Like variables, Ruby methods should use snake_case when they involve more than one word and should be written carefully to describe their role specifically without being overly verbose.

Examples of method names that follow best practices:

• get_user_input
• display_followers
• add_two_numbers
• find_longest_name

In the example above, the developer chose the method name of greet_a_texan. Method names should usually include verbs, since methods do something. The definition just tells the program that it’s a set of directions ready to be followed; the method call is what makes the code in the method execute, or follow the packaged directions. You can call a method as many times as you want, once it’s been defined!

A Method Metaphor

Often, we want to use a method to perform an action on or with a piece of data. Think back to those built-in methods. We didn’t simply call the odd? method by itself. We called it on an Integer object and it returned a Boolean value. We can do the same thing with the methods we define. Think of your method like a machine with inputs and outputs.

If this were a cookie machine, for example, the machine would take in all of the raw ingredients (eggs, flour, sugar, etc.) and perform some steps to make the cookies:

1. Mix ingredients to make dough
2. Place dough balls on a baking sheet
3. Bake at 350 degrees for 10 minutes
4. Let cookies cool
5. Serve the cookies on a plate

We can imagine that our cookie machine would do all of those steps and then give us back freshly baked, warm cookies!

Let’s expand this example to any kind of machine. We give the machine the raw materials, it does something with those materials, and then returns the final product. This is very similar to what we are doing with our own methods. We give the method some piece of data or information (or even multiple pieces of information) and then the method does something with that information and spits out a return value.

  greet_a_texan("Kaitlyn")
  # => "Howdy, Kaitlyn!"

Without possibly having all the information about Ruby syntax, you probably made some connection as to what might be happening with the previous code snippet. The greet_a_texan method was called, but this time, we were able to dynamically change the name of the person we were greeting!

Arguments & Parameters

Arguments are the technical term for the inputs to a method such as the String that was provided in the parenthesis after the method name in the previous example. As developers, we have the control to name the parameters, or placeholders, for the data that will be passed in. Those names should follow variable name conventions and be concise, yet descriptive. The number of arguments passed in should match the number of parameters declared.

# name is a parameter
def greet_a_texan(name)
  "Howdy, #{name}!"
end

# "Kaitlyn" is the argument for this method call
puts greet_a_texan("Kaitlyn")
# => "Howdy, Kaitlyn!"

# "Brian" is the argument for this method call
puts greet_a_texan("Brian")
# => "Howdy, Brian!"

Note: You’ll notice that we are using the puts command in front of the method call this time. This allows us to also see the return value of the greet_a_texan method printed to the console, but it is not necessary. The code greet_a_texan("Kaitlyn") by itself does return the string “Howdy, Kaitlyn!”, but if we want to see it printed in the console, we will need to use puts or print along with the method call.

Return Values

A return value is either:

• Defined implicity: By default, the last line of code automatically becomes the return value of the method.
  OR
• Defined explicitly: By using the return keyword, we can also specify the return value of the method.

In the add example below, the return value is an Integer or Float, based on what values were passed in as arguments. If 2 and 3 are passed in, the return value is 5. This is called an implicit return. Ruby automatically returns the value of the last expression in a method if no return is present. For this reason, if we want to return the value of the last expression in a method, we usually do not use the return keyword, as it is considered redundant and unnecessary.

def add(num1, num2)
  num1 + num2
end

add(2, 3)
# => 5 (return value is 5 since that's the sum of 2+3, and on the last line of the method)

In the subtract example below, the return value will be whatever is stored in the difference variable. If 10 and 7 are passed in as arguments, the return value is 3 because the last line of the method uses the return keyword to return the difference variable. This is called an explicit return.

def subtract(bigger, smaller)
  difference = bigger - smaller
  return difference
end

subtract(10, 7)
#  => 3 (return value is 3 since it is stored in the difference variable, and the last line of the method uses the return keyword)

Be Careful with puts Inside of Your Method

In the say_goodbye example below, notice we included the puts command in the last line of the method instead of returning a data point. The return value is nil because the last line of code is puts "See you later", and puts is a built-in command with a return value of nil. This is generally not a best practice, because the method doesn’t return any usable data.

def say_goodbye
  puts "See you later!"
end

say_goodbye
# "See you later!" will be printed to the console
# The return value is nil because puts is on the last line of the method and the return value of the puts method is always nil

Key Point: Up until now, we’ve use the puts and print commands to see values printed to the console. Be careful not to confuse what you see in the console with the return value of the method – these are two different things. We use puts and print to see data in the console, but what we see in the console is not always the return values.

Storing a Return Value

The examples we’ve looked at so far call the method and execute the code within the method, but the return values go nowhere/can never be used in the program again. Many times, we’ll store the return value of a method in another variable, as modeled below:

def add(num1, num2)
  num1 + num2
end

sum1 = add(2, 3)
sum2 = add(7, 9)

puts sum1
puts sum2

Self-Teach

Part of what you’ll experience at Turing is learning a technical topic on your own. Practicing this skill at Turing will get you prepared for the job where you will do this often.

Take time between now and your next session to self-teach the following section.

Warm-Up for Built-In Methods

Methods

A Method is a package of instructions. Once a method is defined, it can be used as many times as needed. Ruby provides many built-in methods that developers can use.

The code snippet that follows was part of the previous Exploration activity:

p 14.odd? 

To describe the code snippet in English, one could say, “the odd question mark method is being called on the Integer 14.” Since 14 is not odd, false will be the return value. The p command prints that return value of false to the console.

In this particular example, the utility of the odd? method is to determine if an Integer is odd, or not. It answers the question with a Boolean (true or false). The benefit of having this method built into Ruby is if a developer needs to check if a number is odd or not, they only have to type .odd? anywhere they need to check. If they didn’t have a pre-packaged method, they’d have to write several lines of code involving logic, every time they want to check if an integer is odd. Reusability is what makes methods so powerful.

The following code snippet demonstrates that a method can be called on a variable assigned to data:

new_string = "Hello World"
p new_string.upcase

To describe the code snippet in English, one could say, “the first line declares a variable called new_string and the second line calls the upcase method on the new_string variable.” As a result, the method will return a String object where any letter character in the original String stored in new_string will now be capitalized. The p command prints that return value of "HELLO WORLD" to the console. However, it’s important to note that the original data stored in new_string is not modified permanently.

Check For Understanding

• Complete the tasks in this repository.
• Add a link to your respository under a new section of your Mod 0 Gist called Methods.