おっさん初学者のRailsチュートリアル学習記録(4章)

プログラミング年少組のど素人が、アウトプット用に素人目線の解説を書いていきます。
自分が自分に教えていることを想像しながら進めていきます。
下記と同じような境遇の方であれば参考になるかも

- まっさらなプログラミング初学者
- オール独学
- 勉強は得意じゃない
- 社会人のため、1日に勉強できる量は限られる。

電子書籍のwebテキスト(第６版)を購入して使用
Progateの「Web開発パス」完走済
ドットインストールのプレミアム会員卒業
#4章 Rails風味のRuby#
「Rails風味の・・・」とか言われても初学者ペーペーにはイマイチピンときません。。

Railsで開発を進めていく場合、前提としてRubyをマスターしなくてもRailsで使うRubyの必要な知識があれば大丈夫！！ということみたいです
「Ruby on Rails」という名前だけにRubyで全てが作られているという訳ではないということです
「Rubyの機能を一部使いながら、Railsで開発をする」と言ったイメージでしょうか

よって本章では**Railsで使われるRubyの機能について**見ていきます
#4.1 動機#
**トピックブランチの作成**

これまでの章ではRubyの基礎知識を持たずともRailsでアプリの土台を作ったり、テストをしたりすることができました。
が、Rubyを使わないとできることに限界があるのも事実です。。
逆に言えば、Rubyの機能を使うことでアプリをより機能的にできるということです。
一部、RubyにはないけどRubyのような機能というものも存在します。

それでは学習を進めていくにあたり、いつものようにトピックブランチを作成しましょう

```
$ git checkout -b rails-flavored-ruby
```
##4.1.1 組み込みヘルパー##
*組み込みヘルパーについての説明*

まず「組み込みヘルパー」ってなんやねん。。っていう話です。
「組み込みヘルパー」で検索してもそれらしきものは見当たりませんでした。。が、
それらしきもので「組み込み関数」と「ヘルパー」ならヒットしました。

**組み込み関数**
それぞれ特定の機能を使えるようにするために好きに使える<font color="blue">「最初から搭載されている」</font>関数

**ヘルパー**
ある動作を処理する場合にメソッド化して扱えるようにしたもの
link_to、form_with、label_for、image_tagなどが挙げられるそうです

ええ〜〜っと。要は、Railsに初めから搭載されている便利な機能ということですね・・・簡単にまとめすぎて怪しいけど・・・

ここで「application.html.erb」を例に取って組み込み関数について説明が入れられています

```
<%= stylesheet_link_tag 'application', media: 'all',
                                       'data-turbolinks-track': 'reload' %>
```
こちらがいわゆる「組み込み関数」にあたるみたいですが、この2行を入力するだけで<font color="red">「application.css」を全てのメディアタイプで使えるようにする！</font>という機能となっているみたいです。
※メディアタイプ
パソコンのスクリーンやテレビ・プロジェクタ・携帯機器・印刷・音声・点字などが含まれる

また、このたった2行のコードに難しい初学者泣かせの概念が4つもあるとのことです。

- Railsの組み込み関数
- カッコを使わないメソッド呼び出し
- シンボル
- ハッシュ

以後これらについて4章で見ていくとのことです
##4.1.2 カスタムヘルパー##
*カスタムヘルパーについての説明*

カスタムヘルパーについて学んでいくうちに組み込みヘルパーの意味もだんだんわかってきました。
**組み込みヘルパー**
Railsが準備したものであり、あらかじめどういう動きをするものかが決まっている
コードにそのまま組み込んで使う。
先程書いた「Railsに初めから搭載されている便利な機能(メソッド)」というのはあらかた間違いではなかったみたいです
**カスタムヘルパー**
自分で準備するものであり、どういう動きのものかは自分で設定する必要がある
コードに組み込む前に、その<font color="green">ヘルパーがどういう名前でどういう動きをするかについてヘルパーファイルで設定する必要がある</font>
ヘルパーファイルはここにある👉app>helpersディレクトリの中

概要が分かったのでカスタムヘルパーを実装していきましょう
今回はレイアウト「application.html.erb」について見ていきます

```application.html.erb
<title><%= yield(:title) %> | Ruby on Rails Tutorial Sample App</title>
```
ここでは各ページのビューで指定したタイトルが「 | 」の左側に入るようにしていました
<% provide(:title, "Help") %>の場合
表示内容→ Help | Ruby on Rails Tutorial Sample App
<% provide(:title, "About") %>の場合
表示内容→ About | Ruby on Rails Tutorial Sample App
<% provide(:title, "Home") %>の場合
表示内容→ Home | Ruby on Rails Tutorial Sample App

では、Homeページだけprovide呼び出しを削除したい場合どうなるか
<% provide(:title, "Home") %>をなくしちゃったとすると
表示内容はこのようになります→ | Ruby on Rails Tutorial Sample App
...問題は「 | 」が残っちゃっているところです！
前置きが長くなりましたが
それを今回カスタムヘルパーで解消していきましょうという話になります

先程カスタムヘルパーにおきましては
<font color="green">ヘルパーがどういう「名前」でどういう「動き」をするかについて「ヘルパーファイル」で設定する必要がある</font>
と、記載しましたので、今回は
**名前**
full_titleヘルパー
**動き**
ページタイトルが定義されていない場合は基本タイトル「Ruby on Rails Tutorial Sample App」を返し、定義されている場合は基本タイトルに縦棒とページタイトルを追加して返す
**ヘルパーファイル**
application_helper.rb
ということで、作成していきます

