Rubyの基本

# ◆標準入出力
## 標準入力
「gets」による入力値の取得。
### 文字列の取り扱い

#### .chomp

取得した文字列のお尻につく「改行コード」を削除することが可能。


```input_test01.rb
input = gets.chomp
puts "入力した値は「#{input} 」です。"
```

実行結果→
% ruby input_test01.rb
hello　　（コンソールで「hello」を入力し、エンターキー）
入力した値は「hello」です。

#### .split

複数の値を配列として取得することが可能。

```input_test02.rb
input = gets.split.chomp
p input
```


実行結果→
% ruby input_test02.rb
ruby on rails　　（コンソールで入力し、エンターキー）
["ruby","on","rails"]




### 数値の取り扱い

#### .to_i

取得した値を数値として取得する。

```input_test20.rb
number = gets.to_i
puts 2 + number
```

実行結果→
% ruby input_test20.rb
3　　（コンソールで入力し、エンターキー）
5


#### .map
取得した複数の値を数値の配列として取得する。

```input_test21.rb
numbers = gets.split.map(&:to_i)
p numbers
```

実行結果→
% ruby input_test21.rb
1 3 5　　（コンソールで入力し、エンターキー）
[1, 3, 5]





## 標準出力

「puts」による出力命令。

```
puts "Hello World!"
puts 'Hello World?'
hello = "Hello World?!"
puts hello
```
実行結果→
Hello World!
Hello World?
Hello World?!

※文字列はダブルクォーテーションまたはシングルクォーテーションで囲む。



# ◆条件分岐

## if/ else, elsif

```
score = 82
if score > 90
  puts "すごいね！"
elsif score > 80
  puts "がんばったね！"
elsif score > 60
  puts "合格点！"
else
  puts "がんばりましょう"
end
```
実行結果→ がんばったね！

## case

```
score = 70
case score
when 100
  puts "完璧！"
when 91..99
  puts "すごいね！"
when 81..90
  puts "がんばったね！"
when 61..80
  puts "合格点！"
else
  puts "がんばりましょう"
end
```
実行結果→ 合格点！


# ◆数値の編集など

## 四捨五入・切り捨て、小数点

### .round
四捨五入にはroundを使用します。

```
num = 1.23456
puts num.round
puts num.round(3)

num = 123456
puts num.round(-3)
```

実行結果→
1
1.235
123000


### .floor
切り捨てにはfloorを使用します。

```
num = 1.23456
puts num.floor
```

実行結果→
1


※floorメソッドで小数点以下の桁数指定を行うためには、数値をBigDecimalに変換し、floorメソッドで指定する必要あり。
※BigDecimalのオブジェクトを生成する際は一度Stringに変換（to_s）し、最終的にFloatに変換（to_f）する必要があり。

```
require 'bigdecimal'

num = 1.23456
puts BigDecimal(num.to_s).floor(2).to_f
```

実行結果→
1.23





## 偶数か奇数か

### .odd?

```
puts 0.odd?
puts 1.odd?
puts 2.odd?
puts 3.odd?
```

実行結果→
false
true
false
true


### .even?
```
puts 0.even?
puts 1.even?
puts 2.even?
puts 3.even?
```

実行結果→
true
false
true
false

### format

```
puts format('%04d',12)
puts '%04d' % 34
```
実行結果→
0012
0034



# ◆文字列の編集など

## 置換
### .sub
対象文字を一度（最初に一致した文字）だけ置換する。

```
s = "AABBCC"
puts s
puts s.sub(/C/, 'A')
```

実行結果→
AABBCC
AABBAC


### .gsub
対象文字を全て置換する。

```
s = "AABBCC"
puts s
puts s.gsub(/C/, 'A')
```

実行結果→
AABBCC
AABBAA

※第一引数には正規表現を記載する。（この部分は別途学習が必要）

## 抽出
### .slice
文字列から任意の範囲抽出する。

```
s = "abcdef"
puts s.slice(3)
puts s.slice(0..3)

array = ["AA","BB","CC"]
puts array.slice(0)
```

実行結果→
d
abcd
AA


## 大文字/小文字
### .upcase/ .downcase
文字列を大文字/小文字化する。

```
s = "abcdef"
puts s.upcase
s = "ABCDEF"
puts s.downcase
```

実行結果→
ABCDEF
abcdef


## 値の取得
### .abs
絶対値を取得する。

```
a = -3
b = 6
puts a.abs
puts b.abs
```

実行結果→
3
6

### .count
文字列の中から条件に一致する文字数を取得する。

```
text = "ruby on rails"
puts text.count("r")
```

実行結果→
2


# ◆繰り返し
## for

```
names = ["Ichiro", "Jiro", "Saburo"]
for n in 0..2 do
  puts "名前は#{names[n]}です"
end
```
実行結果→
名前はIchiroです
名前はJiroです
名前はSaburoです


## .each

