Paizaで遭遇したRuby メソッドまとめてみた。

webエンジニアへ転職活動中の[ニノ](https://x.com/MuscleEngi87389)です！

これまで`Rails`については、学習、個人開発を行ってきましたが、就活で`企業のコーデイング試験`を解く中で、`ruby`についての理解ができていないことがわかりました。そこで`paiza`をここ１ヶ月くらい解く中で新しく知った`ruby`のメソッドや用語をまとめておこうと思います。

### 用語
#### irb　：　Rubyを対話的に入力・実行するためのツール

### 知識
・Rubyでは、`大文字`で始まる変数（例: P, X, Y, Z）は「定数」として扱われる。

## メソッド

### `map`メソッド:

配列の各要素に対して何らかの操作を行い、その結果を集めて新しい配列を作成するメソッド
```ruby
# 基本構文
配列.map { |item| 実行する処理 }

# 例：各要素を2倍にした配列を返す
numbers = [1, 2, 3, 4, 5]
doubled_numbers = numbers.map { |n| n * 2 }
# => [2, 4, 6, 8, 10]

```

### `gets`メソッド:

ユーザーがキーボードで入力した値を文字列として取得するメソッド
※注意：
①入力されたオブジェクトは、必ず文字列オブジェクトである。
②末尾に改行になる。
```ruby
puts "名前を入力してください："
name = gets.chomp  # ユーザーが入力した内容を受け取る（改行を削除）
puts "こんにちは、#{name}さん！"
```

出力結果
```ruby
名前を入力してください：
赤井　# 入力
こんにちは、赤井さん！ 出力結果
```

### `chomp`メソッド:
末尾の改行コードを削除するメソッド

`chomp`なしの場合
```ruby
puts "名前を入力してください："
name = gets  # ユーザーが入力した内容を受け取る（改行あり）
puts "こんにちは、#{name}さん！"
```

出力結果
```ruby
名前を入力してください：
赤井　
こんにちは、赤井　# nameをchompなし&getsのみで受け取っているため、改行されて出力されている。
さん！
```

### `select`メソッド:
ブロック内で true を返した要素のみを集めて新しい配列として返すメソッド
（ブロック内で条件を指定し、その条件を満たす要素のみを返す）

例文
```ruby
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = numbers.select { |n| n.even? }

puts "偶数: #{even_numbers}"
# 出力: 偶数: [2, 4, 6, 8, 10]
```
※`even?`メソッド：偶数か奇数かを判別するメソッド。与えられた整数が偶数であればtrue、奇数であればfalseを返す。

### `max` メソッド：
配列の中から最大値を返すメソッド
例文
①数値の配列から最大値を取得する
```ruby
numbers = [5, 12, 8, 3, 19, 7]
max_value = numbers.max

puts "最大値は #{max_value} です。"
# 出力: 最大値は 19 です。
```
この例では、配列`[5, 12, 8, 3, 19, 7]`の中から最大値である`19`が取得されます。
②文字列の配列から辞書順で最大の文字列を取得する
```ruby
words = ["apple", "banana", "grape", "cherry"]
max_word = words.max

puts "辞書順で最も後ろの単語は #{max_word} です。"
# 出力: 辞書順で最も後ろの単語は grape です。
```

この例では、文字列の配列`["apple", "banana", "grape", "cherry"]`から辞書順で最も後ろに来る`"grape"`が最大値として返されます。

③複数の最大値を取得する（複数の要素を取りたい場合）
```ruby
numbers = [5, 12, 8, 3, 19, 7]
top_two = numbers.max(2)

puts "最大の2つの値は #{top_two} です。"
# 出力: 最大の2つの値は [19, 12] です。
```
この例では、`max(2)`を使って、配列の中から最大の2つの値[19, 12]を取得しています。


### `min` メソッド：
配列の中から最小の要素を返す便利なメソッド。数値の場合は最も小さい値、文字列の場合は辞書順で最も早いものが返される

例文
①数値の場合
```ruby
numbers = [5, 2, 9, 3, 7, 1]
min_value = numbers.min

puts "最小値は #{min_value} です。"
# 出力: 最小値は 1 です。
```
②文字列の場合
```ruby
words = ["apple", "banana", "cherry", "date"]
min_word = words.min

puts "辞書順で最も早い単語は #{min_word} です。"
# 出力: 辞書順で最も早い単語は apple です。
```

### `to_i`メソッド：
数字の文字列を数値オブジェクトに変換するメソッドであり、
文字列を整数に変換する際に便利で、変換できない文字列は0を返す仕様。

例文
①数字の文字列を整数に変換する
```ruby
str = "123"
num = str.to_i

puts "文字列 '#{str}' を整数に変換すると #{num} になります。"
# 出力: 文字列 '123' を整数に変換すると 123 になります。
```
②非数値文字列が含まれる場合の変換
```ruby
str = "123abc"
num = str.to_i

puts "文字列 '#{str}' を整数に変換すると #{num} になります。"
# 出力: 文字列 '123abc' を整数に変換すると 123 になります。
```

`to_i`メソッドは、文字列の先頭から変換できる部分を整数に変換します。非数値の部分が途中で現れる場合、そこまでの数値部分のみが変換されます。

③変換できない場合の挙動
```ruby
str = "abc"
num = str.to_i

puts "文字列 '#{str}' を整数に変換すると #{num} になります。"
# 出力: 文字列 'abc' を整数に変換すると 0 になります。
```
数字が含まれない文字列を`to_i`で変換すると、デフォルトで`0`が返されます。

### `include?`メソッド： 
文字列の中に、指定した文字列が含まれるか確かめるメソッド。
 戻り値は **真（true）または偽（false)** です。
 