```app/helpers/application_helper.rb
module ApplicationHelper

  # ページごとの完全なタイトルを返します。
  def full_title(page_title = '')
    base_title = "Ruby on Rails Tutorial Sample App" # 変数(base_title)に返しを代入
    if page_title.empty? # タイトルがない場合は？
      base_title # base_titleの値を表示します
    else # それ以外の場合は
      page_title + " | " + base_title # ページタイトルをつけてbase_titleの値を表示します
    end
  end
end
```
ここでできた、できたてホヤホヤのfull_titleヘルパーをhtml.erbに組み込んでいきます
該当箇所はこちら
<組み込み前>

```application.html.erb
<title><%= yield(:title) %> | Ruby on Rails Tutorial Sample App</title>
```
<組み込み後>

```application.html.erb
<title><%= full_title(yield(:title)) %></title>
```
これでyield(:title)=ページタイトルがある場合とない場合での表示内容を調整することができるようになりました

「Home」ページのタイトル表示内容が変わりましたのでテストの内容も変わります

```test/controllers/static_pages_controller_test.rb
class StaticPagesControllerTest < ActionDispatch::IntegrationTest
  test "should get home" do
    get static_pages_home_url
    assert_response :success
    assert_select "title", "Ruby on Rails Tutorial Sample App" # | がありません
  end
```
これで失敗するテストが完成しました

```
$ rails test
3 tests, 6 assertions, 1 failures, 0 errors, 0 skips
```
あとは成功させるためにHomeページのビューからも<% provide(:title, "Home") %>を丸ごと消しましょう
これで成功するテストが完成です

```
$ rails test
3 tests, 6 assertions, 0 failures, 0 errors, 0 skips
```
#4.2 文字列とメソッド#
*Rubyを学ぶツール「rails console」について*

「rails console」の特徴をまとめるの以下のように書いてあります

- コマンドで操作するツール
- Rubyの機能を全て使うことができる
- Rails環境にアクセスすることができる
- development(開発)環境で起動する
- 困ったら「Ctrl + c」で強制的に脱出するか「Ctrl + d」で終了させる


クラウドIDEの場合、使用するにあたり初期設定があるので、テキストを参照にして進めていきました
##4.2.1 文字列##
*Rubyの機能を使って文字列の扱い方を見ていく*

ここではRubyの基本的な簡単な動作を見てきいます
rails consoleで実際に動かしてみて文字の出力、変数に代入などからRubyの機能を楽しんで見ていきましょう
そんなに難しいことはありません

**出力について**
puts：改行あり
print：改行なし

**'シングルクォート'と"ダブルクォート"について**
シングルクォート：式展開しない・・・#{ }こういうやつが使えない
ダブルクォート：式展開する・・・\などの特殊文字を表示することができない
##4.2.2 オブジェクトとメッセージ受け渡し##
*Rubyにおけるオブジェクトについての説明*

ついにやってきました。プログラミング学習では避けて通れない<font color="red">「オブジェクト」</font>
テキストではしょっぱなから
検索したり、本を読むだけでは中々理解できない。体で覚えろ！
Don't Think!!!Feeeeeeeeeeeeeeeel!!的なことが書いてありますが、そんなこと言われてもますますわかりません。。

だがしかし、<font color="green">Rubyにおけるオブジェクトは簡単です</font>
タイトルにある通り、**オブジェクトとはメッセージを受け取ってそれを返すもの**となります。
メッセージと言っても簡単な質問のようなものをイメージすればわかりやすいかもしれません。
例えばメッセージに「length」というものがあります。
メッセージは一般的にはメソッドと呼ばれますので、「lengthメソッド」とでも呼びましょう。
この「lengthメソッド」はオブジェクトに対し、「何文字ですか？」という質問をする意味があります
それではこの「lengthメソッド」を使って、オブジェクトがメッセージを受け取って返す動きを見ていきましょう

まずは「rails console」でターミナルを起動します
ここに「"doraemon"」という文字列があったとします。
これにメッセージを受け取ってもらうには「.(コンマ)」をつけて、メソッドをくっつけます

```
>> "doraemon".length
==> 8
```
これは、"doraemon"は何文字ですか？を表しており、
それを受け取った"doraemon"は「8文字ですよ」と返しているわけです。
ここでいう"doraemon"こそが<font color="red">「オブジェクト」</font>と、いうわけです

<font color="red">「アナタは何ですか〜？」というメソッドの問いを受けることができて、「ワタシはこうですよ〜」のやりとりができるもの何でも「オブジェクト」ということになります</font>

テキストではオブジェクトを変数に代入して、様々なメソッドで問いをぶつけるという作業をしております。

**別件ですが少し補足**
ここでは説明しませんが、今後もテキスト内で多様される機能であり、以下の3点はすでに分かっていること前提となっているものたちですので、理解してから進めるようにしましょう
（Progateなどで簡単に学べます）

- ifを使った条件式
- 条件文を2つ以上含めたelsif (else + if)
- &&（and）や ||（or）、!（not）などの論理値

**話を戻して、nilの扱いについて**
Ruby特有の性質として「nil」もオブジェクトに含みます

```
>> nil.to_s # nilを文字列にすると何ですか？
=> "" # 空です
```
と言った風に返ってきます。しかし・・・

