Railsチュートリアル4章まとめ

#この章で学ぶこと
基本的なRubyの構文を学ぶ
基礎をある程度知っていればこの章は程々に流し見すればOK

+ helper
+ Ruby自体の文字列、オブジェクト
+ メソッド
+ 配列、範囲演算子
+ ブロック{}
+ ハッシュとシンボル　（#タグではありません）
+ クラス、クラスの継承


4.1.2 カスタムヘルパー

ビューなどで新しく作ったメソッドはカスタムヘルパー と呼ぶ

まずは``full_title``というヘルパーを作成する
full_titleヘルパーは、ページタイトルが定義されていない場合は基本タイトル「Ruby on Rails Tutorial Sample App」を返し、定義されている場合は基本タイトルに縦棒とページタイトルを追加して返す

```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
```

ヘルパーを作成したので、これを使ってレイアウトをシンプルにする

```
<title><%= yield(:title) %> | Ruby on Rails Tutorial Sample App</title>
↓↓
<title><%= full_title(yield(:title)) %></title>
```

```app/views/layouts/application.html.erb
<!DOCTYPE html>
<html>
  <head>
    <title><%= full_title(yield(:title)) %></title> #full_titleメソッド
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>
    <%= stylesheet_link_tag    'application', media: 'all',
                               'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application',
                               'data-turbolinks-track': 'reload' %>
  </head>
  <body>
    <%= yield %>
  </body>
</html>
```

タイトルの表示方法を変更したので、testも更新する

```test/controllers/static_pages_controller_test.rb
require 'test_helper'

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

  test "should get help" do
    get static_pages_help_url
    assert_response :success
    assert_select "title", "Help | Ruby on Rails Tutorial Sample App"
  end

  test "should get about" do
    get static_pages_about_url
    assert_response :success
    assert_select "title", "About | Ruby on Rails Tutorial Sample App"
  end
end
```

この状態ではtestは失敗するので、

Homeページのビューからprovide の行を削除する

```app/views/static_pages/home.html.erb
<h1>Sample App</h1>
<p>
  This is the home page for the
  <a href="https://railstutorial.jp/">Ruby on Rails Tutorial</a>
  sample application.
</p>
```

これでtestはパスする。
4章でsample_app自体を触るのはこれで最後。
あとはrails consoleでRuby自体を学ぶ

##4.2 文字列とメソッド

今後、Ruby詳細が知りたければ、Rubyリファレンスマニュアル（通称: るりま）や、るりまサーチを使うと便利
https://docs.ruby-lang.org/ja/
https://docs.ruby-lang.org/ja/search/

###4.2.1 文字列
文字列（string） は、Webアプリケーションにおいて最も重要なデータ構造 
理由はWebページというものが究極的にはサーバーからブラウザに送信された文字列にすぎないため

```Ruby
$ rails console
>> ""         # 空の文字列
=> ""
>> "foo"      # 空ではない文字列
=> "foo"
ここで入力したものは文字列リテラルと呼ばれダブルクォート " で囲むことで作成可能
```

####   +演算子を使って、文字列を結合する

```Ruby
>> "foo" + "bar"    # 文字列の結合
=> "foobar"
```

####式展開（interpolation）=#{}という特殊な構文を使う

```Ruby
>> first_name = "Michael"    # 変数の代入
=> "Michael"
>> "#{first_name} Hartl"     # 文字列の式展開
=> "Michael Hartl"
```

例えば"Michael"という値をfirst_name変数に代入（assign）し、この変数を "#{first_name} Hartl" という形で文字列の中に埋め込むと、文字列の中でその変数が展開される

```Ruby
>> first_name = "Michael"
=> "Michael"
>> last_name = "Hartl"
=> "Hartl"
>> first_name + " " + last_name    # 苗字と名前の間に空白を入れた結合
=> "Michael Hartl"
>> "#{first_name} #{last_name}"    # 式展開を使って結合 (上と全く同じ)
=> "Michael Hartl"
```

最後の2つの結果は、全く同じ結果（「等価」と言います）

####putsで文字列を出力可能
※putの三人称単数現在形ではなく「put string」の略

```Ruby
	>> puts "foo"     # 文字列を出力する
	foo
	=> nil　　　#副作用
```

putsメソッドでは副作用が重要な役割を果たす
 puts "foo"は文字列「"foo"」を副作用としてスクリーンに表示し、戻り値にはnilを返す
