[初心者向け]Rubyメソッド集(不定期更新)*20年6月15日更新

Rubyの学習をする中で、学んだメソッドをまとめていきます。
*新しいメソッドを学習次第、追記・更新していきます。

#小数点以下数字に対する処理
##小数点以下切り捨て/floor
小数点以下を切り捨てる場合はfloorメソッドを使用します。

```:例
1.4.floor 
 #=>1
-1.4.floor
 #=> -2
```
##小数点以下切り上げ/ceil
小数点以下を切り上げる場合はceilメソッドを使用します。

```:例
1.4.ceil
 #=>2
-1.4.ceil
 #=> -1
```

##小数点以下四捨五入/round
小数点以下を四捨五入する場合はroundメソッドを使用します。
roundメソッドは引数に桁数を指定することができます。
また、整数部の四捨五入を行いたい場合は、引数に負数を指定します。

```:例
1.23456.round(2)
 #=> 1.23
123456.round(-2) 
 #=>123500
```

##整数同士の割り算について(分子より分母が大きい場合）/to_f
整数同士の割り算では、分子より分母が大きい場合に答えは0となります。
Rubyでは数値のオブジェクトに対してto_fメソッドが用意されているので、こちらを利用します。

```:例
90 / 100
 #=> 0
90 / 100.to_f
 #=>0.9
```



#文字列を分割/split
splitメソッドは、対象となる文字列を指定した区切り文字によって分割し、
それぞれを配列の要素として格納します。

```:例
#String型変数名.split("区切り文字", 分割後の要素数)
"Ruby, Rails, JavaScript".split”(",") #=>["Ruby", " Rails", " JavaScript"]
```

#先頭の小文字を大文字に変換/capitalize
capitalizeメソッドは、先頭の小文字を大文字に変換したい場合に使用するメソッドです。

```:例
#文字列.capitalize
rails.capitalize #=>"Rails"
```

#文字列を反転/reverse
reverseメソッドは、指定した文字列を反転して取得したい場合に使用するメソッドです。

```:例
#文字列.reverse
"abcde".reverse #=>"edcba"
```
#文字列を大文字(小文字)に変換/upcase,downcase
upcase/downcaseメソッドは、指定した文字列を大文字(小文字)に変換して取得する場合に使用します。

```:例
#文字列.upcase(downcase)
"Hello, world".upcase #=>"HELLO, WORLD"
"HELLO, WORLD".downcase #=>"hello world"
```

#配列(ハッシュ)関連
##ハッシュへ｛｝の代入
ハッシュに対して、キーと値を代入する方法は以下の通りです。
今回は例としてBMIを計算してみます。

```:例
#空のハッシュの定義
hash =[]

#hashのキー 「:name」 に"Suzuki"を代入する
hash[:name] = "Suzuki"

#hashのキー 「:height」 に1.6を代入する
hash[:height] =1.6

#hashのキー 「:weight」 に60を代入する
hash[:weight] =60

#hashのキー 「:bmi」 にBMIの結果を代入する
#BMIの計算方法は 体重(kg)　÷　身長(m) の二乗
hash[:bmi] = (hash[:weight] / hash[:height] ** 2).round(1)
```

##ハッシュのキー・値の取り出し
上記で入力した配列のキーと値を取り出してみます。

```:例
hash.each do |key, value|
puts "#{key}: #{value}"
end
#=>name: Suzuki
height: 1.6
weight: 60
bmi: 23.4
```

##配列の中の要素を数える
###配列の要素数を取得/sizeメソッド,lengthメソッド
配列の要素数を取得するにはsizeメソッド、lengthメソッドが使えます。
*配列だけでなく文字列などでも使用可能です。
*sizeメソッド、lengthメソッドで返される値は同じです。

```:例
nums = [1,2,2,3,3,3]
puts nums.size
puts nums.length
#=> 6
#=> 6
```

###配列の要素数を条件付きで取得/countメソッド
countの引数に指定した要素と一致する数をカウントします

```:例
nums = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]
puts nums.count(4)

#=> 4
```