```
>> nil.empty?
NoMethodError: undefined method `empty?' for nil:NilClass
```
空ですか？と投げると・・・「いやー質問の意味が分かんね〜っす」と返ってきます。
nilはオブジェクトなので、この「分かんね〜っす(NoMethodError)」という返しですらオブジェクトの返答としてみなします。
しかし、一見意味分かりませんね。。。。
文字列を聞くと「空」と答え、「空」かと聞くと「分からない」と答える・・・

```
>> nil.to_s.empty?
=> true
```
この例では、メソッドが2つくっついています。
これを<font color="green">メソッドチェーン</font>といいます。
イメージとしては、1つ目のオブジェクトからの返しに対して２つ目のメソッドでさらに質問を被せている感じです。
「nil.to_s」の返しは「空」でしたので、「空」に「空」ですか？と投げると、今度は「そうですね(true)」が返ってきている。というわけです。

次はこちらのコードです

```
puts "x is not empty" if !x.empty?
```
見たまんだと
「x is not empty」と出力します。もし、〜でなければ。「x」が空
という感じでしょうか。
要は<font color="blue">「xが空ではなかったら"x is not empty"と出力します」</font>という意味になります。
後続するifでの条件式が真のときにだけ実行される式となります。
それ以外の場合(空以外の場合)を指定していないため、「x」に何らかの文字列が入った場合は「nil」が出力されます。

だんだんややこしくなってきました・・・
##4.2.3 メソッドの定義##
*メソッドを定義して、自分で機能を決める*

メソッドを定義する＝ヘルパー同様に、メソッドもどんな機能がありどんな動作をするかを自分で決める
これまで出てきたメソッドは「empty?：空ですか？」のように初めからどんな役割かが決まっていましたが、自分で作って機能を割り当てることも可能です
本節では引数に入れる内容によって、返す値が変わるメソッドを定義していきます
本来はファイル上で定義するのですが、今回はデモ目的のためコンソール上で進めていきます。

**今回定義するメソッド**
「string_message」メソッド
**動作**
引数が空の場合は"It's an empty string!"を返す
それ以外の場合は（引数に何らかの文字列がある場合）"The string is nonempty."を返す

```
>> def string_message(str = '') # この「引数=空」がデフォルト値の引数となる
>>   if str.empty? # 引数が空の場合
>>     "It's an empty string!" # "It's an empty string!"を返す
>>   else # それ以外の場合
>>     "The string is nonempty." # "The string is nonempty."を返す
>>   end
>> end
=> :string_message # メソッドの定義が完了
```
※「str = ''」とは空の文字列を表しており、今回これをデフォルト値に指定しているます。よって引数を渡さない場合は空の状態で返ってきます。
実際の動作を見ていきますと・・・

```
>> puts string_message("foobar") # それ以外の場合(文字列がある)
The string is nonempty.
>> puts string_message("") # 引数が空の場合
It's an empty string!
>> puts string_message # 引数を渡してないので、デフォルト値が選択される
It's an empty string!
```

以下のstring_messateメソッドの定義は上と同じ結果になります。

```
>> def string_message(str = '')
>>   return "It's an empty string!" if str.empty?
>>   return "The string is nonempty." # 空ではなかった場合
>> end
```
いきなり「return(戻り値)」とか出てきて、混乱してしまいそうですがそのままの意味で「メソッドが返す値」を意味します。
<font color="red">Rubyのメソッドには「暗黙の戻り値がある」とのことで、「必ず何かを返しますよ」「戻ってくる値はこちらですよ」というのを「return」に当てはめているだけです</font>
もちろん指定しなかった条件になったら「nil」を返します。
##4.2.4 titleヘルパー、再び##
*改めてfull_titleヘルパーの定義について確認する*

```app/helpers/application_helper.rb
module ApplicationHelper

# ページごとの完全なタイトルを返します。                   # コメント行
  def full_title(page_title = '')                     # メソッド定義とオプション引数
    base_title = "Ruby on Rails Tutorial Sample App"  # 変数への代入
    if page_title.empty?                              # 論理値テスト
      base_title                                      # 暗黙の戻り値
    else
      page_title + " | " + base_title                 # 文字列の結合
    end
  end
