Ruby Language Digest#

Ruby は行指向型言語です。つまり、改行が一文の区切りとなります。

文末記号としてセミコロン ‘;’ も使えるのですが、一行に複数の文を書きたいのでもない限り必要ありませんし、推奨されてもいません。

 class NoVipError < StandardError ; end

↑セミコロンで文を区切る頻出例。中身のない例外クラスの定義。

なお、C言語と同様に、バックスラッシュを打つことで行を継続させることができますし、メソッド呼び出しの引数も複数行にわたって書くことができます。

どこでなにが複数行にわたっての記述が可能か、ということはおおむねユーザの直感にそぐうように決められているので、問題はないでしょう（C や Perl プログラマなら、この直感はより鋭くなるでしょう）。

コメント#

 #行末までコメントだぜ

シェルスクリプトや Perl や Python と同じです。

 =begin
   RDを書くところ。
 =end

このように、「’=begin’」のみの行から「’=end’」のみの行までの間もコメントとして処理系には無視される。クラスやメソッドの説明をRD(Ruby Document)形式で書くために使われたりする。

変数#

Ruby の変数には型がありません。「すべてがオブジェクト」である Ruby では、変数はそのオブジェクトへの参照です。

Rubyの変数には数種類あり、識別子の先頭で書き分けます。

ローカル変数: local_variable

普通に英数字・アンダーバーで名前を付けます。宣言は代入と同時、宣言されていないローカル変数の参照は NameError 例外を起こします。

 Ruby のローカル変数の宣言と評価順序はびみょーにかみ合ってません。
 パースしていく感じで考えて下さい。

グローバル変数: $global_variable

危険なアイツ。 ‘$’ を先頭につけます。一度も代入せずに参照すると nil を返します。そういう意味でも危険です。’$var’ と間違って ‘$val’ とタイプしてもエラーになりません。

自分で作った変数だと「’$’ が先頭 -> グローバル変数」なのですが、組み込み変数の中には例外(スレッドローカルだったり)があるので注意が必要です。

定数: Constant

大文字で始めると定数にされます。 const や final のようなキーワードはありません。宣言は代入と同時です。宣言されていない定数を参照すると NameError 例外が発生します。この挙動を返るフックは存在しますが後述します。

Ruby の定数の縛りはちょっとゆるく、定数に再代入(初回の代入(=宣言)以降の代入) しても現在はエラーではなく警告が出るだけです。

また、Ruby の変数は前述のとおりオブジェクトへの参照なので、定数とするのも参照です。

 CONST_ARRAY = []
 CONST_ARRAY.push 'hoge'

なので、オブジェクトの操作はし放題です。オブジェクトの変更禁止は別の方法があります。

インスタンス変数: @instance_variable

Ruby で「オブジェクトの状態」を表現するもの。 ‘@’ を先頭に付けます。一度も代入せずに参照すると nil を返します。

メンバー変数とでも言える機能ですが、オブジェクトの外からのアクセスは (リフレクション抜きでは)できません。通常 setter・getter メソッドを定義します。

クラス変数: @@class_variable

名前どおりクラスが持つ変数です。そのクラスと、そのクラスのオブジェクト両方からアクセスできます。さらに、サブクラスに継承されたりします。若干スコープがややこしいです。

‘@@’ を先頭に付けます。一度も代入せずに参照すると NameError 例外が発生します。

リテラル#

Rubyのリテラル表現は豊富です。以下に代表的なものを挙げます。

数値リテラル (Numeric)#

123	整数
4567.89	実数
?a	aの文字コード

文字列リテラル (String)#

“double_quote”	式展開などが解釈されます
‘single_quote’	書いたままになります
`back_quote`	コマンドとして実行し、出力を値とします

 `back_quote` 構文の挙動は、実は Kernel#` というすごい名前のメソッドが
 実現しています。

 式展開とは:
 
   val = 123
   puts "put #{val} value"
 
 このコードを実行すると、出力は
 
   put 123 value
 
 となります。式展開が有効なリテラル中で、#{...} で Ruby の式ならなんでも
 置いてみると、それを評価した値の文字列表現が展開されます。
 
 「式展開が有効なリテラル」と言いましたが、この機能が有効なのはダブルクォート
 文字列に限らず、ヒアドキュメントや正規表現リテラルでも使えたりします。

配列リテラル (Array)#

 [12, "abc", 123.45, some_method()]

カンマで式を区切って並べて要素を指定します。もちろん一つも要素を指定しないで、空の配列を作ることも可能です。

ハッシュリテラル (Hash)#

 { "key" => "value", :KEY => 123 }

「キー => 値」という式のペアを、カンマで区切って指定します。もちろん一つも要素を指定しないで、空のハッシュテーブルを作ることも可能です。

 Ruby 1.9.x feature:
 
   { key1: "value", key2: 123 }
 
 キーが Symbol リテラルの場合、こういった書き方もできます。

シンボルリテラル (Symbol)#

Symbol オブジェクトは、Ruby の識別子の実体でもあるオブジェクトです。処理系に作られるものもあれば String#intern メソッドによって作られるものもあります。