nilは「何にもない」ことを表すRubyの特別な値
	
putsを使って出力すると、改行文字である\nが自動的に出力の末尾に追加される
似たメソッドでprintメソッドも同様の出力を行うが、改行文字を追加しない点が異なる
	
```Ruby	
>> print "foo"    # 文字列の画面出力 (putsと同じだが改行がない)
foo=> nil
```
意図的に改行を追加したいときは、「バックスラッシュ（\）+ n」（\n）という改行文字を使えばできる

```Ruby	
>> print "foo\n"  # puts "foo" と等価
foo
=> nil
```

####railsではダブルクォート文字列でもはシングルクォートでもOK。
ほとんどの場合、ダブルクォートとシングルクォートのどちらを使っても実質的に同じだが、式展開はシングルクォートでは行われない

```Ruby
	>> 'foo'          # シングルクォートの文字列
	=> "foo"
	>> 'foo' + 'bar'
	=> "foobar"

	>> '#{foo} bar'     # シングルクォート内の文字列では式展開ができない
	=> "\#{foo} bar"
```

ダブルクォート文字列を用いた文字列で#のような特殊な文字を使いたい場合は、この文字をバックスラッシュでエスケープ（escape） する必要がある
	
※バックスラッシュは￥マークのボタン（mac）　option+¥でできる
https://qiita.com/miyohide/items/6cb8967282d4b2db0f61

```Ruby
>> '\n'       # 'バックスラッシュ n' をそのまま扱う
=> "\\n"
```
	
###オブジェクト指向
Rubyでは、あらゆるものがオブジェクト。文字列やnilですらオブジェクト。
オブジェクト指向って何？となりますが、これは概念のようなもので、実際に触りながらこんなものかと覚えていくしかないようです。
↓参考ページ
https://www.sejuku.net/blog/124336#:~:text=Ruby%E3%81%AF%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E6%8C%87%E5%90%91%E5%9E%8B,%E3%81%BE%E3%81%A8%E3%82%81%E3%81%9F%E9%96%8B%E7%99%BA%E5%BD%A2%E5%BC%8F%E3%81%A7%E3%81%99%E3%80%82
	
文字列オブジェクトは、直接メソッドをつなげられる
※lengthメソッド＝文字列の文字数を返す。
	
```Ruby
>> "foobar".length        # 文字列に "length" というメッセージを送る
=> 6
```

####？疑問符でtrueまたはfalseという論理値（boolean）を返せる

```Ruby
>> "foobar".empty?　　#文字列に"empty?"メソッドを送る
=> false
>> "".empty?
=> true
#以下のif文と等価
>> s = "foobar"
>> if s.empty?
>>   "The string is empty"
>> else
>>   "The string is nonempty"
>> end
=> "The string is nonempty"
```

####条件文を2つ以上含めたい場合は、elsif (else + if) という文を使う

```Ruby
	>> if s.nil?  #もしsがnilなら（trueなら）
	>>   "The variable is nil"
	>> elsif s.empty?　　#もしsが空なら（trueなら）
	>>   "The string is empty"
	>> elsif s.include?("foo")　#もしsが"foo"を含んでいたら
	>>   "The string includes 'foo'"
	>> end
	=> "The string includes 'foo'"　
```

####論理値は &&（and）や ||（or）、!（not）オペレーターで表すこともできる。

```Ruby

	>> x = "foo"
	=> "foo"
	>> y = ""
	=> ""
	>> puts "Both strings are empty" if x.empty? && y.empty?
	=> nil
	>> puts "One of the strings is empty" if x.empty? || y.empty?
	"One of the strings is empty"
	=> nil
	>> puts "x is not empty" if !x.empty?
	"x is not empty"
	=> nil
```

####nilもオブジェクトなので、メソッドに対応可能

オブジェクトを文字列に変換するto_sメソッドを使って、nilがメソッドに応答する例

```Ruby
>> nil.to_s
=> ""
#確かに空文字列が出力される
```

####メソッドチェイン（method chaining）でnilにいろんなオブジェクトを渡す

```Ruby
>> nil.empty?
NoMethodError: undefined method `empty?' for nil:NilClass
>> nil.to_s.empty?      # メソッドチェーンの例
=> true
#nilオブジェクト自身はempty?メソッドには応答しないにもかかわらず、nil.to_sとすると応答する
```

####nilかどうかを調べるメソッドnil?

```Ruby
	>> "foo".nil?
	=> false
	>> "".nil?
	=> false
	>> nil.nil?
	=> true