end
```
ここでヘルパーの定義について見ていくと、メソッドの定義とほぼほぼ同じですね。
返す値を変数に代入しているくらいでしょうかね

一番上にある**<font color="red">module ApplicationHelper</font>**について
ここで定義したfull_titleヘルパーが全てのビューで使えることを意味します
#他のデータ構造#
**Rubyのデータ構造について**

データ構造について掘り下げていくということみたいです。
データ構造って何やねん。。文字列を作るために必要な文字列以外の部分って感じで書いてありますけどよくわかりません。
この節で説明していくということです。。。
##4.3.1 配列をと範囲演算子##
*配列についての説明*

ハッシュやRailsのデータモデルを理解するための重要な基盤となる「配列」について学んでいきます

**配列とは**
ざっくり言うと、複数の文字列を保管している箱のようなもので、下のような形をしています

```
["doraemon", "nobita", "suneo"]
```
**要素とは**
箱に保管された一つ一つの文字列のことを指します。
この箱には"doraemon", "nobita", "suneo"という3つの要素が入っています。

**文字列を配列に変える方法**
splitメソッドを使うことで文字列を空白部分で区切って配列に変えることができます

```
>>  "foo bar baz".split     # 文字列を3つの要素を持つ配列に分割する
=> ["foo", "bar", "baz"]
```
配列は変数に代入することができます

```
>> a = [42, 8, 17]
=> [42, 8, 17] # これで変数aは「配列箱」となりました
```
ここで注意するのが一番左にある「42」は1番目ではなく、コンピュータとしては0番目として見ているということです。
ちなみにこの0番目とか1番目とかを、<font color="red">インデックス番号</font>と呼びます
Rubyの配列では配列の要素にアクセスするには角カッコを使います。
「aという箱の中からインデックス番号が○番の文字列を取り出したいな」といった場合は以下のようにします

```
>> a[0]
=> 42
>> a[1]
=> 8
>> a[2]
=> 17
```
角カッコ意外にも配列の要素にアクセスする方法もあります
それらしいものを、メソッドのようにコンマをつけて変数の後ろにくっつけます

```
>> a # 配列「a」の内容を確認する
=> [42, 8, 17]
>> a.first # firstだけに最初のやつを返す
=> 42
>> a.second # secondだけに2番目のやつを返す
=> 8
>> a.last # lastだけに最後のやつを返す
=> 17
```
**配列にメソッドをつけた場合の動作について**
先ほどから使っているaの箱にメソッドをつけて動作を見てみます

```
>> a
=> [42, 8, 17]
>> a.empty?
=> false
>> a.include?(42)
=> true
>> a.sort
=> [8, 17, 42]
>> a.reverse
=> [17, 8, 42]
>> a.shuffle
=> [17, 42, 8]
```
ちなみに様々なメソッドをつけて出力したとしても、元の配列の並び順は変わりません。
いちいち変わってたら、今はどのメソッド使ったらいいか分からなくなりますもんね。

```
>> a
=> [42, 8, 17] # どのメソッド使った後でも、aを出力したらこの順番で表示されます
```
だがしかし、並び順をメソッドに対応するものに変えてしまう方法ももちろんあります。
単純にメソッドの末尾に「！」をつけるだけでOKです

```
>> a
=> [42, 8, 17]
>> a.sort!
=> [8, 17, 42]
>> a
=> [8, 17, 42]
```
**配列に要素を追加する**
pushメソッド（または同等の<<演算子）を使って配列に要素を追加できます

```
>> a.push(6)                  # 6を配列に追加する
=> [42, 8, 17, 6]
>> a << 7                     # 7を配列に追加する
=> [42, 8, 17, 6, 7]
>> a << "foo" << "bar"        # 配列に連続して追加する
=> [42, 8, 17, 6, 7, "foo", "bar"]
```
**配列を文字列に変換する方法**
文字列を配列に変換するには「splitメソッド」を使いました。
逆に配列を文字列に変換する場合は「joinメソッド」を使います。

```
>> a
=> [42, 8, 17, 6, 7, "foo", "bar"]
>> a.join                       # 単純に連結する
=> "4281767foobar"
>> a.join(', ')                 # カンマ+スペースを使って連結する
=> "42, 8, 17, 6, 7, foo, bar"
```
**範囲について**
続いては範囲です。こんなやつ👉「0..5」、「a..f」
範囲は配列の中から連続したインデックス番号の要素を取り出す時に便利です

```
>> a = %w[foo bar baz quux]         # %wを使って文字列の配列に変換
=> ["foo", "bar", "baz", "quux"]
>> a[0..2]
=> ["foo", "bar", "baz"]
```

こんな風に<font color="red">「0..2」</font>とすることでインデックス番号の0から2までを取り出すことができました。

範囲を( )でくくり、「to_aメソッド」をつけることで、配列として出力することもできます

```
>> (0..9).to_a            # 丸カッコを使い、範囲オブジェクトに対してto_aを呼びましょう
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # ちゃんと0から9までが1個ずつ入ってます

```
また、範囲は文字列でも使えます

```
>> ('a'..'e').to_a
=> ["a", "b", "c", "d", "e"]
```
##4.3.2 ブロック##
*ブロックを紹介*

```
>> (1..5).each { |i| puts 2 * i }
2
4
6
8
10
=> 1..5
```
いきなりワケがわかりません。
(1..5)にeachメソッドが呼ばれている(付いている)? iに2をかけて出力する?
分かるような分からないような感じですので、少しずつ紐解いて見ていきましょう

**範囲オブジェクトのeachメソッドとは**
とにもかくにも、ここを理解するにはまずeachメソッドが何かを知らなくてはなりません。。。
eachメソッドは、主に<font color="red">配列の要素の数だけ処理を繰り返し行いたい場合</font>に使用するメソッドで、**各要素に対してブロックに書いた処理を加えて返します**
配列を指定してeachメソッドを実行すると、配列のインデックス番号0から順番に繰り返し処理が実行されるというワケです
今回の例で当てはめますとこういうことでしょうか
(1..5)：配列の要素ですので[1, 2, 3, 4, 5]・・・<font color="red">範囲オブジェクト</font>
ブロック：{ | i | puts 2 * i }

上にある通り、メソッドに渡されている{ | i | puts 2 * i }が、今回のメインテーマである**ブロック**と呼ばれる部分に該当します

気になるのはブロックの頭に付いている**| i |**です。
i は変数名であり、ブロックのなかにあるのでブロック変数となります。
| i |では変数名が縦棒「|」に囲まれていますが、これはブロック変数に対して使うRubyの構文で、ブロックを操作するときに使う変数を指定してどうのこうの・・・
ますます混乱しそうな説明だな・・・
要は
<font color="blue">「配列（範囲）から引っ張ってきた要素はこれだ（ i だ！）！！処理しろ！！」</font>
と宣言して分かりやすくしてるのよ。たぶん。
範囲に含まれるそれぞれの値をこの変数（ i ）に次々に代入してブロックを実行します。

ちなみに変数（ブロック変数）の名前は固定されていませんので、無理に i にする必要はありません。

ここからそのブロックがどんどん形を変えていきます・・・
<font color="red">ブロックであることを示すには波カッコ で囲みますが、次のように**doとend**で囲んで示すこともできます</font>

```
>> (1..5).each do |i|
?>   puts 2 * i
>> end
2
4
6
8
10
=> 1..5
```
{ }がなくなって、doがeachのあとに付いたくらいでしょうか
先程と結果が同じなので書き方は違えども意味していることが同じことが分かると思います。
ここまできたら、何となくProgateとかで見た形に近づいてきました。

**ブロック付きメソッドの紹介**

```
>> 3.times { puts "Betelgeuse!" }  # 3.timesではブロックの変数は省略できる
"Betelgeuse!"
"Betelgeuse!"
"Betelgeuse!"
=> 3
>> (1..5).map { |i| i**2 }          # 「**」記法は冪乗 (べき乗)
=> [1, 4, 9, 16, 25]
>> %w[a b c]                        # %w で文字列の配列を作成
=> ["a", "b", "c"]
>> %w[a b c].map { |char| char.upcase }
=> ["A", "B", "C"]
>> %w[A B C].map { |char| char.downcase }
=> ["a", "b", "c"]
```
**timesメソッド**
指定された回数分処理を繰り返すメソッド。
オブジェクトの部分に繰り返したい回数を記載する。
ブロック変数が省略されています。ブロック変数を指定しない場合は「これを処理しろ！」みたいな指定が外れるということですので、純粋に要素の数だけブロックの処理を繰り返します。

**mapメソッド**
配列変数.map {|変数名| 具体的な処理 }
配列の要素にブロック内で指定した処理をして配列のまま返す。
**upcaseメソッド**
オブジェクトを大文字に変換して返すメソッド
**downcaseメソッド**
オブジェクトを小文字に変換して返すメソッド
**おまけでrejectメソッド**
配列の要素からブロック内で指定された要素を取り除いて返すメソッド

**単体テストにもブロックが使われていた**

```
test "should get home" do
  get static_pages_home_url
  assert_response :success
  assert_select "title", "Ruby on Rails Tutorial Sample App"