##配列の要素をまとめて出力する/joinメソッド
配列の中身をまとめて出力するときはjoinメソッドが使えます。

```:例
nums = [1,2,2,3,3,3]
puts nums.join
#=> 122333

#要素間にスペースを入れる。
puts nums.join(" ")
#=> 1 2 2 3 3 3

#要素間にカンマを入れる
puts nums.join(",")
#=> 1,2,2,3,3,3
```

##配列の先頭に要素を追加/unshiftメソッド
指定された要素を引数の最後から順番に配列の先頭に挿入します。引数を指定しなければ何もしません。

```:例
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]
```

##複数の配列から要素を順番に出力する/zipメソッド+each do
zipメソッドは、自身と引数に渡した配列の各要素からなる配列の配列を生成して返します。
each doと併用することで、複数の配列から要素を順番に出力することができます。
*生成される配列の要素数は self の要素数と同じです。

```:例
#zipメソッド
p [1,2,3].zip([4,5,6], [7,8,9])
    # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

#要素の数が合わない場合は、双方にある要素分しか生成されません。
p [1,2].zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B]]

#each doと併用することで、各要素を出力できます。
array1=[1,2,3]
array2=[4,5,6]
array1.zip(array2) each do |a1,a2|
 puts a1 + a2
end
#=>5
#=>7
#=>9
```

##配列の要素を削除/deleteメソッド
配列の要素を削除する場合はdeleteメソッドを使用します。

```:例
#配列.delete(削除する要素)

array = [1, 2, 2, 3, 3, 3]
array.delete(2)
puts array 
#=> [1, 3, 3, 3]
```

##末尾の要素を取り除く/popメソッド
popメソッドは自身の末尾から要素を取り除いてそれを返します。
引数を指定した場合はその個数だけ取り除き、それを配列で返します。

```:例
#配列.pop()

array = [a, b, c, d]

puts array.pop 
#=> [a, b, c]

puts array.pop(2) 
#=> [a, c, d]
```

配列の要素を削除するメソッドは他にもございます。
似たようなメソッドは下記URLをご参照ください。

Rubyで配列の要素を削除する：delete, delete_at, shift, slice!
https://uxmilk.jp/24060


##nilを取り除く/compactメソッド
compact は自身から nil を取り除いた配列を生成して返します。

```:例
#配列.compact

ary = [1, nil, 2, nil, 3, nil]
p ary.compact   #=> [1, 2, 3]
```

また、compact!とした場合は自身から nil を取り除き、変更が行われた場合は self を、そうでなければ nil を返します。

```:例
#配列.compact！

ary = [1, nil, 2, nil, 3, nil]
p ary.compact   #=> [1, 2, 3]
p ary           #=> [1, nil, 2, nil, 3, nil]
ary.compact!
p ary           #=> [1, 2, 3]
#一度aryの中身が変更されているので、nilを取り除いたselfが返されてます。

p ary.compact!  #=> nil
#こちらは特に変更が無かったので、nilが返されてます。
```

##配列の要素を取得し、処理を行う/mapメソッド
mapメソッドは配列の各要素を取得し、順に処理を実行します。
このmapメソッドは戻り値を使って配列の中身に処理(変更)をしますが、
map!メソッドを使用すると、戻り値なしで、配列の中身に対して処理(変更)が行われます。
言葉で説明すると、いまいちわかりづらいので、以下の例をご確認ください。

```:例
#配列変数.map {|変数名| 具体的な処理 }

#戻り値なし
array = ["a", "b", "c"]
array.map {|item|  item.upcase }  
 #=> array = ["a", "b", "c"] 
 #これは配列からアイテムを取り出し、処理をしてますが、配列に戻されていないため、
　配列の中身に変更がございません。

#戻り値あり
array = ["a", "b", "c"] 
array= array.map {|item|  item.upcase }  
 #=> array = ["A", "B", "C"] 
 #これは配列からアイテムを取り出し、処理をした後、配列に戻されているので、
　配列の中身が変更されてます。
```

