# Collect and Return Values

## Iteration: Each Vs. Collect

### Objectives

1. Identify the return values of the `each` and `collect` methods.
2. Implement the `each` and `collect` methods.

### Overview

This lesson will give a deeper dive on how to use the `each` and `collect` methods.

For our examples we will be building a `hamburger` method that takes an array of `toppings` as an argument.

#### What we want our methods to do

* Take in an array of hamburger toppings.
* Iterate through each topping, one at a time.
* Manipulate that data (do something to it).
* Return the manipulated data.

## Each

The most important thing to remember about `each` is that it does not change the return value. It implicitly returns the original array.

```
toppings = ["pickles", "mushrooms", "bacon"]

def hamburger(toppings)
  toppings.each do |topping|
    puts "I love #{topping} on my burgers!"
  end
end
```

#### This method will print:

```
I love pickles on my burgers!
I love mushrooms on my burgers!
I love bacon on my burgers!
```

#### But the return value is still:

`["pickles", "mushrooms", "bacon"]`

#### If we want a different return value, we have to explicitly tell it to do so.

In this version of our burger method we set an empty array called `my_statements`, which we will then explicitly return after we finish our loop. Inside our `each` statement loop, we manipulate each topping by interpolating it inside a string. We then push that string into our `my_statements` array. After we iterate over each topping in our array, we return the new `my_statements` array.

You'll notice that since the `each` doesn't return the thing we want, we have to add an extra line at the end that returns the `my_statements` array.

```
def hamburger(toppings)
  my_statements = []
  toppings.each do |topping|
    my_statements << "I love #{topping} on my burgers!"
  end
  my_statements
end
```

### Our new return value:

```
["I love pickles on my burgers!",
 "I love mushrooms on my burgers!",
 "I love bacon on my burgers!"]
```

However, if we do want a different return value, there is a handy method called `map`, also known as `collect`. These methods are abstractions of our `each` method. An abstraction is the process of taking away or removing characteristics from something in order to reduce it to a set of essential characteristics. Let's take a look at a few examples.

## Map & Collect

```
toppings = ["pickles", "mushrooms", "bacon"]

def hamburger(toppings)
  toppings.map do |topping|
    puts "I love #{topping} on my burgers!"
  end
end
```

Since `map` and `collect` are the same thing, this can be expressed exactly the same way with `collect`, like the following.

```
toppings = ["pickles", "mushrooms", "bacon"]

def hamburger(toppings)
  toppings.collect do |topping|
    puts "I love #{topping} on my burgers!"
  end
end
```

#### This method will print:

```
I love pickles on my burgers!
I love mushrooms on my burgers!
I love bacon on my burgers!
```

#### This method will return:

`[nil, nil, nil]`

#### Why does it return nil?

If you look inside our `map` loop, you will see that we are using `puts`, which always has a `nil` return value. What this is telling us is that our return value is indeed being changed by `map`. Let's look at another example.

Here we are no longer using `puts`, but instead implicitly returning what is inside our block. Again showing that `map` will give us a new return value based on the logic inside our block.

```
def hamburger(toppings)
  toppings.collect do |topping|
    "I love #{topping} on my burgers"
  end
end
```

#### Our new return value:

```
["I love pickles on my burgers",
 "I love mushrooms on my burgers",
 "I love bacon on my burgers"]
```

### Takeaway:

* If you want the transformations to be reflected in the return value use `map` or `collect`.
* If you want to return the original return value use `each`.

View [Iteration: Each Vs. Collect](https://learn.co/lessons/each-vs-collect-readme) on Learn.co and start learning to code for free.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://certil-remy.gitbook.io/learn/ruby/untitled-24.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.