【Ruby】基礎メソッド

## length/size
``Ruby``で``length``は「文字列の長さ」と「配列の長さ(配列の要素の数)」を 調べるためのメソッド。

**「文字列の長さ」を調べる際のlenght/size**

```rb
str = 'あいうえお'
str.length
=> 5
```

**「配列の長さ」を調べる際のlenght/size**

```rb
data = [1,2,3,4,5,6,7,8,9]
data.size
=> 9
```

## rand
ランダムで数値を生成してくれる。
引数に``100``を渡すと、``0~99``までのランダムな整数値を返す。
rand(1..99)と範囲を指定することも可能。この場合、``1~99``までのランダムな整数値を返す。
```rb
puts rand(100)
=> 56

puts rand(1..99)
=> 78
```

## even?/odd?
偶数・奇数の判定をしてくれる。
``evev``が偶数、``odd``が奇数。それぞれの判定があっていた場合、``true``が返却れる。
```rb
puts 1.odd?
=> true

puts 1.even?
=> false
```

## join
配列の要素を結合して一つの文字列としたい場合に``join``が使われる。
```rb
array = ["ABC", "DEF", "GHI"]
p array.join
=> ABCDEFGHI
```
``joinメソッド``に区切り文字を入れることもできる。
```rb
array = ["ABC", "DEF", "GHI"]
p array.join(',')
=> ABC,DEF,GHI
```

## split
文字列を分割して配列にするためのメソッド。
``splitメソッド``は第1引数に区切り文字を指定できるが、引数を指定しない場合は空白文字で区切られる。

空白文字として扱われるのは、``” “(半角スペース)``、``”\n”(改行コード)``、``”\t”(タブ)``など。

**デフォルト(何も指定せずに分割)**
```rb
str = "dog cat human"
p str.split
=> ["dog", "cat", "human"]
```
**区切り文字有り**
```rb
str = "dog,cat,human"
p str.split(",")
=> ["dog", "cat", "human"]

--------------------------------

str = "123456"
p str.split("34")
=> ["12", "56"]
```
**1文字ずつ分割**
```rb
str = "123456"
p str.split("")
=> ["1", "2", "3", "4", "5", "6"]
```

## map ・ collect / map!
``map``は、配列の要素の数だけブロック内の処理を繰り返し、結果として作成された配列を返す。
``map``は元の値に対して**影響を与えない**のに対し、``map!``は**元の値を書き換える**。また、Rubyには``collectメソッド``があるが、これは``mapメソッド``の別名。

**mapメソッドを使用した場合**
```rb
array = ["a", "b", "c"]
=> ["a", "b", "c"]

array.map {|s|  s.upcase }
=> ["A", "B", "C"]

p array
=> ["a", "b", "c"] # 元の値はそのまま
```
**map!メソッドを使用した場合**
```rb
array = ["a", "b", "c"]
=> ["a", "b", "c"]

array.map {|s|  s.upcase }
=> ["A", "B", "C"]

p array
=> ["A", "B", "C"] # 元の値が変更されてしまう
```


``mapメソッド``は、下記の３つの条件に合えば、ブロックを渡す代わりに``&:メソッド``を使って省略して書くことが出来る。

・ブロックの引数が１つであること
・ブロックで呼び出すメソッドに引数がないこと
・ブロック引数に対して、メソッドを呼び出すこと以外の処理がないこと
```rb
通常の書き方
["RUBY", "PHP", "JAVA"].map { |s| s.downcase }
=> ['ruby', 'php', 'java']

省略した書き方
["RUBY", "PHP", "JAVA"].map(&:downcase)
=> ["ruby", "php", "java"]
```

``mapメソッド``は、配列だけではなく``Hash``に対しても使用することができる。
ただし、返り値はハッシュではなく、配列になるので注意。返り値を配列ではなく``Hash``にする場合は、``to_hメソッド``を使用。
```rb
h = { BANANA: 100, ORANGE: 200, MELON: 300 }
=> {BANANA: 100, ORANGE: 200, MELON: 300}

h.map { |key, value| [key.downcase, value] }
=> [[:banana, 100], [:orange, 200], [:melon, 300]]

h.map { |key, value| [key.downcase, value] }.to_h
=> {banana: 100, orange: 200, melon: 300}
```

