【Ruby】基本コマンド一覧

#【Ruby】基本コマンド一覧
Rubyの基本コマンドの一覧と実例。



##目次
1. [puts, print, pの違い](#puts-print-pの違い)
2. [定数](#定数)
3. [オブジェクトのクラス一覧表示（.class）](#オブジェクトのクラス一覧表示class)
4. [オブジェクトのメソッド一覧表示（.methods）](#オブジェクトのメソッド一覧表示methods)
5. [小数点以下の計算](#小数点以下の計算)
6. [小数点の表示桁数指定](#小数点の表示桁数指定)
    7. [format（または sprintf）](#formatまたは-sprintf)
    8. [round, ceil, floorメソッド](#round-ceil-floorメソッド)
9. [文字列](#文字列)
    10. [式展開](#式展開)
    11. [連結](#連結)
    12. [繰り返し](#文字列の繰り返し)
    13. [文字数カウント（.length）](#文字数カウントlength)
    14. [文字列から数値に変換（.to_i）](#文字列から数値に変換to_i)
10. [配列](#配列)
    11. [配列の要素取得](#配列の要素取得)
    12. [要素追加（push or <<）](#要素追加push-or-)
    13. [配列の長さ取得（size, length, count）](#配列の長さ取得size-length-count)
    14. [ソート](#ソート)
11. [ハッシュオブジェクト](#ハッシュオブジェクト)
    12. [作成と呼び出し](#作成と呼び出し)
    13. [要素追加](#要素追加)
    14. [要素削除（.delete(:キー名)）](#要素削除deleteキー名)
12. [条件分岐](#条件分岐)
    13. [if](#if)
    14. [case,when](#casewhen)
13. [繰り返し](#繰り返し)
    14. [for in](#for-in)
    15. [each do](#each-do)
    16. [while](#while)
    17. [times do](#times-do)
    18. [loop + break](#loop--break)
    19. [スキップ（if next）](#スキップif-next)
14. [メソッドの作成と呼び出し](#メソッドの作成と呼び出し)
15. [クラスの作成とインスタンスの生成](#クラスの作成とインスタンスの生成)





<br>
##puts, print, pの違い
それぞれに微妙な違いはあるものの、putsついで、pだけ覚えておけばいい。

それぞれの差は、改行の有無や型表現の有無。

| メソッド | puts | p | print |
|:-:|:-:|:-:|:-:|
| 用途  | 本番用  | デバッグ用  | pythonの名残？  |
| 改行  | あり  | あり  | なし  |
| 型表現  | なし  | あり  | なし |


```ruby:putsとprintの違い（改行の有無）
puts "こんにちは"
puts 123

#こんにちは
#123


print "こんにちは"
print 123

#こんにちは123
```


<br>
▼「p」の場合、文字列のテキストにダブルクオテーションがつく

```ruby:putsとpの違い（型表現の有無）
puts "こんにちは"
puts 123

#こんにちは
#123


p "こんにちは"
p 123

#"こんにちは"
#123
```



<br>
##定数
・変数を大文字で定義
・単語を複数つなげる場合はアンスコを使用
・上書きしたり、再定義するとエラーが出る

```ruby
TAX_RATE = 1.0
puts TAX_RATE

#上書き指示
TAX_RATE = 1.5

#warning: already initialized constant TAX_RATE
#warning: previous definition of TAX_RATE was here
```



<br>
##オブジェクトのクラス一覧表示（.class）
`p オブジェクト.class`


```ruby
p 1.1.class

#Float
```




<br>
##オブジェクトのメソッド一覧表示（.methods）
`p オブジェクト.methods`


```ruby
p 1.1.methods

#[:-@, :**, :<=>, :<=, :>=, :==, :===, :eql?, :%, :inspect, :*, :+, :-, :/, :<, :>, :to_int, :coerce, :to_s, :divmod, :to_i, :to_f, :to_r, :fdiv, :modulo, :abs, :magnitude, :zero?, :finite?, :infinite?, :floor, :ceil, :round, :truncate, :positive?, :negative?, :numerator, :denominator, :rationalize, :arg, 以下省略...
```


```ruby
p "abc".methods

#[:encode, :encode!, :unpack, :unpack1, :include?, :%, :*, :+, :count, :partition, :to_c, :sum, :next, :casecmp, :casecmp?, :insert, :bytesize, :match, :match?, :succ!, :<=>, :next!, :upto, 以下省略...
```




<br>
##小数点以下の計算
計算する整数に「.0」をつけると小数点まで表示する。
　┗ どちらか一方
　┗ 桁数を指定するものではない
　┗ ない場合は切り捨て

```ruby
p 8.0 / 3
p 8/3.0
p 8/3

#2.6666666666666665
#2.6666666666666665
#2
```


<br>
##round, ceil, floorメソッド
`.round`：四捨五入
`.ceil`：切り上げ
`.floor`：切り捨て

```ruby
p 8.0/7
p (8.0/7).round
p (8.0/7).ceil
p (8.0/7).floor

#1.1428571428571428
#1   round
#2   ceil
#1   floor
```



<br>
##小数点の表示桁数指定
###format（または sprintf）
`format("%.桁数f", 対象数値)`

```ruby
calc = 8/3.0

puts format("%.2f", calc)
puts sprintf("%.2f", calc)

#2.67
#2.67
```


###round, ceil, floorメソッド
`オブジェクト.round(桁数)`
`オブジェクト.ceil(桁数)`
`オブジェクト.floor(桁数)`


```ruby
puts calc.round(2)
puts calc.round(3)

#2.67
#2.667


puts calc.ceil(2)
puts calc.ceil(3)

#2.67
#2.667


puts calc.floor(2)
puts calc.floor(3)

#2.66
#2.666
```




<br>
##文字列

###式展開
`puts "#{数式や変数}"`
　┗ ダブルクオテーション
　┗ シングルだとそのまま出力

```ruby
puts "tax #{1000 * 0.10}"
#tax 100.0

puts 'tax #{1000 * 0.10}'
#tax #{1000 * 0.10}
```




<br>
###連結
`puts 文字列 + 文字列`

```ruby
puts "Hello" + "World"

#HelloWorld
```


<br>
###文字列の繰り返し
`puts 文字列 * n `

```ruby
puts "Hello★" * 5

#Hello★Hello★Hello★Hello★Hello★
```



<br>
###文字数カウント（.length）
`puts 文字列.length `

```ruby
str = "hello world"
p str.length

#11
```


<br>
###文字列から数値に変換（.to_i）
`puts 文字列.to_i `

```ruby
str = "123"

p str
p str.to_i

#"123"
#123
```



<br>
##配列
###配列の要素取得
`変数 = [ , , , ]`

```ruby
colors = ["red", "blue", "white"]

p colors[0]
p colors[3] #nil
p colors

#"red"
#nil
#["red", "blue", "white"]
```


<br>
###要素追加（push or <<）
・`オブジェクト.push(追加要素)`
・`オブジェクト << (追加要素)`

```ruby
colors = ["red", "blue", "white"]

p colors.push("green")
#["red", "blue", "white", "green"]

p colors << ("black")
#["red", "blue", "white", "green", "black"]
```



<br>
###配列の長さ取得（size, length, count）
・`オブジェクト.size`
・`オブジェクト.length`
・`オブジェクト.count`


```ruby
colors = ["red", "blue", "white", "green", "black"]

p colors.length
p colors.size
p colors.count

#5
#5
#5
```



<br>
###ソート
・`オブジェクト.sort`
・`オブジェクト.sort.reverse`


```ruby
colors = ["red", "blue", "white", "green", "black"]

p colors.sort
p colors.sort.reverse

#["black", "blue", "green", "red", "white"]
#["white", "red", "green", "blue", "black"]
```


```ruby
numbers = [5, 8, 1, 4, 9]

p numbers.sort
p numbers.sort.reverse

#[1, 4, 5, 8, 9]
#[9, 8, 5, 4, 1]
```





<br>
##ハッシュオブジェクト
###作成と呼び出し
書き方は３種類あるが、省略形のみ覚えておけばいい。

**作成**
`変数 = {キー:値, キー:値,,,}`

**呼び出し**
`変数[:キー名]`


```ruby
scores = {tanaka:100, sato:80, ito:50}

p scores
p scores[:sato]

#{:tanaka=>100, :sato=>80, :ito=>50}
#80
```


<br>
▼他の記述方法

```ruby:以下どれも同じ
score1 = {"tanaka" => 100, "sato"=>80, "ito"=>50 }
score2 = {:tanaka =>100, :sato=>80, :ito=>50}
score3 = {tanaka:100, sato:80, ito:50}

p score1
p score2
p score3

#{:tanaka=>100, :sato=>80, :ito=>50}
#{:tanaka=>100, :sato=>80, :ito=>50}
#{:tanaka=>100, :sato=>80, :ito=>50}
```


<br>
###要素追加
`変数[:キー名] = 値`

```ruby
scores = {tanaka:100, sato:80, ito:50}

scores[:suzuki] = 40
p scores
 
#{:tanaka=>100, :sato=>80, :ito=>50, :suzuki=>40}
```




<br>
###要素削除（.delete(:キー名)）
`変数.delete(:キー名)`

```ruby
scores = {tanaka:100, sato:80, ito:50, suzuki:40}

scores.delete(:suzuki)
p scores
 
#{:tanaka=>100, :sato=>80, :ito=>50}
```



<br>
##条件分岐

###if
**条件式**で処理を分岐する。
`if, elsif, else, end`

```ruby:
stock = 5  #在庫

if i >= 10
    puts '在庫：◎'
elsif i > 3
    puts '在庫：△'
elsif i == 1
    puts '在庫：ラスト１個'
else 
    puts '在庫：×'
end

#在庫：△
```


<br>
###case,when
**値**で条件式を分岐する。
`case, when, else, end`

```ruby:case構文の構造
# case 評価したい変数
#     when 数値
#         処理    
#     when 範囲（開始値..終値）
#         処理
#     when 範囲（開始値..終値）
#         処理
#     else
#         処理
# end
```


<br>
**▼実例**

```ruby:
age = 6

case age 
    when 0..5
        puts 800
    when 6..11
        puts 1800
    else 
        puts 2500
end 

#1800
```

・`開始値 .. 終値`
　┗ 開始値〜終値までの範囲





<br>
##繰り返し
###for in
`for 変数 in 範囲`

```ruby:配列
x = ["A", 1, "b", 3]

for i in x
    puts i
end

#A
#1
#b
#3
```


```ruby:連続した数値
for i in 0..3
    puts i
end

#0
#1
#2
#3
```



<br>
###each do
eschメソッドによる繰り返し。
`オブジェクト.each do |変数| 処理 end`

```ruby:
arrays = ["A", 1, "b", 3]

arrays.each do |array|
    puts array
end

#A
#1
#b
#3
```



<br>
###while
条件範囲内での繰り返し。
`while 条件式 処理 end`

```ruby:
i = 0

while i < 3
    puts i
    i += 1
    # i++は使えない
end

#0
#1
#2
```


<br>
###times do
繰り返し回数の指定。
`数値.times do |変数|`
　┗ 変数にインデックス番号が入る（０始まり）


```ruby:
3.times do |i|
    puts "#{i}回目の処理です"
end


#0回目の処理です
#1回目の処理です
#2回目の処理です
```



<br>
###loop + break
無限ループと終了条件の組み合わせによる繰り返し。
`loop{処理 if 条件 break end}`
　┗ 終了条件(break)がないとエラーになる


```ruby
i = 0 

loop{
    puts i
    i += 1
    
    if  i >=3
        break
    end
}

#0
#1
#2
#3
```


<br>
###スキップ（if next）
指定条件のみスキップする。
`if 条件式 next end`
　┗ 繰り返し処理の中で使用する。


```ruby:
3.times do |i|
    if i == 1 
        next
    end

    puts "#{i}回目の処理です"
end

#0回目の処理です
#2回目の処理です
```




<br>
##メソッドの作成と呼び出し

▼作成
`def メソッド名() 処理 end`
　┗ 引数なしの場合は()不要。


▼呼び出し
`メソッド名()`


```ruby:
def hello(name)
    puts "Hello #{name}さん"
end

hello("Yuta")

#Hello Yutaさん
```


<br>
▼事例２

```ruby:複数個の引数
def ttl_price(price, n)
    return (price * n * 1.10).floor  #returnは省略可能
end

puts ttl_price(500, 3)

#1650
```




<br>
##クラスの作成とインスタンスの生成
###クラスの作成

`class クラス名 end`

- クラス名は頭文字大文字。
- initializeメソッド：インスタンス作成時に自動で呼び出されるメソッド。
- プロパティは@で定義。


```ruby:クラスの作成
class User
    def initialize(name)
        @name = name
    end

    def say_name
        puts "私は#{@name}です。"
    end

end
```


<br>
##インスタンスの生成

`変数 = クラス名.new(引数)`


```ruby:インスタンスの生成
tanaka = User.new("tanaka")
tanaka.say_name

#私はtanakaです。


yamada = User.new("yamada")
yamada.say_name

#私はyamadaです。
```

<br>
以上。