```
names = ["Ichiro", "Jiro", "Saburo"]
names.each do |name|
  puts "名前は#{name}です"
end
```
実行結果→　
名前はIchiroです
名前はJiroです
名前はSaburoです

## .times

```
3.times do |n|
  puts n
end
```
実行結果→
0
1
2

## .upto / .downto

```
3.upto(5) do |n|
  puts n
end
```

実行結果→
3
4
5
※```オブジェクト.downto(min) ```とすることで１ずつマイナスカウントして繰り返すことも可能。

# ◆配列
## ソート
### .sort

```
num = [1,5,3,2,4]
p num.sort
```
実行結果→
[1, 2, 3, 4, 5]

### .reverse

```
num = [1,5,3,2,4]
p num.sort.reverse
```
実行結果→
[5, 4, 3, 2, 1]


## 和の取得
### .sum

```
num = [1,2,3,4,5]
puts num.sum
```
実行結果→15


### .inject

```
num = [1,2,3,4,5]
p num.inject(:+) #配列の要素の和
p num.inject(100,:+) #初期値100に配列の要素の和を足す
```
実行結果→
15
115
※inject の引数部分は他にも記載方法があるので、要確認。


# ◆ハッシュ
複数の値を管理する際、ハッシュとして管理する。
ハッシュの場合、それぞれの値に「キー」と呼ばれる名前を付けて管理する。

```
# 配列
[値１, 値2]
# ハッシュ
{キー1 => 値１, キー2 => 値2}
```

### ハッシュの使い方
```
# 変数への格納
user = {"name" => "Taro", "age" => 23}
# 項目の追加
user["gender"] = "male"

# 出力①
puts user
# 出力②
puts user["name"]

# 値の更新
user["age"] = 25
# 出力③
puts user["age"]
```

実行結果①→　{"name" => "Taro", "age" => 23, "gender" => "male"}
実行結果②→　Taro
実行結果③→　25

### シンボル
文字を「"」や「'」で囲む代わりに、先頭に「:」をつけた書き方をシンボルと呼ぶ。

```
{"name" => "Taro", "age" => 23}
{:name => "Taro", :age => 23}   # シンボルを用いた記述
```

ハッシュのキーにシンボルを用いる場合、省略した記述が可能。


```
# 「:key =>」→「key:」に省略可能
{:name => "Taro", :age => 23}
{name: "Taro", age: 23}   # 省略形
```

省略の有無にかかわらず、出力はシンボルを用いた記述が可能。

```
user = {name: "Taro", age: 23}
puts user[:name]
```
実行結果→　Taro


# ◆メソッド
### メソッドの定義、呼び出し

```
# メソッドの定義
def メソッド名
  処理内容
end

# メソッドの呼び出し
メソッド名
```

### 引数
メソッドに対して引数（値）を与える。
引数が複数ある場合は、カンマ区切りで記載する。

```
# メソッドの定義
def メソッド名(引数)
  処理内容
end

# メソッドの呼び出し
メソッド名(値)
```

### ※キーワード引数
引数の数が多くなると、何の値なのかがわからなくなることを避けるために「キーワード引数」という記載方法がある。

```
def introduce(name:, age:, gender:)
  puts "私の名前は#{name}。#{age}歳で、性別は#{gender}。"
end

# 実行：引数名を明記した書き方
introduce(name: "Taro", age: 23, gender: male)
```
実行結果→　私の名前はTaro。23歳で、性別はmale。

### 戻り値
```
# メソッドの定義
def メソッド名
  return 値
end

# メソッドの呼び出しによりkekka変数に戻り値が格納される
kekka = メソッド名
```
### ※その他の戻り値
条件式を戻り値にすると、真偽値（true/false）を返す。
真偽値を返すメソッドは、メソッド名の末尾に「?」をつける慣習がある。

```
def overfive?(number)
  return number > 5
end

puts overfive?(3)
```
実行結果→　false



# ◆クラス

設計図（＝クラス）を元に、もの（＝インスタンス）を作成するという考え方。

### クラスの定義

```
class User
  ・・・
end
```
※クラス名の先頭は大文字。



### インスタンス変数

```
class User
  attr_accessor :name
  attr_accessor :age
end
```
「attr_accessor シンボル」とすることで、クラスに情報（インスタンス変数）を持たせることができる。

### インスタンスの生成

```
user1 = User.new
```
「クラス名.new」とすることでインスタンスを生成することができる。


### ※インスタンス変数の利用

```
class User
  attr_accessor :name
end

user1 = User.new
# 値を代入
user1.name = "Taro"
# インスタンス変数を利用した出力
puts user1.name
```
実行結果→ Taro

### インスタンスメソッド
クラスの中でメソッドを定義することができ、「インスタンス.メソッド名」とすることで呼び出しが可能。