```:例
#配列変数.map! {|変数名| 具体的な処理 }

array = ["a", "b", "c"] 
array.map! {|item|  item.upcase }  
 #=> array = ["A", "B", "C"] 
 #map!を使用すれば戻り値を使用せずに変更を加えられます。
```

##配列の削除/delete, delete_at, delete_ifメソッド
###deleteメソッド
deleteメソッドは引数で与えた要素を探しだして削除を行います。

```:例
array = (1..5).to_a
p array
 #=>[1, 2, 3, 4, 5]
array.delete(3)
p array
 #=>[1, 2, 4, 5]

#すべての要素に対して操作を行うので一つだけ削除などは出来ないことに注意。
array = [1,2,2,3,3,3]
p array
　#=>[1, 2, 2, 3, 3, 3]
array.delete(3)
p array
 #=>[1, 2, 2]
```
###delete_atメソッド
delete_atメソッドは引数で与えられた位置の要素を削除します。
先ほどのdeleteメソッドでは全選択しかできませんでしたが、こちらは配列の順番を選択することで、特定要素のみを削除できます。

```:例
fruits = ["apple", "orange", "banana", "kiwi","banana"]
fruits.delete_at(2)
p fruits
　#=>fruits = ["apple", "orange", "kiwi","banana"]
#配列は0スタートなので、３番目のbananaが削除されてます。
```
###delete_ifメソッド
delete_ifメソッドはブロック文の中に削除する条件の記述を行い、その返り値が真を返す要素を削除します。

```:例
array = (1..10).to_a
p array
 #=>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#偶数の時にその数字を削除します。
array.delete_if{|n| n.even? }
p array
 #=>[1, 3, 5, 7, 9]
```

##配列を結合/joinメソッド
joinメソッドは配列を連結して一つの文字列にします。

```:例
array = ['ruby', 'python']
p array.join
　#=>rubypython

#連結時に区切り文字を指定できます。
array = ['ruby', 'python','java']
p array.join(',')
　=>"ruby, python, java"

#配列の中身が配列の時は以下のようになります。
array = [['ruby','rails'],['python','javascript']]
p array.join(',')
　#=>"ruby, rails, python, javascript"
```

##配列の要素に指定した要素が含まれているか確認/include?メソッド
配列の要素に指定した要素が含まれているか確認できます。

```:例
#配列の中に指定要素が含まれていれば"true"と表示させます。
nums = [1,2,3,4,5]
if nums.include?(4)
puts "true"
else
puts "false"
#=>true

#複数指定する場合は以下のように記載します。
#AかつBが含まれる
if nums.include?(4) && nums.include?(5)

#AまたはBが含まれる
if nums.include?(4) || nums.include?(5)
```

##配列要素における文字列の出力順番を変更する
メソッドではありませんが、配列要素における文字列の出力順番を変更する方法があります。
例えば、文字列における１、２文字目を抽出して、後ろに結合させてみます。

```：例
def left2(str)
  puts str[2..-1] + str[0..1]  
end

left2('Hello') 
 #=> 'lloHe'
left2('java') 
 #=>'vaja'
left2('Hi') 
 #=>'Hi'
```
##配列の中身を並び替える/sortメソッド

```：例
array = [4, 2, 5, 1, 3]
newarray = array.sort
puts newarray
 #=>[1,2,3,4,5]

#sort!とすることで、配列自身を変更できます。
array = [4, 2, 5, 1, 3]
puts array.sort!
#=>[1,2,3,4,5]
```

#文字列を数列に変換/数列を文字列に変換
Rubyのプログラムの中に直接記述できる値のことをリテラルと言います。
リテラルには文字列リテラル、数値リテラルなどがあり、リテラルを他のリテラルへ変換することができます。

##文字列を数列に変換/to_iメソッド
数列に変換するには、to_iメソッドを使用します。
to_iメソッドは文字列を整数へ変換しますが、その文字列が10進数とみなすことができなければ、数値0を返します。

```:例
word = "2000"
puts word.to_i
#=> 2000

word = "Love2000"
puts word.to_i
#=> 0

word = "2000Love"
puts word.to_i
#=> 2000

mse = "Love"
puts word.to_i
#=> 0
```
上記のように、整数がある場合には整数を表示し、整数で表すことができないため数値0（もしくは整数のみ）を返しています。