end
```
先程「ブロックはdoとendで囲むことができる」とありまたので、今回はgetから下3行がそれに当たります。
と、いうことで「test」はメソッドです。
「test」メソッドは文字列"should get home"とブロックを引数に取っています。
ちなみに、文字列が入っていてややこしくしていますが、これはただの「説明文」です。
テストでやることを分かりやすく表示しているだけみたいです。
##4.3.3 ハッシュとシンボル##
*ハッシュの説明*

**ハッシュとは**
「キーと値」の1ペアが配列の要素1個に当たるようなイメージで、キーと値のペアを波カッコで囲んで表記したものを指します。

```
 {"last_name"=>"Nobi", "first_name"=>"Nobita"} # こんな感じ
```
・・・いきなりキーとか値とか言ってもワケ分からないのでタンスに例えます。
タンスには引き出しがついていますが、上着用の引き出しには上着が入っていますし、下着用の引き出しには下着が入っています。（ここで上着下着を場所に関係なくぶち込んでいるようなガサツな方は几帳面な人になったつもりで見ていて下さい）
この「上着用の引き出し」や「下着用の引き出し」が「キー」に該当し、中に入っている「上着」や「下着」が「値」に該当します。
とりあえず、コード上で例にとります。

```
>> user = {}                          # {}は空のハッシュ。userタンスを作る
=> {}
>> user["first_name"] = "Michael"     # キー（引き出し）が "first_name" で値が "Michael"
=> "Michael"
>> user["last_name"] = "Hartl"        # キー（引き出し）が "last_name" で値が "Hartl"
=> "Hartl"
>> user["first_name"]                 # 要素へのアクセスは配列の場合と似ている
=> "Michael"
>> user                               
=> {"last_name"=>"Hartl", "first_name"=>"Michael"} # ハッシュはこのように表示される
```
この例ですと「"first_name"の引き出し」を開けたら「"Michael"」が入っていて、「"last_name"」の引き出しを開けると「"Hartl"」が入っている。といった状態です。
（ちなみに、波かっこで囲まれていますが、ブロックの波カッコとはまったく別物です）

また、キーや値を指定する方法として、上記のように書くよりも簡潔にする方法があります

```
>> user = { "first_name" => "Michael", "last_name" => "Hartl" }
```
これで上記と同様にuserタンスにものを入れる作業・・・じゃなくてハッシュの定義が完了します。

**文字列をシンボルに**
さてさて、ここから本番です。と言っても過言ではありません。
特殊なデータ形式である「シンボル」を使うことでRailsっぽさが出てきます。
Railsでは文字列よりもシンボルを使う方が普通です。

シンボルは文字列と似ていますが、クォート（"mojiretsu"）で囲む代わりにコロン（ :sinboru ）が前に置かれています。このように見た目の違いはもちろん、呼び出せるメソッドも違ってきます。

```
>> "name".split('')
=> ["n", "a", "m", "e"]
>> :name.split('') # split使えませーん
NoMethodError: undefined method `split' for :name:Symbol
>> "foobar".reverse
=> "raboof"
>> :foobar.reverse # reverse使えませーん
NoMethodError: undefined method `reverse' for :foobar:Symbol
```
まあ、ハッシュとしてシンボルを使うのに、配列にバラしたり逆に読むことなんてないから関係ねーですけどね

**ハッシュはキーとして使われます**

```
文字列を使用すると
>> user = { "first_name" => "Michael", "last_name" => "Hartl" }
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}

ハッシュを使用すると
>> user = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
```
そしてさらにハッシュには別にも記法がありまして・・・

```
さっき紹介した記法(コロンが左に！)
>> h1 = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}