```

####ifの簡潔な使い方

```Ruby
puts "x is not empty" if !x.empty?
#もしxが空(true)でないなら...
```

後続するifでの条件式が真のときにだけ実行される式（後続if）を書くことができ、コードが非常に簡潔になる

unlessキーワードも同様に使える

```Ruby
>> string = "foobar"
>> puts "The string '#{string}' is nonempty." unless string.empty?
#stringが空（true）でない（false）なら...
The string 'foobar' is nonempty.
=> nil
```

####Rubyのオブジェクトのうち、オブジェクトそのものの論理値がfalseになるのは、false自身とnilの2つしかない
「!!」（「バンバン（bang bang）」と読みます）という演算子を使うと、そのオブジェクトを2回否定することになるので、どんなオブジェクトも強制的に論理値に変換できる
	
```Ruby
>> !!nil  #nilのまま
=> false
#ゼロですらtrue
>> !!0
=> true
```
	
###4.2.3 メソッドの定義
	
```Ruby
	>> def string_message(str = '')　#デフォルトの引数は''
	>>   if str.empty?     #引数が空なら
	>>     "It's an empty string!"
	>>   else　　　　　　　#引数が空出なければ
	>>     "The string is nonempty."
	>>   end
	>> end
	=> :string_message
	>> puts string_message("foobar")　#string_messageメソッドに"foobar"引数で実行
	The string is nonempty.
	>> puts string_message("")#string_messageメソッドに""引数で実行
	It's an empty string!
	>> puts string_message　　　　#引数与えなければデフォルトの引数''で実行
	It's an empty string!
```

###4.3.1 配列と範囲演算子
配列（array）は、特定の順序を持つ要素のリスト

```Ruby
>>  "foo bar baz".split     # 文字列を3つの要素を持つ配列に分割する
=> ["foo", "bar", "baz"]
```

``foo,bar,baz``の3つの文字列からなる配列が得られます。
splitは文字列を区切って配列にするが、
次のように``split('x')``引数を渡して他の文字を指定して区切ることもできる

```Ruby
>> "fooxbarxbaz".split('x')
=> ["foo", "bar", "baz"]
```

####配列の中の番号は1からではなく0から数える

```Ruby
>> a = [42, 8, 17]
=> [42, 8, 17]
>> a[0]               # Rubyでは角カッコで配列にアクセスする
=> 42
>> a[1]
=> 8
>> a[2]
=> 17
>> a[-1]              # 配列の添字はマイナスにもなれる!
=> 17
```

####firstやsecondメソッドでも取り出せる

```Ruby
>> a                  # 配列「a」の内容を確認する
=> [42, 8, 17]
>> a.first
=> 42
>> a.second
=> 8
>> a.last
=> 17
>> a.last == a[-1]    # == を使って比較する
=> true
```

####lengthメソッドで配列の数も返すことができる

```Ruby
>> x = a.length       # 配列も文字列と同様lengthメソッドに応答する
=> 3
>> x == 3
=> true
>> x == 1
=> false
>> x != 1
=> true
>> x >= 1
=> true
>> x < 1
=> false
```

####lengthメソッド以外にも、さまざまなメソッドに応答する

```Ruby
>> 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自身は変更されていない
####配列の内容を変更するには「破壊的メソッド」を使う
破壊的メソッドの名前には、元のメソッドの末尾に「!」を追加する

```Ruby
>> a
=> [42, 8, 17]
>> a.sort!
=> [8, 17, 42]
>> a
=> [8, 17, 42]
```

####pushメソッド（または同等の<<演算子）を使って配列に要素を追加するのも可能

```Ruby
>> a.push(6)                  # 6を配列に追加する
=> [42, 8, 17, 6]
>> a << 7                     # 7を配列に追加する push 7でもOK
=> [42, 8, 17, 6, 7]
>> a << "foo" << "bar"        # 配列に連続して追加する
=> [42, 8, 17, 6, 7, "foo", "bar"]
```

####joinメソッドで配列を一つの文字列にできる→splitの反対
 
```Ruby
>> a
=> [42, 8, 17, 6, 7, "foo", "bar"]
>> a.join                       # 単純に連結する
=> "4281767foobar"
>> a.join(', ')                 # カンマ+スペースを使って連結する
=> "42, 8, 17, 6, 7, foo, bar"
```