「:ident」のようにリテラルが書けます。「:"hoge"」のように、識別子っぽくない Symbol をリテラルで書くにはクォートします。

ブロック付きメソッド呼び出し#

メソッドに引数としてオブジェクトを渡すのみならず、処理のカタマリ=ブロックを渡すことができます。

 method_name(arg, ...) do |x|
   ...
 end

 method_name(arg, ...){|x|
   ...
 }

のように記述すると、method_name 内でこのブロックを呼び出すことが出来ます。|…| で囲われた部分は、そのブロックが受け取る引数のためのローカル変数です。メソッドの引数のようなものですが、メソッドと違ってブロックからは外側のローカル変数を見ることが出来ます。

ざっくりと言ってしまうと、高階関数に渡すための無名関数のリテラル、と言えます。

 例えば Lisp だと
 
   (mapcar #'(lambda (x) (* x 10)) '(1 2 3))
   ; => (10 20 30)
 
 のようなことが、Ruby では
 
   [1, 2, 3].map{|x| x * 10 }
   # => [10, 20, 30]
 
 と書けます。

 Ruby 1.9.x feature:
 
 ブロック引数の扱いが変わっています。
 
 - 多重代入のような挙動から、メソッド引数のような扱いに変更されています。
 - 外側の環境に同名のローカル変数があるのに、ブロック引数にもその名前を
   使った場合、外側の環境の変数として扱われていたのに対し、新たに
   ブロックローカルな変数が確保されるようになります。
 
 また、ブロックローカル変数宣言が可能になっています。
 
   method_name(arg, ...){|x; a, b|
     ...
   }
 
 これで a や b も、外側のスコープに気兼ねせずに使える名前に
 なります。

ブロックを受け取った側では、yield を使ってブロックを関数呼び出しのように呼び出せます。

 def method_name(arg, ...)
   ...
   block_returning_value = yield(val)
   ...
 end

この機能によって、制御構文のようなメソッドが Ruby にはいろいろあります。

Rubyの真偽評価#

以下に述べる条件分岐などで、Ruby の値(=オブシェクト)がどのように真偽評価されるかを説明します。

結論から言うと、Ruby における偽とは false と nil であり、それ以外のあらゆるオブジェクトは真です。

明示的に真を表す代表的な値に true があります。

これら(true, false, nil)はそれぞれ TrueClass, FalseClass, NilClass の唯一のインスタンスです。

制御構造#

条件分岐#

if 文, if 修飾子

 if EXPR then ... end
 
 if EXPR [then]
   ...
 end
 
 ... if EXPR

EXPR を評価して真ならば、… を実行する。複数行に分けて書くならば(改行で区切りが明確なので) then は省略可能です。

 if EXPR1
   ... # (A)
 elsif EXPR2
   ... # (B)
 else
   ... # (C)
 end

EXPR1 を評価して真ならば (A) を実行して終わりますが、そうでない場合、 EXPR2 を評価して真ならば (B) を実行します。こうした elsif 部の条件式も全部偽だった場合、(C) の else 部を実行します。

0 個以上の elsif 部の後に 0 ～ 1 個の else 部が書けます。

unless 文, unless 修飾子

if に似た文法をとりますが、unless は条件式の評価基準が逆です。

 ... unless EXPR

は、EXPR の評価が偽のときだけ … を実行しますし、

 unless EXPR
   ... (A)
 else
   ... (B)
 end

は、EXPR の評価が真ならば (A) を実行し、そうでなければ (B) を実行します。ただ、if における elsif に相当するパートはありません。

繰り返し#

Ruby における繰り返し(ループ)のための文とは、

while
until
for
イテレータ

です。以下これら総称してただ単にループと呼びます。

while 文

 while COND [do]
   ...
 end

COND の評価が真である限り、中の文を実行します。do は省略可能です。

until 文

 until COND [do]
   ...
 end

while - until は if - unless の関係に対応し、COND の評価が偽である限り、
中の文を実行します。: for 文

 for IDENT in LIST_EXPR
   ...
 end

Ruby の for 文は C などのものと違い、シェルスクリプトや Perl の foreach に近いです。これは、配列のように複数の要素の集合である LIST_EXPR(の評価結果)に対して、その各要素を IDENT という変数に取り出して順次処理していくときに使われます。

in の後にとるオブジェクトには、each というメソッドがイテレータ(後述)として実装されている必要があります。 for 文は内部でこのメソッドを呼んでいます。

イテレータ: 例: Array#each

 array = [1, 2, 3, 4, 5]
 array.each do |x|
   p x  #=> 1, 2, 3, 4, 5
 end

ブロック付きメソッド呼び出しで、「要素に対しての繰り返し」を隠蔽して実装しています。

 loop do
   ...
 end

のように、一見制御構造のようなイテレータから、

 1.upto(10) do |x|
   p x  #=>1, 2, 3, ..., 9, 10
 end

のように、用途が特化した便利なイテレータもあります。

 元々 Ruby のブロック付きメソッド呼び出し機能は、このようなイテレータメソッド
 を実装する狙いで、CLU という言語を参考にしたものです。
 そうした歴史的経緯から、ちょっと前の文書だと
 「ブロック付きメソッド呼び出しのブロック」ぐらいの意味で「イテレータ」という
 言葉が使われていたりします。

break, next, redo, retry

ループ内でのフロー制御文です。

break: 現在のループから脱出します。
next: 現在のループの、現在の回の残りの文を飛ばして、次の繰り返しに移ります。
redo: 現在のループの、現在の回の繰り返しをまた初めからやり直します。
retry: 現在のループを始めからやり直します。

例外処理#

 begin
   ...  # (A)
 rescue ExClass => ex
   ...  # (B)
 else
   ...  # (C)
 ensure
   ...  # (D)
 end

(A) 内で起きた例外を rescue で捕捉します。

捕捉する例外クラス ExClass を指定して、変数 ex で実際に捕捉した例外オブジェクトを参照します。「rescue => ex」、「rescue ExClass」のように両者とも省略可能です。ExClass が省略された場合は StandardError が指定されたものとして処理されます。 rescue 節は、発生した例外のクラスが ExClass、またはそのサブクラスの場合にその例外を捕捉します。

並べた rescue 節がひとつも実行されなかった場合、(C) の else 部が実行されます。

そして最後に、例外が起きようが起きまいが、どの rescue 節あるいは else 節が実行されようがされまいが、必ず締めに実行されるのが (D) の ensure 節です。

1 個以上の rescue 節のあとに 0 ～ 1 個の else 節が書けます。そのあとに 0 ～ 1 個の ensure 節が書けます。

クラス定義#

せっかくのオブジェクト指向言語ですから、クラスの作り方をば。

 class ClassName < SuperClass
   ...
 end

「< SuperClass」は名の通り継承するクラスを指定します。省略すると自動的に Object クラスを継承します。評価すればスーパークラスを返す式ならば置けます。

ClassNameは大文字で始める必要があります。定数と同じです(というか、まんま定数なのですが)。

定義したクラスのインスタンスは obj = ClassName.new() のカタチで作れます。カタチを見て判るとおり、new は予約語ではなくメソッド名で、普通に変数名とかにも使えます。

生成したクラスを初期化したい場合、C++ や Java でいうコンストラクタのようなものを定義します。class … end 内で定義される initialize() というメソッドがそれです。new は自分の引数を initialize に丸投げします。

クラスと似たようなものにモジュールがあります。

 module ModuleName
   ...
 end

モジュールはクラスと違って継承できず、インスタンスも持てません。

しかし、include によってそのモジュールで定義した機能をクラス定義中に取り込むことができます(Mix-In)。

メソッド可視性の制御#

 class ClassName
   public
   ...  # (A)
   private
   ...  # (B)
   protected
   ...  # (C)
 end

C++ や Java と語彙が一緒なので誤用されていることがたまにあります。

(A) で定義されたメソッドは public で、どこからでも呼べます。

(B) で定義されたメソッドは private で、そのオブジェクト自身のコンテキストでしか呼べません。

Ruby のメソッド呼び出し制御の着眼点は、「レシーバ.メソッド」という形で呼び出すかどうか、に集約されます。

 class Hoge
   def initialize
     priv       # これはOK
     self.priv  # NoMethodError
   end
   
   private
   
   def priv
     ...
   end
 end

同じコンテキストですらこうです。

それから、いくら private にしようがリフレクションでどうにでもなるゆるゆるな制御なので、あてにし過ぎるのは止してください。

attr系メソッド – アクセサ定義#

「変数」の節で

 メンバー変数とでも言える機能ですが、オブジェクトの外からのアクセスは
 (リフレクション抜きでは)できません。
 通常 setter・getter メソッドを定義します。

と述べました。

さて、その setter と getter ですが、set_member(val), get_member() のようなネーミングは Ruby では一般的ではありません。

 obj.member = 123
 obj.member

あたかも属性のように、こう書きたいものです。そして Ruby では実際にこのような書き方が出来ます。Ruby パーサは、前者を member=() という名前のメソッド呼び出しと解釈してくれるからです。

 class C
   def member
     @member
   end
   
   def member=(val)
     @member = val
   end
 end

これで、インスタンス変数をメソッドで属性のように扱えます。定義する際においては他のメソッドとなんら変わりなく、代入値のチェックなども自分で勝手に書けます。

ただ、そういった独自処理もしないのにいちいち上記のような setter・getter を手で書くのは煩雑です。なのでこれに等しい処理は

 class C
   attr_accessor :member
 end

で可能です。

attr_reader: getter を定義
attr_writer: setter を定義
attr_accessor: 両方を定義

 特別な構文のように見えますが、実はリフレクションを駆使して定型処理を便利に
 まとめた 1 メソッドに過ぎません。
 
   def my_attr_reader(name)
     define_method(name){ instance_variable_get("@#{name}") }
   end
   
   def my_attr_writer(name)
     define_method("#{name}="){|val| instance_variable_set("@#{name}", val) }
   end
 
 最低限、こんな感じで自分でも実装できます。