##数列を文字列に変換/to_sメソッド
数列を文字列に変換するには、to_sメソッドを使用します。
Rubyでは数字と文字列をそのまま+演算子でくっつけることができないので、数字と文字列をくっつけて表示したい時などに利用します。

```:例
word = 2000
puts word.to_s(2)
#=> "11111010000"

puts word.to_s(8)
#=> "3720"

puts word.to_s(10)
#=> "2000"
```
上記のように、to_sの後に数字を入れることで、どのような整数を返すか決めています。
２の場合は２進数、１０の場合は１０進数で返します。＊１０進数の場合は、（10)の記載はなくてもOKです。
ちなみに足し算の場合は、以下のようになります。

```
def addition(a,b)
  puts a.to_s + b.to_s
end

addition("hello","world")
#=>"helloworld"

addition("hello",1)
#=>"hello1"

addition("hello",1.1)
#=>"hello1.1"

addition(100,1.1)
#=>"1001.1"
```


#引数
##引数のデフォルト値
通常、引数は呼び出し側とメソッド定義側で数が一致している必要がありますが、メソッド定義側では引数にデフォルト値を設定することが可能です。
メソッドを呼び出した時に指定した引数は、メソッド側で先頭から順に代入されていきます。
この時、代入するオブジェクトが無かった場合(呼び出し側で指定した引数の数が、メソッド定義側で指定した引数よりも少なかった場合)、デフォルト値が設定されていればその値が代わりに代入されます。

```:例
def putsHello(msg="No msg", name="No name")
  puts (msg + "," + name)
end

putsHello("hello","test")
 #=>hello,test
putsHello("hello")
 #=>hello,No name
putsHello()
 #=>No msg,No name
```

##可変長引数
可変長引数:
個数に制限を設けていない引数のことで、その引数は配列として認識されることとなります。
配列ですから、いくつあっても良いってことになります。
可変長引数の使い方は引数の前に＊をつけるだけです。
＊のついた引数は可変長引数として制限がなく配列として認識します。

```:例
class Member
  def attend(*numbers)
    puts "今日の参加者は#{numbers.join(",")}です。"
  end
end

member = Member.new
member.attend("Aさん","Bさん","Cさん")
 =>今日の参加者はAさん,Bさん,Cさんです

```

##キーワード引数
Rubyにおいて、引数は同じ位置にある仮引数(メソッドに書かれている仮の引数)と同じ位置に、実引数(実際に引数を使ってメソッドを使う場合の引数)によってメソッドが実行されることとなります。
通常は仮引数のままメソッドを実行することも多いのですが、実際、そのメソッドを実引数で使い場合など、位置を間違えたりすることが多いのも現状です。
そういったミスを回避し、また作業効率や保守においてもできるだけ勘違いなどによる無駄を省き、わかりやすい引数を設定するために設けられたのが”キーワード引数”となります。

キーワード引数はメソッドに引数を実装する際に、引数を”キー: 値”という形で設定します。
この時、値に何もいれておかないと、メソッドを実行する際に、実引数で実際の値をいれないとArgumentErrorとなります。

```:例
#使い方
def (key1: value1, key2: value2)
end

def apple(color: "red", price: 200)
  p "#{color}, #{price}"
 end

apple()
 #=>"red, 200"
 #上記にてデフォルト値が設定されているので、そのデフォルト値が出力されます。

apple(color: "green", price: 250)
 #=> "green, 250"
 #入力された引数が出力されます。

apple(price: 250,color: "green")
  #=> "green, 250"
  #キーワード値が与えられているので、順番にかかわらず入力された引数が出力されます。
```
  
#繰り返し表示させる/timesメソッド
繰り返し同じことを表示させる時はtimesメソッドを使用します。
こちらは以下のように使用します。

```:例
#繰り返し回数.times do
end

#ユーザに繰り返し入力させる回数をインプットしてもらう形では以下のように変数を使用します。
def hello(num)
  num.times do
    puts "Hello"
　end
end

puts "繰り返し表示する回数を入力してください"
num = gets.to_i
hello(num)
 #=>3
 #=>Hello
 #=>Hello
 #=>Hello
```

