# inject method

`Enumerable#inject`

--Method for performing convolution operation

Reference: https://docs.ruby-lang.org/ja/latest/method/Enumerable/i/inject.html

### What is Enumerable in the first place?

`module`

. A mix-in for repeating classes. The following are famous friends (instance methods).

Reference: https://docs.ruby-lang.org/ja/latest/class/Enumerable.html

In Ruby, thanks to the ʻEnumerable` module, you can use methods with convenient iterations.

# Basic usage

```
ary = [1,2,3,4,5]
ary.inject(1){ |sum, n| sum + n }
# => 16
```

--The return value of each process in the block is in `sum`

.
--The method argument goes into the initial value (the block argument of the first process).
--Repeat until the last element, and the return value of the last block becomes the total return value.

,,,Hard to understand.

Let's make it easy to understand.

```
ary = [1,2,3,4,5]
ary.inject(1) do |sum, n|
puts sum
sum + n
end
=begin
=>1 (Initial value specified in the argument of inject"1"Enters sum)
=>2 (Initial value (sum)+Sum of the first element (n) of the array)
=>4 (The return value (2) of the previous process is in sum+Second element sum)
=>7 (Omitted below)
=>11
=>16 (overall return value)
=end
```

Can you imagine it somehow? This is ** folding **.

By the way, if you omit the method argument (`hoge`

part of ʻinject (hoge)`), the first element of the array will be set to the initial value.

```
ary = [1,2,3,4,5]
ary.inject do |sum, n|
puts sum
sum + n
end
=begin
=>1
=>3
=>6
=>10
=>15 (overall return value)
=end
```

# What makes me happy

With a proper understanding, you can write complex processes in an easy-to-understand manner. Since the processing inside the block can be repeated by folding, it can be written shorter than the ʻeach` method.

In other words, it is often used for refactoring iterations.

Let's write some practical code below.

# Actual usage

## Get the sum of the arrays

### For each

```
sum = 0
ary = [100,200,300,42,52]
ary.each { |n| sum += n }
puts sum
# =>694
```

### In case of inject

```
ary = [100,200,300,42,52]
sum = ary.inject { |s, n| s += n }
puts sum
# =>694
```

One line has decreased. Refreshing.