```
class User
  attr_accessor :name

  def hello
    puts "こんにちは！"
  end
end

user1 = User.new
# インスタンスメソッドの呼び出し
user1.hello
```
実行結果→ こんにちは！

### ※インスタンスメソッドの中でインスタンス変数を使う
「self.変数名」とすることでインスタンス変数を使用する。

```
class User
  attr_accessor :name

  def hello
    puts "こんにちは！#{self.name}です！"
  end
end

user1 = User.new
user1.name = "Taro"
user1.hello
```
実行結果→ こんにちは！Taroです！


### initializeメソッド
インスタンス生成直後に実行される「initializeメソッド」

```
class User
  ・・・
  def initialize
    puts "ユーザーを作成しました"
  end
end

user1 = User.new
```
実行結果→ ユーザーを作成しました

### ※initializeメソッドに引数を渡す①

```
class User
  ・・・
  def initialize(message)
    puts message
  end
end

user1 = User.new("こんにちは！")
```
実行結果→ こんにちは！

### ※initializeメソッドに引数を渡す②

```
class User
  attr_accessor :name
  attr_accessor :age

  def initialize(name:, age:)
    # 引数をインスタンス変数に代入＆使用
    self.name = name
    self.age = age
    puts "こんにちは！#{name}、#{age}歳です。"
  end
end

# キーワード引数により見やすく記載
user1 = User.new(name: "Taro", age: 23)
```
実行結果→ こんにちは！Taro、23歳です。

### ファイルの分割（require）
Userクラスの定義をuser.rb で管理した場合、index.rb の先頭行に「require "./user"」を記載することでuser.rb のコードを読み込むことが可能となる。

```user.rb
class User
  ・・・
end
```

```index.rb
require "./user"

user1 = User.new
```




# ◆継承
### 継承とインスタンス変数の追加
 - Programmerクラス （プログラマ｜使用する言語language の情報も保有したい）
 - Managerクラス （経営者｜経営する会社company の情報も保有したい）

これらのクラスを作成したいとき、既存のUserクラスを「継承」することによって効率的にコードを書くことができる。「class 子クラス名 < 親クラス名」と記述する。
※新たに作成するクラスを「子クラス」、継承元のクラスを「親クラス」という。
ここでは、新クラス内でのインスタンス変数追加も併せて提示。

```user.rb
class User
  attr_accessor :name
  attr_accessor :age
end
```
```programmer.rb
# User クラスを継承したProgrammer クラスを定義
class Programmer < User
  # インスタンス変数language を追加（name, age, language を保有）
  attr_accessor :language
end
```
```manager.rb
# User クラスを継承したManager クラスを定義
class Manager < User
  # インスタンス変数company を追加（name, age, company を保有）
  attr_accessor : company
end
```
（インスタンス変数同様、インスタンスメソッドについても追加が可能）



### オーバーライド
親クラスにあるメソッドと同じ名前のメソッドを子クラスで定義することで、メソッドを上書きすることが可能。（＝メソッドの「オーバーライド」）
オーバーライドした場合、子クラスのメソッドが実行（優先）される。

```user.rb
class User
  def hello
    puts ""
  end
end
```
```programmer.rb
class Programmer < User
  # helloメソッドをオーバーライド
  def hello
    puts "こんばんは！"
  end
end
```
```index.rb
require "./user"

programmer1 = Programmer.new
programmer1.hello
```
実行結果→ こんばんは！


# ※オーバーライド（super）
オーバーライドしたメソッドの中で「super」を使うと、親クラスの同名のメソッドを呼び出すことが可能。

```user.rb
class User
  attr_accessor :name
  attr_accessor :age

  def initialize(name:, age:)
    self.name = name
    self.age = age
  end
end
```
```programmer_01.rb
class Programmer < User
  attr_accessor :language

  def initialize(name:, age:, language:)
    self.name = name   # この部分を修正
    self.age = age   # この部分を修正
    self.language = language
  end
end
```
「super」を利用することにより、programmer_01.rb の一部を修正可能。

```programmer_02.rb
class Programmer < User
  attr_accessor :language

  def initialize(name:, age:, language:)
    super(name: name, age: age)   # 修正後
    self.language = language
  end
end
```




# ◆Dateクラス
日付を扱うためには、Dateクラスを使う。

```
require "date"
# 引数に年月日を渡してインスタンスを作成
date1 = Date.new(2018,12,12)

# 出力
puts = date1
# Dateクラスのインスタンスメソッド「sunday?」を使って真偽値を出力（日曜日かどうか）
puts = date1.sunday?
```
実行結果→ 2018-12-12
実行結果→ false

### ※今日の日付を取得（Date.today）
Dateクラスでは、new の代わりにクラスメソッドtoday によりインスタンスの生成が可能。

```
require "date"
# 引数に年月日を渡してインスタンスを作成
date1 = Date.today

# 出力
puts = date1
```
実行結果→ 2018-12-12
（実行した日付が出力される）