####範囲 (a..z)で範囲を作れる
to.aメソッド（to array）は配列にするメソッド　to.aを使う際は()で範囲オブジェクトにする

```Ruby
>> 0..9
=> 0..9
>> 0..9.to_a              # おっと、9に対してto_aを呼んでいるのでエラー　
NoMethodError: undefined method `to_a' for 9:Fixnum
>> (0..9).to_a            # 丸カッコを使い、範囲オブジェクトに対してto_aを呼びましょう
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

####範囲は、配列の要素を取り出すのに便利

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

####インデックスに-1を使うと、配列の長さを知らなくても配列の最後の要素を指定することができる

```Ruby
>> a = (0..9).to_a
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> a[2..(a.length-1)]               # 明示的に配列の長さを使って選択
=> [2, 3, 4, 5, 6, 7, 8, 9]
>> a[2..-1]                         # 添字に-1を使って選択
=> [2, 3, 4, 5, 6, 7, 8, 9]
#次のように、文字列に対しても範囲オブジェクトが使える
>> ('a'..'e').to_a
=> ["a", "b", "c", "d", "e"]
```

###4.3.2 ブロック

- eachメソッドに渡されている{ |i| puts 2 * i }が、ブロックと呼ばれる
- ブロック内|i|はブロックを操作するときに使う変数
- 以下の場合、範囲オブジェクトのeachメソッドは、iという1つの変数を使ってブロックを操作
- 範囲に含まれるそれぞれの値をこの変数に次々に代入してブロックを実行する
- 1..5に対しi(1..5)それぞれに2をかける

```Ruby
>> (1..5).each { |i| puts 2 * i }
2
4
6
8
10
=> 1..5
```

####ブロックはdoとendで囲んで示すこともできる

```Ruby
?>   puts 2 * i
>> end
2
4
6
8
10
=> 1..5
```

####ブロックの中は複数行もOK

```Ruby
>> (1..5).each do |number|
?>   puts 2 * number
>>   puts '--'
>> end
2
--
4
--
6
--
8
--
10
--
=> 1..5
#今度はiの代わりにnumberを使っている  変数名は指定なし
```

####その他の使用例　times,map

```Ruby
>> 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 } #upcaseは大文字にするメソッド
=> ["A", "B", "C"]
>> %w[A B C].map { |char| char.downcase }　#douncaseは小文字にするメソッド
=> ["a", "b", "c"]
```

####&シンボルの使い方もある

```Ruby
>> %w[A B C].map { |char| char.downcase }
=> ["a", "b", "c"]
>> %w[A B C].map(&:downcase) 
=> ["a", "b", "c"]
```

####testもブロックで書かれていた

```Ruby
test "should get home" do
  get static_pages_home_url
  assert_response :success
  assert_select "title", "Ruby on Rails Tutorial Sample App"
end
```

###4.3.3 ハッシュとシンボル

- ハッシュは配列と基本的には同じ
- ハッシュの場合インテックス番号以外のキーを付けれる
- ハッシュは、キーと値のペアを波カッコで囲んで表記します{"last_name"=>"Hartl", "first_name"=>"Michael"}
- キーと値のペアを持たない波カッコの組（{}）は空のハッシュ
- ハッシュの波カッコは、ブロックの波カッコとはまったく別物
- ハッシュは配列との重要な違いはハッシュでは要素の「並び順」が保証されない。もし要素の順序が重要である場合は、配列を使う

```Ruby
>> 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"}
```

####ハッシュロケットと呼ばれる=> によってリテラル表現が一般的

```Ruby
>> user = { "first_name" => "Michael", "last_name" => "Hartl" }
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}
```

####キーは文字列よりシンボルを使う方が一般的
シンボルはコロンが前に置かれている
:nameのように
####シンボルと文字列では使えるメソッドが異なる

```Ruby
>> "name".split('')
=> ["n", "a", "m", "e"]
>> :name.split('')  #シンボルは文字列と違うのでメソッドができない
NoMethodError: undefined method `split' for :name:Symbol
>> "foobar".reverse
=> "raboof"
>> :foobar.reverse　#
NoMethodError: undefined method `reverse' for :foobar:Symbol
```

####ハッシュの実例