## concat
文字列や配列同士を結合するときに便利なメソッド。
``cancatメソッド``は破壊的メソッドであるため、メソッドを呼び出した変数は、文字列結合した内容に変数の値が書き換えられる。
```rb
str1 = "Hello "
str2 = "Ruby!"
str1.concat(str2)
p str1
=> Hello Ruby!

---------------------

str1 = "apple"
str2 = "orange"
str3 = "banana"
str1.concat(str2, str3)
p str1
=> appleorangebanana

---------------------

fruits1 = ["apple", "orange", "melon", "banana"]
fruits2 = ["pineapple", "strawberry"]
fruits1.concat(fruits2)
p fruits1
=> ["apple", "orange", "melon", "banana", "pineapple", "strawberry"]
```
## times
指定回数だけ繰り返し処理を行う。
```rb
3.times{
  p "Hello"
}

=> 
"Hello"
"Hello"
"Hello"
```
## upto
``uptoメソッド``を利用することで、``upto``のMAX値（下記例だと``7``）になるまで、数字を1づつ追加しながら、変数（コード例のnum）を表示する。
```rb
3.upto(7){|num|
    p num 
  }

=>
3
4
5
6
7
```

## downto
``uptoメソッド``の逆。
```rb
7.upto(3){|num|
    p num 
  }

=>
7
6
5
4
3
```

## each_with_index
要素とそのインデックス数をブロックに渡して繰り返す。
```rb
[5, 10, 15].each_with_index do |n, idx|
  p [n, idx]
end

 => [5, 0]
    [10, 1]
    [15, 2]
```
## each_cons
要素を重複ありで n 要素ずつに区切り、ブロックに渡して繰り返す。
```rb
(1..10).each_cons(3){|v| p v }

=>  [1, 2, 3]
    [2, 3, 4]
    [3, 4, 5]
    [4, 5, 6]
    [5, 6, 7]
    [6, 7, 8]
    [7, 8, 9]
    [8, 9, 10]
```

## abs
絶対値を返す。
```rb
-12345.abs    => 12345
12345.abs     => 12345
-1234567890987654321.abs    => 1234567890987654321
```
## select
各要素に対してブロックを評価した値が真であった要素を全て含む配列を返す。
```rb
[1,2,3,4,5].select
=> #<Enumerator: [1, 2, 3, 4, 5]:select>

[1,2,3,4,5].select { |num| num.even? }
=> [2, 4]
```

## reject
条件を反転させた``select``。除外する。
```rb
# 偶数を除外する (奇数を集める)
(1..6).reject {|i| i % 2 == 0 }  

=> [1, 3, 5]
```

## push
順番に配列の末尾に追加する。「<<」の記号を使うことでも末尾に要素を追加できる。
```rb
array = [1, 2, 3]
array.push 4
array.push [5, 6]
array.push 7, 8
p array          

=> [1, 2, 3, 4, [5, 6], 7, 8]

--------------------------------

a = [1, 2, 3]
a << 4
p a 

=> [1, 2, 3, 4]
```

## unshift
配列の先頭に追加する。``push``の逆。
```rb
arr = [1,2,3]
arr.unshift 0
p arr             => [0, 1, 2, 3]

arr.unshift [0]
p arr             => [[0], 0, 1, 2, 3]

arr.unshift 1, 2
p arr             => [1, 2, [0], 0, 1, 2, 3]
```

## sort
配列の内容を並び替える。要素同士の比較は``<=>``演算子を使って行う。
```rb
ary1 = [ "d", "a", "e", "c", "b" ]
p ary1.sort
=> ["a", "b", "c", "d", "e"]

#reverseつけると逆順になる
p ary1.sort.reverse
=> ["e", "d", "c", "b", "a"]

ary2 = ["9", "7", "10", "11", "8"]
p ary2.sort
=> ["10", "11", "7", "8", "9"] (文字列としてソートするとこうなる)

p ary2.sort{|a, b| a.to_i <=> b.to_i }
=> ["7", "8", "9", "10", "11"] (ブロックを使って数字としてソート)

#aとbの位置を反対にすると降順になる
p ary2.sort{|a, b| b.to_i <=> a.to_i }
=> ["11", "10", "9", "8", "7"]

# sort_by を使っても良い
p ary2.sort_by{|x| x.to_i }
=> ["7", "8", "9", "10", "11"]
```


## 参考記事
[Ruby 3.1 リファレンスマニュアル](https://docs.ruby-lang.org/ja/latest/doc/index.html)
[Rubyでlengthを使う方法を現役エンジニアが解説【初心者向け】](https://techacademy.jp/magazine/28245)
[Rubyのjoinメソッドの使い方を現役エンジニアが解説【初心者向け】](https://techacademy.jp/magazine/19903)
[【Ruby入門】splitで文字列を分割しよう！](https://www.sejuku.net/blog/41681)
[【Ruby】 mapメソッドの基礎から応用の使い方まとめ](https://pikawaka.com/ruby/map)
[はじめてのRuby！concatメソッドで配列や文字列を結合する方法](https://www.sejuku.net/blog/69942)
[timesメソッド、uptoメソッド、downtoメソッド](https://www.javadrive.jp/ruby/for/index6.html)
[繰り返し処理が行える！Rubyでtimesを使う方法【初心者向け】](https://techacademy.jp/magazine/7570)