#文字を数値に変換・数値を文字に変換/ordメソッド・chrメソッド
ordメソッドとは文字をその文字のコードポイントへ変換するメソッドです。
逆にchrメソッドとはコードポイントを文字に変換するメソッドです。
*コードポイント:文字に割り当てられた整数の値

以下の具体例をご確認ください。

```:例
puts 'A'.ord 
 #=>65
puts 'A'.ord + 1
 #=>66
puts ('A'.ord + 1).chr
 #=>B
```

#通貨の定義方法＊千の位で区切る/number_to_currency,delimitedメソッド
##number_to_currency

```haml：例
#precision:小数点
 = number_to_currency(123456789, precision:5) 
 #=>$123,456,789.00000

#unit:通貨
 = number_to_currency(123456789, unit:"￥") 
 #=>¥123,456,789

#format:フォーマット設定
#「%u」はunitの略、また「%n」はnumberの略で今回はunitを後ろに表示しています。
 = number_to_currency(123456789, format:"%n%u", unit: "円")
 #=>123,456,789円
```

##delimitedメソッド

```haml：例
"#{10000(:delimited, delimiter: ',')}円"
 #=>10,000円
```

#例外処理が行われた際に再度ループを実行する/rescue
rescueとは、発生した例外を捕捉し、例外が起こった際に呼び出される条件節です。
例外が発生しそうな部分をbeginから始まるブロックで囲み、ブロックの内部にrescueを記述して使用します。
通常、each, times, whileなどの繰り返しの最中に例外が発生した場合、繰り返し処理は途中で中止され、次のループが実行されることはありません。
ただし、繰り返し処理の内部にrescueを記述していた場合、例外が発生したとしても、次のループに移ることができます。
大量のレコードを扱う処理で、例外が発生しても繰り返しを続行したい場合には、rescueを使うようにしましょう。

```:例
begin
# 数字を0で割ろうとすると、ZeroDivisionError例外が発生する
  1 / 0
rescue
# 例外が発生した時にrescue以下の処理が呼ばれる
  puts '0で割ることはできません'
end
```

#指定箇所を抽出する・指定箇所を削除する/slice・slice!
sliceメソッドは指定した範囲の文字列を抽出することができます。

```:例
str = "Liverpool"
 
puts str.slice(2)
 #=>v

puts str.slice(1..4)
 #=>iver
```

slice!メソッドは文字列から取り除いたうえで取り除いた部分文字列を返します。
返り値は同じですが、Slice!は指定範囲が取り除かれます。

```:例
str = "Liverpool"
 
puts str.slice!(2)
 #=>v

puts str.slice!(1..4)
 #=>iver
```

また何か見つけたら、追記していきます。

以上となります。最後までご覧いただき、ありがとうございました！
今後も学習した事項に関してQiitaに投稿していきますので、よろしくお願いします！
記述に何か誤りなどございましたら、お手数ですが、ご連絡いただけますと幸いです。



#参照
【Java入門】文字列を分割するsplitメソッドの使い方(List化も解説)
https://www.sejuku.net/blog/14487

はじめてのRuby！文字列を大文字⇔小文字に変換する方法まとめ
https://www.sejuku.net/blog/60402

Rubyで文字列を数値へ変換する方法を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/19839

Rubyのto_sメソッドの使い方を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/22202

Rubyのdeleteメソッドの使い方を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/21219

引数のデフォルト値
https://www.javadrive.jp/ruby/method/index4.html

Rubyにおける可変長引数の使い方を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/19841

Rubyのキーワード引数の使い方を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/19791

Rubyの文字列で使えるメソッド・使い方総まとめ
https://www.sejuku.net/blog/11843

Rubyのordメソッドの使い方を現役エンジニアが解説【初心者向け】
https://techacademy.jp/magazine/20142

Rails - 通貨フォーマットの扱い
https://qiita.com/azusanakano/items/c2e73521d5a4bdfa73d6