新しい記法(コロンが右に！)
>> h2 = { name: "Michael Hartl", email: "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
```
頭につけてた「 : 」がお尻に、そしてハッシュロケット（ => ）も省略されて少し簡略化されていますね。
頭にコロンがついてて「シンボル！」って感じでしたので、シンボルであることを忘れてしまいそうですけど・・
（コンピュータ上ではしっかり頭につけたシンボルとして見てますね。。）

**ハッシュの中にハッシュ！？**

```
>> params = {}        # 'params' というハッシュを定義する ('parameters' の略)。
=> {}
>> params[:user] = { name: "Michael Hartl", email: "mhartl@example.com" }
=> {:name=>"Michael Hartl", :email=>"mhartl@example.com"}
>> params
=> {:user=>{:name=>"Michael Hartl", :email=>"mhartl@example.com"}}
>>  params[:user][:email]
=> "mhartl@example.com"
```
ええ〜っと・・・
キーが「user」で値が「name: "Michael Hartl", email: "mhartl@example.com"」
その値の中でキー「name」と「email」があり、値「"Michael Hartl"」と「"mhartl@example.com"」になっていて・・・ややこしいですね！！

ここはまたタンスで例えましょう！！
paramsタンスです！！
タンスの下着入れてる引き出しって仕切りにしていますよね。ここは靴下ゾーン、ここはパンティーゾーン、ここはハンカチーフゾーン・・みたいに。。あれです！
今回のケースですとparamsタンスのuser引き出しは下着入れる引き出しで、開けたらまた仕切りで区切られていて、靴下ゾーン（nameゾーン）やパンティゾーン（emailゾーン）に分けられて保存されている！というワケです。
しかも今後この「ハッシュの中にハッシュ」は多用されるらしい・・・なので必ずここで理解しておくようにしておきましょう。
大丈夫。ああ・・パンティのやつね・・で思い出せます。

**ハッシュにもeachメソッドが使えるというはなし**
とりあえずコードから見てみましょうか

```
>> flash = { success: "It worked!", danger: "It failed." } # success引き出しとdanger引き出しね
=> {:success=>"It worked!", :danger=>"It failed."}
>> flash.each do |key, value|
?>   puts "Key #{key.inspect} has value #{value.inspect}"
>> end
Key :success has value "It worked!"
Key :danger has value "It failed."
```
ハッシュの説明を始めた時にボソっと書いていました
「「キーと値」の1ペアが配列の要素1個に当たるようなイメージ」だと。
eachメソッドの説明の時にボソっと書いていました
「配列の要素の数だけ処理を繰り返し行う」と。
ブロック変数の説明の時にボソっと書いていました。
「配列（範囲）から引っ張ってきた要素はこれだ（ i だ！）！！処理しろ！！」ということだと。

それらを組み合わせて、今回のコードは理解できそうです。
success: "It worked!"が要素１
danger: "It failed."が要素２
ブロックの中ではそれぞれのキーや値を出力させるような処理が書かれてあります。
そして、2つある要素を実行して処理は完了しています。それだけのことですね。

**inspectメソッドの紹介**
先程、例のコードでさりげなく入っていた、inspectメソッドにて説明されています。
要求されたオブジェクトを表現する文字列を返します。

```
1
2
3
4
5
>> puts (1..5).to_a.inspect    # 配列のリテラルを出力
[1, 2, 3, 4, 5]
>> puts :name, :name.inspect
name
:name
>> puts "It worked!", "It worked!".inspect
It worked!
"It worked!"
```
なんか、「そのままを出してる！！」って感じですね。
##4.3.4 CSS、再び##
*4章の始めに出てきたstylesheet_link_tagメソッドのおさらい*

スタイルシートを追加するための特別なメソッドであるstylesheet_link_tagメソッド

```
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'
```
今ならこのコードを理解できるようになったはずです！
・・とか言われても理解できません！！

```
stylesheet_link_tag('application', { "media" => 'all',
                               "data-turbolinks-track" => 'reload' })
```

ということで、省略されているであろう表現を全て書き足してみました。
こうすれば、なんとな〜〜くだけど見えてくるような気がします・・・

「stylesheet_link_tagメソッドを2つの引数が呼んでいる」ということでしたので、それぞれ引き出して眺めてみました。

**1つ目の引数："application"**
スタイルシートへのパスを示しています
（拡張子を指定しない場合は.cssが自動的に追加されるらしい）
なので、パスはここのことかな👉app < assets < stylesheets < application.css

**2つ目の引数：{ "media" => 'all', "data-turbolinks-track" => 'reload' }**
ハッシュで2つの要素が表現されています。
最初の要素はメディアタイプを示し、スタイルシートをすべてのメディアタイプに適用するため、明示的に「all」に設定しています。
次の要素はRails 4.0で追加されたturbolinksという機能をオンにしています。それだけのこと。

・・・そんなこんなでapplication.cssをあらゆるメディアで使えるようにしているワケです。

理解度11％くらいですが、これ以上考えても、今の自分のレベルでは到底理解できず先に進まないのでこれくらいにしときます。。すみません。。
#4.4 Rubyにおけるクラス#
**クラスで何をしているかを軽く説明**

Rubyはメソッドをまとめるのにクラスを使っています。
このクラスからインスタンスが作成されることでオブジェクトが作成されるという流れとなりますが、
この節ではオブジェクトをいくつか作ってみましょう。といった流れになるそうです

オブジェクト思考プログラミングの経験がない方は何のことだか分からないでしょうけどね。ぷ。
ということです。
##4.1.1 コンストラクタ##
*オブジェクトができるまで*

先程書いた「クラスからインスタンスが作成されることでオブジェクトが作成される」という流れを見ていきましょう

```
>> "foobar".class # "foobar"のクラスは何ですか〜
=> String # Stringです
>> :foobar.class # :foobarのクラスは何ですか〜
=> Symbol # Symbolです
```
この.classは「classメソッド」であり、どのクラスに所属しているかを単に聞いているだけです。
どこのclassに所属しているかなんて指定した覚えはないけれど・・・
実は指定しているのです。。。省略されているだけで。。

```
>> String.new("foobar") # 「Stringクラスで"foobar"作りました！！」
=> "foobar"
```
「String.new」が省略されているのです。
仮にここでclassメソッドをくっつけてみると・・・

```
>> String.new("foobar").class
=> String
```
「Stringクラスで"foobar"作りましたけども、クラスは何ですか〜」ってアホか！ってなりますけど、当然Stringクラスです。
シンボルについてはnewメソッドが使えないので、同じようにはできないので置いときましょう！
newメソッドが使える例として「配列」があります。

```
>> [1,2,3].class # [1,2,3]のクラスは何ですか〜
=> Array  # Arrayです
>> Array.new([1,2,3]).class
=> Array
```
以上、インスタンスを何も意識しないで作ることができてました。という話でした。
**しれっと使っていたnewメソッド**
classからインスタンスを作るメソッド
（インスタンス・・・classという型からできた具体例）
また、クラスにくっついてるので<font color="red">「クラスメソッド」</font>と呼ばれます

このインスタンスが型からポーンでオブジェクトができたというわけです

結局「コンストラクタ」って何だよ・・・
##4.4.2 クラス継承##
*クラスの継承について*

**superclassメソッド**
どこのクラスを継承しているかを調べる（親クラスを調べる）
※classメソッドは自分のクラスを調べる

まずはRubyの根本的なところから見ていきます

```
>> s = String.new("foobar")
=> "foobar"
>> s.class                        # 変数sのクラスを調べる
=> String　　　　　　　　　　　　　　　# 先程出てきたStringクラス
>> s.class.superclass             # Stringクラスの親クラスを調べる
=> Object　                       # Stringクラスの親クラスはObjetクラス
>> s.class.superclass.superclass  # Objetクラスの親クラスはBasicObjectクラス
=> BasicObject
>> s.class.superclass.superclass.superclass
=> nil # 終わり
```
「Rubyの全てのクラスの先祖は一人のBasicObjectクラスから始まった」ということです
クラスは親から子に機能が引き継がれますので、**子は親のクラスを継承している**ということになります。

ということで、クラスを作って見ましょう

```
>> class Word
>>  def palindrome?(string)
>>   string == string.reverse
>>  end
>> end
=> :palindrome?
```
「Wordクラス」には今回定義した回文かどうかを確かめる「palindrome?」というメソッドが入ってます
では早速確かめてみましょう

```
>> w = Word.new # インスタンスを作成
=> #<Word:0x00007fb3a4bc81f8>
>> w.palindrome?("foobar") #"foobar"は回文ですか？
=> false
>> w.palindrome?("level") # "level"は回文ですか？
=> true
```
ちゃんと機能しているみたいですね。
よしよし、いい感じに動いていますね。。
ここでクラスを確認してみましょう

```
>> w.class
=> Word
>> w.class.superclass
=> Object
>> w.class.superclass.superclass
=> BasicObject
```
Wordクラスは特にクラスの継承は指定していませんでした。
<font color ="red">クラスの継承を指定しない場合は勝手にObjectクラスを継承</font>していることになるみたいですね。
ですので、Wordクラスではpalidrome?しか定義していなかったにも関わらず「class」メソッドを使うことができた。というわけです。
基本的なことは大体ObjectクラスやBasicObjectクラスにまとめて入っているので、それを継承させることで機能を引き継げば同じように使える。というわけです。
ちなみに継承させるクラスを指定するには
**作成したクラス < 親クラス（機能を引き継ぎたいクラス）**とすればよいので、今回のWordクラスの例でやってみましょう

```
>> class Word < String
>>  def palindrome?
>>   self == self.reverse # self!?
>>  end
>> end
=> :palindrome?
```
こうすることで、Wordクラス内でStringクラスのメソッドが使えるようになります
sizeメソッド、lengthメソッド・・・・すぐに思い浮かばんけどとにかくいろいろ使えます
もちろん今回指定したpalindrome?メソッドも使えます

ここで、サラッと流していましたが**「self」**についてです
これはStringクラスを継承したことにより使えるようになった機能です
先程はpalindromeメソッドの引数に文字列を渡して回文かどうかをチェックしていましたが
今回はpalindromeメソッド自体（self）が回文かどうかをチェックしています
字数も少なくてすみますし積極的に使っていきたいものです
##4.4.3 組み込みクラスの変更##
*Rails風味のRubyの回収*

継承を使わずにWordクラスなどわざわざ作らなくてもpalindrome?メソッドを使えるようにする手段として、先程親クラスとしていたStringクラスにpalindrome?を定義することができます
このことを<font color="red">Stirngクラスを拡張する</font>と言います

```
>> class String
>>   # 文字列が回文であればtrueを返す
>>   def palindrome?
>>     self == self.reverse
>>   end
>> end
=> :String
>> "deified".palindrome?
=> true
```
**ただし！！！**
真に正当な理由がない限り、組み込みクラスにメソッドを追加することは無作法であると考えられています
**「こういうこともできるけど、やんない方がいい。てかやるな！みんなが使うものを勝手に改造するな！」**ということですね。。。

この仕組みを使って、RailsによってRubyの組み込みクラスに追加が行われています

```
>> "".blank?
=> true
>> "      ".empty?
=> false
>> "      ".blank?
=> true
>> nil.blank?
=> true
```
Rubyにある「empty?メソッド」ではスペースでの空白を認識することができません
そこで、Railsは「blank?メソッド」をStringの上のクラスに追加して、空白を認識できるメソッドを作成しています。
Rubyのコードだけども、Rubyには備わっていないRailsオリジナルの機能が他にもたくさんあるということです。。。
##4.4.4 コントローラークラス##

これまで何気に使っていたコントローラーについても見ていきましょう

```
class StaticPagesController < ApplicationController

  def home
  end

  def help
  end

  def about
  end
end
```
よく見ると、、、コントローラーも「クラス」だったんですね。。。
StaticPagesControllerはApplicationControllerを継承していることがわかりますが、この先の階層も辿って見ていきましょう

```
>> controller = StaticPagesController.new
=> #<StaticPagesController:0x22855d0>
>> controller.class
=> StaticPagesController
>> controller.class.superclass
=> ApplicationController
>> controller.class.superclass.superclass
=> ActionController::Base
>> controller.class.superclass.superclass.superclass
=> ActionController::Metal
>> controller.class.superclass.superclass.superclass.superclass
=> AbstractController::Base
>> controller.class.superclass.superclass.superclass.superclass.superclass
=> Object
>> controller.class.superclass.superclass.superclass.superclass.superclass.superclass
=> BasicObject
```
・・・そう、全てのクラスはたった一人のBasicObjectから始まった。。と、いうことです。
それと同様に、モデルとかビューにおいても同じことが言えます。
##4.4.5 ユーザークラス##
*クラスを作成して動作を確認する*

完全なクラスを作ります。。。完全なクラスって何だよ。。と思いましたが、コンソール上じゃなくて、ファイルで作成しようというはなしみたいです。。。
しかも、ちょっと作ってみるだけなのに初めて見ること盛り沢山やんけ・・・と愚痴っても仕方ないのでボチボチやっていきましょう

テキストではアプリケーションのルートディレクトリにexample_user.rbファイルを作成するとあります
ルートディレクトリは一番上のディレクトリのことです
appを右クリックしてファイルを作成しましょう

```
class User
  attr_accessor :name, :email・・・①

  def initialize(attributes = {})・・・②
    @name  = attributes[:name]
    @email = attributes[:email]
  end

  def formatted_email・・・③
    "#{@name} <#{@email}>"
  end
end
```
とりあえずで書かれてますと言ったわりに、見たことないものがいくつか見受けられます。
そして3部構成になっていますね・・・

**① attr_accessor(アトリビュートアクセサ)について**

```
attr_accessor :name, :email
```
ユーザー名とメールアドレス（属性: attribute）に対応するアクセサー（accessor） をそれぞれ作成します。。アクセサを作成するとそのデータを取り出すメソッド（getter）と、データに代入するメソッド（setter）をそれぞれ定義してくれます。
要は**「getter」と「setter」を定義してくれるメソッド**です
おおおお、とても難しい説明ですね
とりあえずバラバラに分解したら下記のようなコードになるみたいです

```
　def name # 読み込み用（getter）
       @name
　end
    
  def name=(val) # 書き込み用（setter）
      @name = val
  end
   
  def email # 読み込み用（getter）
      @email
  end
   
  def email=(val) # 書き込み用（setter）
      @email = val
  end
```
読み込み用（getter）：インスタンス変数にアクセスしてデータを取り出すメソッド
書き込み用（setter）：データに代入するメソッド

そして(val)とか出てきてなおさら混乱してきましたね。。。分解して良かったのか・・・
ここでは<font color="red">インスタンス変数(@がついたやつ)にアクセスできるようになった</font>ことだけ抑えときましょう
<font color="blue">Railsでは、インスタンス変数をコントローラ内で宣言するだけでビューで使えるようになる</font>ため、クラス内であればどこからでもアクセスできる変数として使われます。

このattr_accessorの説明。書いてみたものの実は全然理解できてません。。
ってな時にこの記事読んでたらスッキリしました
👉[Railsから入った人へ【attr_accessor】って？](https://qiita.com/Hassan/items/0e034a1d42b2335936e6)

②initializeメソッドについて

```
  def initialize(attributes = {}) # 空のハッシュ
    @name  = attributes[:name]
    @email = attributes[:email]
  end
```
**initializeは、Rubyの<font color="red">特殊な</font>メソッドで「クラス名.new」すると自動的に呼び出されるメソッドです**（今回はUser.new）
このメソッドをクラス内に記述した場合にはオブジェクトが作成される時に自動的に呼び出されます。
newして、できたてホヤホヤのインスタンスに対して常に勝手に実行するメソッドってことですかね。

今回initializeメソッドは、次のようにattributesという引数を1つ取ります
デフォルト値が空のハッシュになっているので、キーが存在しません。
よって**newした時にとりあえず名前やアドレスのないユーザーを作ることになります**
これで「自分がユーザー登録しようとしたら、初めから違う人の名前が入っていた・・」なんてケースを防ぐことができます。。
そしてそこからattr_accessorで定義した「書き込み」の方を利用して名前やアドレスを代入していくと言うワケです。

③formatted_emailメソッドの定義

```
  def formatted_email
    "#{@name} <#{@email}>"
  end

```
@nameや@emailは先程「attr_accessor」で定義したので当たり前のように使えます。
newして出てきた空の「name」や「email」を肉付けをしていく過程を見ていくと

```
>> example = User.new
=> #<User:0x224ceec @email=nil, @name=nil> # initializeメソッド発動！！！！
>> example.name                 # attributes[:name]は存在しないのでnil
=> nil
>> example.name = "Example User"           # 名前を代入する
=> "Example User"
>> example.email = "user@example.com"      # メールアドレスを代入する
=> "user@example.com"
>> example.formatted_email
=> "Example User <user@example.com>"
```
空になっていたので、値を代入した。ただそれだけのことです。。
#4章の要約をようやく作り終えての感想#
ここは今後に響いてくる重要な章だと思います。ここを理解できないまま先に進と大事故になる恐れがあります。。。挫折という・・・・
まさに基礎的なことをやっているのだなーと思いながらも、説明できるほどには到底理解できておらず、流石にうやむやなまま通り過ぎるワケにはいかない部分なので、かなり時間をかけて一つ一つ調べながら進めました。
そしてたまらず解説動画を購入しました。何度か定期的に振り返りたい章です。

今回はここまで。。。
また続きは後日更新します