例文
①指定した文字列が含まれているか確認する場合
```ruby
str = "Ruby is a wonderful programming language."
result = str.include?("wonderful")

puts result  # 出力: true
```
この例では、`"wonderful"`が文字列`str`に含まれているため、`true`が返されます。

②指定した文字列が含まれていない場合
```ruby
str = "Ruby is a wonderful programming language."
result = str.include?("Python")

puts result  # 出力: false
```
この例では、`"Python"`が含まれていないため、`false`が返されます。

③空文字列を確認する
```ruby
str = "Ruby"
result = str.include?("")

puts result  # 出力: true
```
空文字列は常に含まれているとみなされるため、この場合は`true`が返されます。


- `gsub`メソッド：指定したパターンにマッチしたすべての部分を特定の文字列に置換するメソッド

例文
①文字列の置換
```ruby
str = "I have a cat. The cat is cute."
new_str = str.gsub("cat", "dog")

puts new_str
# 出力: "I have a dog. The dog is cute."
```
この例では、`cat`という文字列がすべて`dog`に置き換えられています。

②正規表現を使った置換
```ruby
str = "I have 2 apples and 3 bananas."
new_str = str.gsub(/\d+/, "many")

puts new_str
# 出力: "I have many apples and many bananas."
```
この例では、正規表現`\d+`を使って数字（1桁以上の数字）をすべて`many`に置き換えています。
※\d+ は、正規表現のパターンの一部で、以下の意味を持っています。
`\d:` 任意の1桁の数字を表します。具体的には、`0` から` 9 `までの数字がマッチします。
`+:` 直前のパターン（この場合は `\d`）が**1回以上**繰り返されることを意味します。

つまり、`\d+` は「1桁以上の連続した数字」にマッチするパターンです。これにより、1桁の数字だけでなく、複数桁の数字（例: 12, 345, 6789 など）にもマッチします。

例:
`"12345"` に対して `\d+` を適用すると、`"12345"` 全体がマッチします。
`"I have 2 apples and 34 bananas."` に対して `\d+` を適用すると、`2` と `34` がそれぞれマッチします。
このパターンは、数値を検索、置換、抽出する際に非常に便利です。


③ 特定の文字を削除する
```ruby
str = "Hello, World!"
new_str = str.gsub(",", "")

puts new_str
# 出力: "Hello World!"
```
この例では、`gsub`を使ってカンマを空文字に置き換え（つまり削除）しています。