```Ruby
>> user = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
>> user[:name]              # :name に対応する値にアクセスする
=> "Michael Hartl"
>> user[:password]          # 未定義のキーに対応する値にアクセスする
=> nil
 #未定義のハッシュ値はniになる
```

####ハッシュは以下のようにも記載可能 (こっちの方が人気)

```
>> 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"}
>> h1 == h2
=> true
```

####ハッシュの中にハッシュを入れることもできる

```
>> 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"
```

#####ハッシュも配列や範囲オブジェクトと同様、eachメソッドに応答
配列のeachメソッドでは、ブロックの変数は1つだけですが、ハッシュのeachメソッドでは、ブロックの変数はキーと値の2つになっている
→ハッシュに対してeachメソッドを実行すると、ハッシュの1つの「キーと値のペア」ごとに処理を繰り返す


```
>> flash = { success: "It worked!", danger: "It failed." }
=> {: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."
```

####シンボルはpメソッドを使うと文字列として表示できる

```
>> p :name             # 'puts :name.inspect' と同じ
:name
```

###4.3.4 CSS、再び
メソッドなどの理解をした上で、CSS（cascading style sheet）に追加した以下行の解説
※CSSがcascading style sheetの略ということを初めて知りました

```
<%= stylesheet_link_tag 'application', media: 'all',
                                       'data-turbolinks-track': 'reload' %>
```

####Rubyでは丸括弧（）を使用しなくてもいい
次の2つの行は等価です。

```
# メソッド呼び出しの丸カッコは省略可能。
stylesheet_link_tag('application', media: 'all',
                                   'data-turbolinks-track': 'reload')
# 上は以下のように書いても同じ
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'
```

大きな目で見るとstylesheet_link_tag（）というメソッドが使われている

####ハッシュがメソッド呼び出しの最後の引数である場合は、波カッコを省略可能
media引数はハッシュのようですが、波カッコがない点が不思議です。実は、ハッシュがメソッド呼び出しの最後の引数である場合は、波カッコを省略できます。次の2つの行は等価です。

```
# 最後の引数がハッシュの場合、波カッコは省略可能。
stylesheet_link_tag 'application', { media: 'all',
                                     'data-turbolinks-track': 'reload' }
# 上は以下のように書いても同じ
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'
```

大きな目で見ると、stylesheet_link_tagの引数は

- application' 第一引数
- {media: 'all','data-turbolinks-track': 'reload'} =第二引数　となる

####Rubyは空白と改行を区別しない

```
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'
```

なので改行して読みやすくしている

まとめると
stylesheet_link_tagメソッドで　第一引数の文字列 ``'application'``はスタイルシートへのパス
第二引数のハッシュ`` media: 'all','data-turbolinks-track': 'reload'``は最初の要素はメディアタイプ、二つ目はturbolinksという機能をオンにしている

ここの部分をHTMLソースとして見るとこうなる

```
<link rel="stylesheet" media="all" href="/assets/application.self-
f0d704deea029cf000697e2c0181ec173a1b474645466ed843eb5ee7bb215794.css?body=1"
data-turbolinks-track="reload" />
```

###クラス

###4.4.1 コンストラクタ
コンストラクタとはなんぞ？と思ったので、調べてみました。
https://wa3.i-3-i.info/word13646.html
https://www.fenet.jp/dotnet/column/language/3861/#i

一言でいうとクラスをnewした瞬間に実行される関数

今までの文字列を""で囲っていた””もリテラルコンストラクタに当たる

```
>> s = "foobar"       # ダブルクォートは実は文字列のコンストラクタ
=> "foobar"      #""でfoobarという文字列のインスタンスを作っていた
>> s.class　　　　#classメソッドで所属するクラスを返す
=> String
```

####クラス名に対してnewメソッドを実行することで名前つきコンストラクタを生成する

```
>> s = String.new("foobar")   # 文字列の名前付きコンストラクタ
=> "foobar"
>> s.class
=> String
>> s == "foobar"
=> true
```

####配列でも、文字列と同様にインスタンスを生成できます。

```
>> a = Array.new([1, 3, 2])
=> [1, 3, 2]
```

####ハッシュの場合

```
>> h = Hash.new
=> {}
>> h[:foo]            # 存在しないキー (:foo) の値にアクセスしてみる
=> nil
>> h = Hash.new(0)    # 存在しないキーのデフォルト値をnilから0にする
=> {}
>> h[:foo]
=> 0
```