④ブロックを使った動的な置換
```ruby
str = "apple, banana, cherry"
new_str = str.gsub(/\w+/) { |word| word.upcase }

puts new_str
# 出力: "APPLE, BANANA, CHERRY"
```
この例では、`単語（\w+）`ごとに`upcase`メソッドを使って大文字に変換しています。gsubのブロックを使うことで、動的な処理が可能です。

※`upcase`メソッド：小文字の文字列を大文字に変換するメソッド

### `chars`メソッド :
文字列の各文字を1文字ずつ分解し、文字列の配列として返すメソッド。
**利点**：各文字に対して処理を行うことが簡単になる。

例文
①`chars`メソッドで文字列を配列に変換する
```ruby
str = "hello"
char_array = str.chars

puts char_array.inspect
# 出力: ["h", "e", "l", "l", "o"]
```
この例では、文字列 `"hello"` がそれぞれの文字に分解されて、`["h", "e", "l", "l", "o"]` という配列が返されます。
※`inspect`メソッドについては、下記で別途解説してます。


②各文字を配列に変換して処理する
```ruby
str = "Ruby"
char_array = str.chars

char_array.each do |char|
  puts char
end
# 出力:
# R
# u
# b
# y
```
この例では、`chars`メソッドを使って文字列 `"Ruby"`を分解し、それぞれの文字を1行ずつ出力しています。

- `inspect`メソッド:オブジェクトの「内部表現」を文字列として返すメソッド
通常、デバッグや詳細な情報を確認したいときに使います。inspectは、オブジェクトの内容をわかりやすく表示し、配列やハッシュなどの構造を確認するのに便利です。

**具体的な役割**

- 配列やハッシュなどの複雑なオブジェクトの内容をそのままの形で表示します
- 文字列の場合はダブルクォートで囲まれた形で表示されます

**例文**
①`inspect`を使った配列の表示
```ruby
char_array = ["h", "e", "l", "l", "o"]
puts char_array.inspect
# 出力: ["h", "e", "l", "l", "o"]
```
この例では、`inspect`メソッドを使うことで、`char_array`の内部表現である`["h", "e", "l", "l", "o"]`がそのまま表示されます。`puts`で普通に配列を表示する場合は、要素が改行されますが、`inspect`を使うと配列全体が1行で表示されます。

②`puts`と`inspect`の違い
```ruby
char_array = ["h", "e", "l", "l", "o"]

# 普通にputsで表示
puts char_array
# 出力:
# h
# e
# l
# l
# o

# inspectを使って表示
puts char_array.inspect
# 出力: ["h", "e", "l", "l", "o"]
```
`puts char_array`は配列の各要素を改行して表示しますが、
`puts char_array.inspect`は配列の全体像を、見たままの形で出力します。

### `split` メソッド：
指定した区切り文字で文字列を分割し、配列に変換するメソッド。

例文
①スペースで文字列を分割する
```ruby
str = "Ruby is a powerful programming language"
words_array = str.split(" ")

puts words_array.inspect
# 出力: ["Ruby", "is", "a", "powerful", "programming", "language"]
```
この例では、スペース（`" "`）で文字列を分割し、それぞれの単語を要素とする配列が返されます。

②カンマで文字列を分割する
```ruby
str = "apple,banana,cherry,grape"
fruits_array = str.split(",")

puts fruits_array.inspect
# 出力: ["apple", "banana", "cherry", "grape"]
```
この例では、カンマ（`,`）を区切り文字として文字列を分割し、各要素が配列に変換されます。

③区切り文字を指定しない場合（デフォルトのスペースで分割）
```ruby
str = "Hello World from Ruby"
words_array = str.split

puts words_array.inspect
# 出力: ["Hello", "World", "from", "Ruby"]
```
区切り文字を指定しない場合、デフォルトでスペース（空白文字、タブ、改行など）を使って分割されます。

④正規表現を使って分割する
```ruby
str = "one1two2three3four"
numbers_and_words = str.split(/\d/)

puts numbers_and_words.inspect
# 出力: ["one", "two", "three", "four"]
```
この例では、正規表現`\d`（数字）を区切り文字として使い、数字で分割しています。