Hashと言うクラス自身に対して呼び出されるメソッド（newの部分）=クラスメソッド
Hash.newで呼び出した結果=クラスのオブジェクト、インスタンス
h.lengthのようなインスタンスに対して呼び出すメソッド=インスタンスメソッド

###4.4.2 クラス継承
superclassメソッドを使ってクラス階層を調べられる

```
>> s = String.new("foobar")
=> "foobar"
>> s.class                        # 変数sのクラスを調べる
=> String
>> s.class.superclass             # Stringクラスの親クラスを調べる
=> Object
>> s.class.superclass.superclass  # Ruby 1.9からBasicObjectが導入
=> BasicObject
>> s.class.superclass.superclass.superclass
=> nil
```

`foobar`のクラスは`String`>`Object`>`BasicObject`となる

####クラスについての理解を深めるために自分でクラスを作ってみる
（回文を返すメソッド）

```
>> class Word
>>   def palindrome?(string)
>>     string == string.reverse
>>   end
>> end
=> :palindrome?
```

####wordクラスの使い方

```
>> w = Word.new              # Wordオブジェクトを作成する
=> #<Word:0x22d0b20>
>> w.palindrome?("foobar")
=> false
>> w.palindrome?("level")
=> true
```

####単語は文字列のためStringクラスを継承する（している）

```
>> class Word < String             # WordクラスはStringクラスを継承する
>>   # 文字列が回文であればtrueを返す
>>   def palindrome?
>>     self == self.reverse        # selfは文字列自身を表します
>>   end
>> end
=> :palindrome?
```

####Word < String 記法でStringクラスを継承する。
継承するとStringクラスが扱えるすべてのメソッドがWordクラスでも使える

```
>> s = Word.new("level")    # 新しいWordを作成し、"level" で初期化する
=> "level"
>> s.palindrome?            # Wordが回文かどうかを調べるメソッド
=> true
>> s.length                 # WordはStringで扱える全てのメソッドを継承している
=> 5
```

####WordクラスはStringクラスを継承している

```
>> s.class
=> Word
>> s.class.superclass
=> String
>> s.class.superclass.superclass
=> Object
```
`s`クラスは`Word`<`String`<`Object`クラスを継承している

####selfで自分自身を返すことができる
以下の例ではselfで自分自身を返している 
※s=Word.new(引数）で作ったインスタンス自身の名前を反対にしている

```
>> class Word < String             # WordクラスはStringクラスを継承する
>>   # 文字列が回文であればtrueを返す
>>   def palindrome?
>>     self == self.reverse        # selfは文字列自身を表します
>>   end
>> end
=> :palindrome?
```

`self == self.reverse`
なお、Stringクラスの内部では、メソッドや属性を呼び出すときのself.も省略可能

`self == reverse`
といった省略記法でも、動く

###4.4.3 組み込みクラスの変更
String（文字列）クラス自体にpalindromeメソッドを組み込むことができる
Stringクラスに以下のようにメソッドを追加できる

```
>> class String
>>   # 文字列が回文であればtrueを返す
>>   def palindrome?
>>     self == self.reverse
>>   end
>> end
=> :String
>> "deified".palindrome?
=> true
```

しかしこれはあまりやらない方がいいらしいです。みんなが使うクラスを勝手に変えるのはよくないですもんね。。


###4.4.4 コントローラクラス
クラスはStaticPagesControllerでも既に使われていた

```
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
```


###4.4.5 ユーザークラス
以下のコードを例題に解説

```example_user.rb
class User
  attr_accessor :name, :email

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

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

####アクセサー
`attr_accessor :name, :email`
ユーザー名とメールアドレス（属性: attribute）に対応するアクセサー（accessor） をそれぞれ作成している

アクセサーを作るとインスタンス変数`@name``@email`へアクセスできるメソッドが用意され、インスタンス変数をコントローラー内で作ればビューで使え得るようになる
※データを取り出すメソッド（getter）と、データに代入するメソッド（setter）をそれぞれ定義

####initializeメソッド
User.newを実行すると自動的に呼び出されるメソッドで
次のようにattributesという引数を1つ取る

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

上のコードで、attributes変数は空のハッシュをデフォルトの値として持つため、名前やメールアドレスのないユーザーを作る

###initializeメソッドにハッシュを渡すことで、属性が定義済みの他のユーザを作成することができる

##まとめ
4章ではRubyの基本的な文法や配列、ハッシュなどを学んだ