### `each_char` メソッド：
文字列に対して使われるメソッドで、文字列の各文字に対して1文字ずつ処理を行います。ブロックを使って文字ごとに操作を実行できます。
文字列の中の1文字ずつに対して何らかの処理を行いたい場合、各文字を順にチェックしたり、カウントしたり、処理を加えたいときに便利です。
```ruby
str = "hello"

str.each_char do |char|
  puts char
end
```
出力
```
h
e
l
l
o
```
この例では、`each_char`メソッドを使って、文字列 `"hello"`の各文字を1つずつ取り出し、それをブロック内で処理しています。この場合は、各文字を1行ずつ出力しています。

### `values`メソッド: 
ハッシュのすべての値（キーに対応する部分）を配列として取得するためのメソッド。

例文
①ハッシュのすべての値を取得する
```ruby
student_scores = { "Alice" => 85, "Bob" => 92, "Charlie" => 78 }
scores = student_scores.values

puts "全てのスコア: #{scores}"
# 出力: 全てのスコア: [85, 92, 78]
```
この例では、student_scoresハッシュのすべての値が配列`[85, 92, 78]`として返されます。

②`values`メソッドで得た配列を使って計算を行う
```ruby
student_scores = { "Alice" => 85, "Bob" => 92, "Charlie" => 78 }
scores = student_scores.values

average_score = scores.sum / scores.size
puts "平均スコア: #{average_score}"
# 出力: 平均スコア: 85
```
この例では、`values`メソッドを使ってすべてのスコアを配列として取得し、その配列を使って平均スコアを計算しています。

### `sort`メソッド：
昇順に並び替えるメソッド。
例文
①数値の配列を昇順に並べ替える
```ruby
numbers = [5, 3, 8, 1, 2]
sorted_numbers = numbers.sort

puts "昇順に並べ替えた配列: #{sorted_numbers}"
# 出力: 昇順に並べ替えた配列: [1, 2, 3, 5, 8]
```
②文字列の配列を辞書順に並べ替える
```ruby
words = ["banana", "apple", "cherry", "date"]
sorted_words = words.sort

puts "辞書順に並べ替えた配列: #{sorted_words}"
# 出力: 辞書順に並べ替えた配列: ["apple", "banana", "cherry", "date"]
```
③sortメソッドにブロックを渡す
```ruby
numbers = [5, 3, 8, 1, 2]
sorted_numbers_desc = numbers.sort { |a, b| b <=> a }

puts "降順に並べ替えた配列: #{sorted_numbers_desc}"
# 出力: 降順に並べ替えた配列: [8, 5, 3, 2, 1]
```
この例では、sortメソッドにブロックを渡し、降順に並べ替えています。`<=>`演算子を使用して並べ替え順を指定できます。


## 振り返り
一部ですが、paizaを解く中でよく使用すると感じた`Ruby`のメソッドについて、よく使用するが理解できていなかったメソッドについてまとめてみました。
これまで、`Ruby`のフレームワークである`Rails`については、チュートリアル、個人開発を通して、学習してきましたが、いざ素の`ruby`を使用してアルゴリズム問題を解こうと思うと、知らないメソッド、理解できていないメソッドが多いと気づき、再度`ruby`の学習を再開しました。

`Rails`は、下記の特徴があると思います。
- 良くも悪くもよく理解していないままコードを書いても動く。
- `gem`などの便利なツールによって、各メソッドの理解をしていなくても、なんとなくで実装出来てしまう。

私自身、まだまだ学習することばかりですが、この`paiza`を通した`ruby`のアルゴリズム学習の段階で学習の仕方を見直すことが出来て良かったです。

これは就活のコーディング試験に出会えたことがきっかけですが、この経験に限らず、何事も**行動→反省→改善→成長**のサイクルが大切だと感じました。

最後まで読んでいただき、ありがとうございました！！

今回、書ききれなかったメソッドや予約語についても、別の記事か、この記事にアップデートしていこうと思います！

よければ[twitter](https://x.com/MuscleEngi87389)の方のフォローお願いします！