付録：Ruby 言語の早わかり

• 大項目のみ
• 中項目まで

　　　　説明：この文書は、「Ruby は初めてだが他の言語でのプログラミング
　　　　　　　経験はある」という技術者向けのものである。
　　　　　　　Ruby のすべてを説明するものではないが、プログラミング経験者
　　　　　　　の立場から、最低限必要だと思われる情報を網羅している。

　　　　書式：print( aaa, bbb, ccc, ... )
　　　　例文：print( "ruby ver", "1.8.4" )
　　　　補足：自動改行しないので、改行したいときは "�n" を使うこと

　　　　書式：puts( aaa, bbb, ccc, ... )
　　　　例文：puts( "ruby", "ver 1.8.4" )
　　　　補足：各引数ごとに自動改行する

　　　　書式：p aaa
　　　　説明：プログラマ向け。デバッグ時のオブジェクトの内容確認用

　　　　書式：pp aaa
　　　　説明：プログラマ向け。デバッグ時のオブジェクトの内容確認用
　　　　補足：プログラムの先頭に require 'pp' を記述すること

　　　　例文：12　　　（10進数）
　　　　例文：012　　（８進数）
　　　　例文：0x12　　（16進数）
　　　　例文：0d12　　（10進数）
　　　　例文：0b0101　（２進数）
　　　　例文：12_345
　　　　例文：0x1234_5678
　　　　補足：整数は、Integer クラスのオブジェクト（インスタンス）
　　　　　　　下線は無視するので、見やすいように適宜付けてよい。

　　　　例文： 12.3456
　　　　例文： 7.89e12
　　　　補足：実数は、Float クラスのオブジェクト（インスタンス）

　　　　概要：ダブルクオートで囲む
　　　　例文： "ruby�n"
　　　　例文： "vars: #{var} #{$gvar} #{@ivar} "
　　　　補足：バックスラッシュはメタキャラクタ
　　　　補足： #{変数名} で展開。式でもよい。
　　　　補足：文字列は、String クラスのオブジェクト（インスタンス）

　　　　概要：シングルクオートで囲む
　　　　例文： 'ruby'
　　　　補足：バックスラッシュは下記の場合のみメタキャラクタ
　　　　　　　　・バックスラッシュ自体を表す場合（ �� ）
　　　　　　　　・シングルクオート自体を表す場合（ �' ）
　　　　補足：文字列は、String クラスのオブジェクト（インスタンス）

　　　　概要：ヒアドキュメント
　　　　書式１： << "EOS"
　　　　書式２： << 'EOS'
　　　　補足： <<- で、EOS の行頭の制限を緩和し、空白タブを容認する
　　　　補足：文字列は、String クラスのオブジェクト（インスタンス）
　　　　注意：aaa << "bbb" は、aaa に "bbb" を追加する。
　　　　　　　aaa = << "bbb" が、ヒアドキュメントでの代入。

　　　　概要：コロンを前置する
　　　　例文： :client
　　　　補足：シンボルは、Symbol クラスのオブジェクト（インスタンス）
　　　　注意：構文上の曖昧さを回避するためには、三項演算子（?:）の
　　　　　　　コロンの両側には空白が必要

　　　　概要：要素をカンマで区切り、全体を[]で囲む
　　　　例文： [ "aaa", "bbb", "ccc" ]
　　　　例文：　[ ]
　　　　説明：後者の例文は要素が何もない、空の配列を表す。
　　　　　　　要素のデータ型は何でもよく、混在してもよい。
　　　　補足：配列は、Array クラスのオブジェクト（インスタンス）

　　　　概要：キーと値のペア（キー => 値）をカンマで区切り、全体を{}で囲む
　　　　例文： { "xxx" => "aaa", "yyy" => "bbb" }
　　　　補足：ハッシュは、Hash クラスのオブジェクト（インスタンス）
　　　　補足：Ruby ではハッシュと呼んでいるが、他の言語では
　　　　　　　連想配列や辞書（ディクショナリ）とも呼ばれている。

　　　　書式： /pattern/
　　　　補足：正規表現は、Regexp クラスのオブジェクト（インスタンス）

　　　　書式： n..m
　　　　書式： n...m
　　　　説明：前者は n以上、m以下
　　　　　　　後者は n以上、m未満
　　　　補足：範囲は、Range クラスのオブジェクト（インスタンス）

　　　　説明：変数名の先頭が英小文字または下線のもの
　　　　例文： num01 = 0
　　　　補足：事前の宣言は不要。最初の代入文が宣言を兼ねる
　　　　注意：イテレータブロックとの絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　説明：変数名の先頭が $ のもの
　　　　例文： $ary02 = [ "aaa", "bbb" ]
　　　　補足：事前の宣言は不要。最初の代入文が宣言を兼ねる

　　　　説明：変数名の先頭が @ のもの
　　　　例文： @str03 = "ccc"
　　　　補足：事前の宣言は不要。最初の代入文が宣言を兼ねる
　　　　補足：インスタンス変数を直接操作できるのは、当該クラスと
　　　　　　　その継承クラスのみ

　　　　説明：変数名の先頭が @@ のもの
　　　　例文： @@val04 = 256
　　　　補足：事前の宣言は不要。最初の代入文が宣言を兼ねる
　　　　補足：クラス変数を直接操作できるのは、当該クラスとその継承クラスのみ

　　　　説明：Ruby の組み込み変数的なもの。ユーザ定義不可
　　　　　　　nil    ← NilClass の唯一のインスタンスオブジェクト
　　　　　　　true   ← TrueClass の唯一のインスタンスオブジェクト
　　　　　　　false  ← FalseClass の唯一のインスタンスオブジェクト
　　　　　　　self
　　　　　　　__FILE__ ソースファイル名
　　　　　　　__LINE__ ソースファイル上の行番号

　　　　説明：変数名の先頭が英大文字のもの
　　　　例文：MAX_LENGTH = 4096
　　　　補足：クラス内で定義すると、クラススコープの定数となる
　　　　補足：クラス定数を外部から参照するには、「クラス名::定数名」と書く

　　　　BEGIN END
　　　　alias and begin break case class def defined? do
　　　　else elsif end ensure false for if in module
　　　　next nil not or redo rescue retry return
　　　　self super then true indef unless until
　　　　when while yield __FILE__ __LINE__

　　　　nil は NilClass の唯一のインスタンスオブジェクトである。
　　　　true は TrueClass の唯一のインスタンスオブジェクトである。
　　　　false は FalseClass の唯一のインスタンスオブジェクトである。

　　　　説明：Ruby では、文字列は単なるバイト列である。
　　　　　　　$KCODE にてデフォルトの符号化方法を指定する。
　　　　　　　正規表現には符号化方法を指定するオプションがある。
　　　　注意：Ver 1.9 とそれ以降は、このへんの扱いが大きく変わった。

　　　　説明：GC との絡みがあるので、文字列の無闇な追加変更処理には
　　　　　　　注意が必要。
　　　　　　　ひとつの文字列変数に次々と別の文字列を追加していくような
　　　　　　　処理をする場合、そのままでは GC のオーバーヘッドが心配。
　　　　　　　こういうときは、文字列をそのまま使うのではなく配列を使う。
　　　　　　　配列に次々と文字列を追加していき、最後に join()でまとめて
　　　　　　　しまえばいい。

　　　　書式：前述の「データ型（リテラル値の表現方法）」を参照

　　　　書式：[添字]
　　　　例文：ddd = [ "aaa", "bbb", "ccc" ]
　　　　　　　print( ddd[0] )
　　　　　　　eee = ddd[2]
　　　　　　　fff = ddd[6]
　　　　　　　ddd[1] = "ggg"
　　　　　　　ddd[7] = "hhh"
　　　　　　　ddd[5,0] = "iii"
　　　　　　　xxx = ddd[1..2]
　　　　　　　yyy = ddd[1...4]
　　　　　　　zzz = ddd[1,3]
　　　　補足：添字は 0 から始まる
　　　　補足：「添字」と訳さずに「インデックス」とも呼ぶ
　　　　補足：例文の print の結果は aaa となる
　　　　補足：例文の変数 eee の内容は "ccc" となる
　　　　補足：例文の変数 fff の内容は nil となる。
　　　　　　　nil は NilClass の唯一のインスタンスオブジェクトである。
　　　　補足：例文の変数 ddd の ２番目の要素が "bbb" から "ggg" に変わる
　　　　補足：例文の変数 ddd の８番目に "hhh" が入り、
　　　　　　　４〜７番目は nil になる。
　　　　　　　nil は NilClass の唯一のインスタンスオブジェクトである。
　　　　補足：例文の変数 ddd の５番目と６番目のあいだに "iii" を挿入する。
　　　　補足：例文の変数 xxx は、要素数２個の配列となる。
　　　　　　　n..m で、n以上 m以下となる。
　　　　補足：例文の変数 yyy は、要素数３個の配列となる。
　　　　　　　n...m で、n以上 m未満となる。
　　　　補足：例文の変数 zzz は、要素数３個の配列となる。
　　　　　　　n,m で、nから m個分となる。
　　　　補足：添字の値が負のとき、配列の最後尾からの番号となる。
　　　　　　　-1 のときは配列の最後の要素を表す。

　　　　書式：size()
　　　　例文：ddd = [ "aaa", "bbb", "ccc" ]
　　　　　　　print( ddd.size() )
　　　　補足：例文の print の結果は 3 となる

　　　　書式：each() { |仮変数| 処理 }
　　　　書式：each() do |仮変数| 処理 end
　　　　説明：仮変数は、配列の各要素を表す。
　　　　例文：ddd = [ "aaa", "bbb", "ccc" ]
　　　　　　　ddd.each() do |v|
　　　　　　　　　print( v, "�n" )
　　　　　　　end
　　　　補足：例文の結果は下記の３行を出力する。
　　　　　　　　　aaa
　　　　　　　　　bbb
　　　　　　　　　ccc
　　　　補足：「{」および「do」は、each と同じ行に記述せねばならない
　　　　補足：each は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である。他にも多数あり。
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：each_with_index() { |仮変数,仮インデックス| 処理 }
　　　　書式：each_with_index() do |仮変数,仮インデックス| 処理 end
　　　　説明：仮インデックスは、配列のインデックスを表す。

　　　　書式：aaa << bbb　　　　　　末尾に追加
　　　　書式：aaa.push( bbb )　　　末尾に追加
　　　　書式：ccc = aaa.pop()　　　末尾を取る
　　　　書式：aaa.unshift( bbb )　　先頭に追加
　　　　書式：ccc = aaa.shift()　　　先頭を取る

　　　　書式：前述の「データ型（リテラル値の表現方法）」を参照

　　　　書式：[キー]
　　　　例文：ddd = { "xxx" => "aaa", "yyy" => "bbb" }
　　　　　　　print( ddd["xxx"] )
　　　　　　　eee = ddd["yyy"]
　　　　　　　ddd["xxx"] = "fff"
　　　　　　　ddd["zzz"] = "ggg"
　　　　補足：例文の print の結果は aaa となる
　　　　補足：例文の変数 eee の内容は "bbb" となる
　　　　補足：例文の変数 ddd のキー "xxx" に対応する値が
　　　　　　　"aaa" から "fff" に変わる
　　　　補足：例文の変数 ddd に、キー "zzz" とそれに対応
　　　　　　　する値 "ggg" が追加される

　　　　書式：each() { |キー用の仮変数, 値用の仮変数| 処理 }
　　　　書式：each() do |キー用の仮変数, 値用の仮変数| 処理 end
　　　　説明：仮変数は、ハッシュの各要素を表す。
　　　　例文：ddd = { "xxx" => "aaa", "yyy" => "bbb" }
　　　　　　　ddd.each() do |k,v|
　　　　　　　　　print( k, " => ", v, "�n" )
　　　　　　　end
　　　　補足：例文の結果は下記の２行を出力する。
　　　　　　　　　xxx => aaa
　　　　　　　　　yyy => bbb
　　　　補足：「{」および「do」は、each と同じ行に記述せねばならない
　　　　補足：each は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である。他にも多数あり。
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　例文： a + b
　　　　補足：両辺のデータ型が文字列のときは、連結した文字列を返す。
　　　　補足：文字列を数値として扱うときは、to_i メソッドで数値に。

　　　　例文： a - b

　　　　例文： a * b
　　　　補足：和と差よりも演算の優先順位が高い

　　　　例文： a / b
　　　　補足：和と差よりも演算の優先順位が高い

　　　　書式： sin(aaa)
　　　　書式： Math.sin(aaa)
　　　　補足：前者の書式の場合、プログラムの最初に下記が必要
　　　　　　　　include Math
　　　　補足：この include は、C言語等での #include とは違う。
　　　　　　　Ruby では、モジュール名を省略するために使う。
　　　　　　　Java の import に相当。
　　　　　　　C言語等での #include に似たものとしては require がある

　　　　書式： sqrt(aaa)
　　　　書式： Math.sqrt(aaa)
　　　　補足：前者の書式の場合、プログラムの最初に下記が必要
　　　　　　　　include Math
　　　　補足：この include は、C言語等での #include とは違う。
　　　　　　　Ruby では、モジュール名を省略するために使う。
　　　　　　　Java の import に相当。
　　　　　　　C言語等での #include に似たものとしては require がある

　　　　書式： a == b
　　　　説明：演算結果として、true または false のどちらかを返す。
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。
　　　　補足：数値および文字列で使える。
　　　　補足：同じ値でも、整数と実数を区別するときは eq?() メソッド。
　　　　補足：同じオブジェクトかどうかを判定するには equal?() メソッド。
　　　　補足： === という演算子もある。後述

　　　　書式： a != b
　　　　説明：演算結果として、true または false のどちらかを返す
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。
　　　　補足：数値および文字列で使える

　　　　書式： a < b
　　　　説明：演算結果として、true または false のどちらかを返す
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。

　　　　書式： a > b
　　　　説明：演算結果として、true または false のどちらかを返す
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。

　　　　書式： a <= b
　　　　説明：演算結果として、true または false のどちらかを返す
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。

　　　　書式： a <= b
　　　　説明：演算結果として、true または false のどちらかを返す
　　　　　　　Ruby では、true は 1 とは違う。
　　　　　　　Ruby では、false は 0 ではないし、nil とも違う。

　　　　書式： /ppp/ =~ aaa
　　　　　　　 /ppp/i =~ aaa
　　　　説明：マッチしたときは、その文字位置を返す。
　　　　　　　マッチしなかったときは、nil を返す。
　　　　　　　書式の後者の場合、大文字と小文字の違いを無視する

　　　　書式： aaa === bbb
　　　　説明：左辺が数値または文字列のときは、== と同じ。
　　　　　　　左辺がクラス名のときは、右辺もそのクラスのときに真。
　　　　　　　左辺が正規表現のときは、=~ と同じ。

　　　　書式： aaa <=> bbb
　　　　説明：両辺の大小により、-1、0、1 のいずれかを返す

　　　　書式： 条件 && 条件
　　　　説明：双方の条件が真のときだけ true を返す。
　　　　例文： 1 <= aaa && aaa <= 9
　　　　例文： b = arrayData && arrayData[0]
　　　　補足：C/C++/Java と同様の挙動をする。
　　　　　　　評価順序は左側から。左側が偽なら、右側は実行しない。

　　　　書式： 条件 || 条件
　　　　説明：双方のどちらかの条件が真であれば true を返す。
　　　　例文： aaa < 1 || 9 < aaa
　　　　例文： b ||= "xyz"  # b が nil か false なら "xyz" を代入
　　　　補足：C/C++/Java と同様の挙動をする。
　　　　　　　評価順序は左側から。左側が真なら、右側は実行しない。

　　　　書式： ! 条件
　　　　説明：条件が真のときは false を返し、偽のときは true を返す。
　　　　補足：場合によっては、これを使わずに、もともとの条件の意味を
　　　　　　　逆にするほうがよい場合もある。

　　　　説明： && と同じ
　　　　補足：演算の優先順位は && よりも低い（どの演算子よりも低い）

　　　　説明： || と同じ
　　　　補足：演算の優先順位は || よりも低い（どの演算子よりも低い）

　　　　説明： ! と同じ
　　　　補足：演算の優先順位は ! よりも低い（and,orの次に低い）

　　　　説明：C/C++/Java と同じ。
　　　　注意：適切に空白を入れること。演算子の両側に空白を入れるべき。
　　　　　　　  xxx? yy :zz
　　　　　　　上記のように空白がないと、xxx? がメソッド名、zz がシンボルと
　　　　　　　解釈されてしまう。

　　　　書式： #
　　　　説明： # 以降、行末までがコメント（注釈）となる

　　　　書式：=begin
　　　　書式：=end
　　　　説明：前者の書式から後者の書式までコメント（注釈）となる。
　　　　　　　どちらも行頭に記述すること。

　　　　書式：if 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　end
　　　　補足：then は省略可
　　　　補足：条件式の結果が nil または false のときだけ偽、
　　　　　　　それ以外は真となる。
　　　　　　　Ruby では、数値の 0 は nil でも false でもないので真。

　　　　書式：if 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　else
　　　　　　　　　処理
　　　　　　　end
　　　　補足：then は省略可
　　　　補足：条件式の結果が nil または false のときだけ偽、
　　　　　　　それ以外は真となる。
　　　　　　　Ruby では、数値の 0 は nil でも false でもないので真。

　　　　書式：if 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　elsif 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　else
　　　　　　　　　処理
　　　　　　　end
　　　　補足：then は省略可
　　　　　　　「elsif 条件 then 処理」は複数指定可
　　　　補足：条件式の結果が nil または false のときだけ偽、
　　　　　　　それ以外は真となる。
　　　　　　　Ruby では、数値の 0 は nil でも false でもないので真。

　　　　書式：unless 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　end
　　　　説明：if ! ( 条件 ) と同じ。条件の意味が逆になる
　　　　補足：then は省略可

　　　　書式：unless 条件
　　　　　　　then
　　　　　　　　　処理
　　　　　　　else
　　　　　　　　　処理
　　　　　　　end
　　　　説明：if ! ( 条件 ) と同じ。条件の意味が if の逆になる
　　　　補足：then は省略可

　　　　書式：case 変数または演算式
　　　　　　　when 値 then
　　　　　　　　　処理
　　　　　　　when 値 then
　　　　　　　　　処理
　　　　　　　when 値 then
　　　　　　　　　処理
　　　　　　　else
　　　　　　　　　処理
　　　　　　　end
　　　　補足：then は省略可
　　　　　　　「when 値 then 処理」は複数指定可。
　　　　　　　値はカンマで区切って複数指定可
　　　　補足：値には数値、文字列、クラス名、正規表現が指定可。式も可♪
　　　　　　　値の比較は、=== によっておこなわれる

　　　　書式：while 条件 do
　　　　　　　　　処理
　　　　　　　end
　　　　補足：do は省略可。付ける場合は while と同じ行に記述せねばならない
　　　　補足：繰り返し制御には、break/next/redo を使う。後述

　　　　書式：until 条件 do
　　　　　　　　　処理
　　　　　　　end
　　　　説明：while ! ( 条件 ) と同じ。条件の意味が while の逆になる
　　　　補足：do は省略可。付ける場合は until と同じ行に記述せねばならない
　　　　補足：繰り返し制御には、break/next/redo を使う。後述

　　　　書式：for 仮変数 in 初期値..終了値 do
　　　　　　　　　処理
　　　　　　　end
　　　　書式：for 仮変数 in 配列 do
　　　　　　　　　処理
　　　　　　　end
　　　　書式：for 仮変数 in 範囲オブジェクト do
　　　　　　　　　処理
　　　　　　　end
　　　　例文：for i in 1..cnt do
　　　　　　　　　puts( i )
　　　　　　　end
　　　　説明：最初の書式では、仮変数は初期値から終了値までの値を順に持つ。
　　　　　　　２番目の書式では、仮変数は配列の各要素を順に持つ。
　　　　　　　３番目の書式が本来の一般形。
　　　　補足：do は省略可。付ける場合は for と同じ行に記述せねばならない
　　　　補足：繰り返し制御には、break/next/redo を使う。後述

　　　　書式：loop() do 処理 end
　　　　書式：loop() { 処理 }
　　　　補足：繰り返し制御には、break/next/redo が使える？
　　　　補足：「{」および「do」は、loop と同じ行に記述せねばならない
　　　　補足：loop は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：aaa.times() { 処理 }
　　　　書式：aaa.times() do 処理 end
　　　　書式：aaa.times() { |仮変数| 処理 }
　　　　書式：aaa.times() do |仮変数| 処理 end
　　　　説明：aaaは整数または整数型変数。
　　　　　　　回数が必要なときは仮変数を指定する（値は 0 から始まる）
　　　　補足：繰り返し制御には、break/next/redo が使える？
　　　　補足：「{」および「do」は、times と同じ行に記述せねばならない
　　　　補足：times は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：aaa.upto( 最終値 ) { |仮変数| 処理 }
　　　　書式：aaa.upto( 最終値 ) do |仮変数| 処理 end
　　　　説明：aaaは整数または整数型変数。aaaから最終値まで繰り返す。
　　　　　　　「aaa <= 最終値」であること。
　　　　補足：繰り返し制御には、break/next/redo が使える？
　　　　補足：「{」および「do」は、upto と同じ行に記述せねばならない
　　　　補足：upto は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：aaa.downto( 最終値 ) { |仮変数| 処理 }
　　　　書式：aaa.downto( 最終値 ) do |仮変数| 処理 end
　　　　説明：aaaは整数または整数型変数。aaaから最終値まで繰り返す。
　　　　　　　「最終値 <= aaa」であること。
　　　　補足：繰り返し制御には、break/next/redo が使える？
　　　　補足：「{」および「do」は、downto と同じ行に記述せねばならない
　　　　補足：downto は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：aaa.step( 最終値,増分 ) { |仮変数| 処理 }
　　　　書式：aaa.step( 最終値,増分 ) do |仮変数| 処理 end
　　　　説明：aaaは整数または整数型変数。aaaから最終値まで繰り返す。
　　　　　　　増分が正のときは、「aaa <= 最終値」であること。
　　　　　　　増分が負のときは、「最終値 <= aaa」であること。
　　　　補足：繰り返し制御には、break/next/redo が使える？
　　　　補足：「{」および「do」は、step と同じ行に記述せねばならない
　　　　補足：step は、Ruby ではイテレータまたはブロック付きメソッドと
　　　　　　　呼んでいるものの一種である
　　　　注意：ブロック記述の「{}」と「do/end」とでは、挙動が微妙に
　　　　　　　異なる場合がある。
　　　　注意：イテレータブロックとローカル変数の絡みに注意。
　　　　　　　詳細は後述のイテレータブロックの項目を参照。

　　　　書式：break
　　　　書式：break if 条件
　　　　書式：break unless 条件
　　　　説明：繰り返しを中断し抜ける
　　　　説明：if/unless を修飾子として指定可

　　　　書式：next
　　　　書式：next if 条件
　　　　書式：next unless 条件
　　　　説明：現時点の繰り返し処理を飛ばして、次回の繰り返しへ進む
　　　　説明：if/unless を修飾子として指定可
　　　　補足：C言語やJavaの continue と同じ

　　　　書式：redo
　　　　書式：redo if 条件
　　　　書式：redo unless 条件
　　　　説明：現時点の繰り返し処理を再度繰り返す
　　　　説明：if/unless を修飾子として指定可

　　　　書式：retry
　　　　書式：retry if 条件
　　　　書式：retry unless 条件
　　　　説明：ループを初期値からやり直す。
　　　　　　　事実上、for ループでしか使う意味がない。
　　　　補足：rescue 節の中で使うと、再度 begin から実行する。

　　　　書式：def iter( 引数, 引数, ... )
　　　　　　　　　if block_given?
　　　　　　　　　　　yield( ブロックに渡す値, ...　)
　　　　　　　　　end
　　　　　　　end
　　　　書式：def iter( 引数, ..., &ブロック用引数 )
　　　　　　　　　ブロック用引数.call( ブロックに渡す値, ...　)
　　　　　　　end
　　　　説明：ブロック用引数は、Proc クラスのオブジェクト

　　　　例文１：File.open("trap") do |f|
　　　　　　　　　　buf = f.read
　　　　　　　　end
　　　　　　　　puts buf
　　　　例文２：if $0 == "---"
　　　　　　　　　　buf = 123
　　　　　　　　end
　　　　　　　　File.open("trap") do |f|
　　　　　　　　　　buf = f.read
　　　　　　　　end
　　　　　　　　puts buf
　　　　説明：例文１は、puts の位置で（bufが未定義）エラーになる。
　　　　　　　buf は、イテレータブロック内で最初に表れている。
　　　　　　　このとき、buf はブロック内でのみ有効な変数となる。
　　　　　　　例文２は、正常に動作する。
　　　　　　　このとき、buf = 123 の処理をしたかどうかは関係ないし、
　　　　　　　違うデータ型でも問題ない。
　　　　　　　ここで重要なのは、イテレータブロックよりも前に同じ名前
　　　　　　　のローカル変数が存在する可能性があるかどうかだけ。
　　　　　　　このように、イテレータブロックとローカル変数のあいだには
　　　　　　　微妙な関係がある。
　　　　補足：for/whileはイテレータブロックではないので、このような
　　　　　　　問題は起きない。

　　　　書式：def メソッド名( 引数, 引数, ... )
　　　　　　　　　処理
　　　　　　　end
　　　　補足：引数のデフォルト値を、「引数=値」という形で指定できる。
　　　　　　　デフォルト値のある引数は、このメソッドの呼び出し時に、
　　　　　　　その引数の指定を省略してもよい。
　　　　補足：引数が何もないときは、メソッド名の後の括弧を省略してもよい
　　　　補足：引数の個数が可変のときは、その可変となる引数以降については
　　　　　　　「*引数」と記述する。
　　　　　　　このとき、この引数は配列になり、実際の引数はその要素となる。
　　　　補足：クラスのインスタンスメソッドやクラスメソッドを定義したいときは、
　　　　　　　クラス定義の中でメソッド定義する
　　　　補足：マニュアル等で、インスタンスメソッドとクラスメソッドを区別
　　　　　　　するために、下記のような表記をすることがある。
　　　　　　　　　Aaa#xxx　　クラス Aaa のインスタンスメソッド xxx
　　　　　　　　　Aaa.yyy　　クラス Aaa のクラスメソッド yyy
　　　　　　　　　Aaa::zzz 　クラス Aaa のクラスメソッド zzz

　　　　書式：なし
　　　　書式：return 値
　　　　説明：前者の書式のように、return がないときは、そのメソッドの
　　　　　　　最後に実行した処理の結果の値が戻り値となる。
　　　　補足：値を指定せずに return を記述すると、nil を返す。

　　　　書式１：メソッド名( 引数, 引数, ... )
　　　　書式２：インスタンス.メソッド名( 引数, 引数, ... )
　　　　書式３：クラス名.メソッド名( 引数, 引数, ... )
　　　　書式４：クラス名::メソッド名( 引数, 引数, ... )
　　　　例文１： meth( "ruby", 1 )
　　　　例文２： iob.size()
　　　　例文３： Array.new
　　　　例文４： Array::new
　　　　補足：引数がないときは、例文３のように括弧を省略してもよい
　　　　補足：引数があるときでも、括弧だけは省略してもよい場合があるが、
　　　　　　　見つけにくい不具合の元になることがあるので、
　　　　　　　括弧を省略せずに付けていたほうが無難
　　　　補足：引数で「*配列名」と記述すると、配列の各要素が引数となる。
　　　　補足：マニュアル等で、インスタンスメソッドとクラスメソッドを区別
　　　　　　　するために、下記のような表記をすることがある。
　　　　　　　　　Aaa#xxx　　クラス Aaa のインスタンスメソッド xxx
　　　　　　　　　Aaa.yyy　　クラス Aaa のクラスメソッド yyy
　　　　　　　　　Aaa::zzz 　クラス Aaa のクラスメソッド zzz

　　　　書式：new()
　　　　説明：指定クラスのオブジェクト（インスタンス）を生成し、
　　　　　　　そのクラスの initialize メソッドを呼び出す。
　　　　補足：new はクラス毎にいろいろな引数を持ったものがある。
　　　　　　　一般的なものは、new の引数として初期値を指定するもの。

　　　　書式：class クラス名
　　　　　　　　　クラスの定義
　　　　　　　end
　　　　例文：class Controller
　　　　　　　　　def show( msg )
　　　　　　　　　　　puts( msg )
　　　　　　　　　end
　　　　　　　end
　　　　　　　ctr = Controller.new
　　　　　　　ctr.show( "ruby" )
　　　　補足：クラス名は必ず英大文字であること
　　　　補足：すべてのクラスは Object クラスを暗黙的に継承している
　　　　補足：メソッドのアクセス制限のデフォルトは public
　　　　補足：クラス定義は入れ子にできる。
　　　　補足：モジュール定義の中でクラス定義できる

　　　　書式： def initialize()
　　　　　　　　　処理
　　　　　　　 end
　　　　説明：当該クラスで new() メソッドが呼ばれたとき、自動的に
　　　　　　　このメソッドが呼ばれる。
　　　　　　　もしこのクラスが Object からの直接の派生クラスでない
　　　　　　　ときは、このメソッドの処理の最初で明示的に super() を
　　　　　　　呼び出す必要がある。

　　　　例文１：def name
　　　　　　　　　　return @name
　　　　　　　　end
　　　　例文２：def name=(pName)
　　　　　　　　　　@name = pName
　　　　　　　　end
　　　　例文３：attr_reader :name
　　　　例文４：attr_writer :name
　　　　例文５：attr_accessor :name
　　　　説明：例文１は、インスタンス変数 name の参照用
　　　　説明：例文２は、インスタンス変数 name の変更用
　　　　説明：例文３は、例文１と同じ
　　　　説明：例文４は、例文２と同じ
　　　　説明：例文５は、例文１と２の両方のメソッドを定義したのと同じ
　　　　補足：アクセスメソッドは、他の言語ではアクセッサ(accessor)あるいは
　　　　　　　ゲッターセッター(getter/setter)とも呼ばれる。
　　　　補足：例文３、４、５は、内部のインスタンス変数と強く結ばれている。
　　　　　　　これはオブジェクト指向におけるカプセル化に反する。
　　　　　　　この手法は、いわゆる属性あるいはプロパティというものを定義
　　　　　　　するためにのみ使うべきである。

　　　　例文：class Controller
　　　　　　　　　def display( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　　　self.show( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　end
　　　　　　　end
　　　　補足：当該クラスのインスタンスを指定するには self を使う

　　　　書式：def クラス名.メソッド名
　　　　　　　　　処理
　　　　　　　end
　　　　説明：クラス定義の中にこのメソッド定義を記述する
　　　　例文：class Controller
　　　　　　　　　def Controller.show( msg )
　　　　　　　　　　　puts( msg )
　　　　　　　　　end
　　　　　　　end
　　　　補足：クラスメソッドは、全部で３とおりの書き方がある

　　　　書式：def self.メソッド名
　　　　　　　　　処理
　　　　　　　end
　　　　説明：クラス定義の中にこのメソッド定義を記述する
　　　　例文：class Controller
　　　　　　　　　def self.show( msg )
　　　　　　　　　　　puts( msg )
　　　　　　　　　end
　　　　　　　end
　　　　補足：クラスメソッドは、全部で３とおりの書き方がある

　　　　書式：class << クラス名
　　　　　　　　　def メソッド名
　　　　　　　　　　　処理
　　　　　　　　　end
　　　　　　　end
　　　　説明：クラス定義とは別に、このメソッド定義を記述する
　　　　例文：class << Controller
　　　　　　　　　def show( msg )
　　　　　　　　　　　puts( msg )
　　　　　　　　　end
　　　　　　　end
　　　　補足：クラスメソッドは、全部で３とおりの書き方がある

　　　　書式：class クラス名 < スーパークラス名
　　　　　　　　　クラスの定義
　　　　　　　end
　　　　例文：class SpecialController < Controller
　　　　　　　　　def display( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　　　show( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　end
　　　　　　　end
　　　　　　　ctr = SpecialController.new()
　　　　　　　ctr.display( "ruby" )
　　　　補足：クラス名は必ず英大文字であること
　　　　補足：すべてのクラスは Object クラスを暗黙的に継承している
　　　　補足：もしこのクラスが Object からの直接の派生クラスではなく、
　　　　　　　initialize メソッドを定義しているときは、このメソッドの
　　　　　　　処理の最初で明示的に super() を呼び出す必要がある。

　　　　書式：module モジュール名
　　　　　　　　　モジュールの定義
　　　　　　　end
　　　　説明：名前空間や Mix-in（メソッド追加）を実現する
　　　　補足：モジュール名は必ず英大文字であること
　　　　補足：モジュール定義の中でクラス定義できる。

　　　　例文：module Independent
　　　　　　　　　Ext_text = ".txt"
　　　　　　　　　Ext_ruby = ".rb"
　　　　　　　　　def addRuby( body )
　　　　　　　　　　　return body + Ext_ruby
　　　　　　　　　end
　　　　　　　　　def addExt( body, ext )
　　　　　　　　　　　return body + ext
　　　　　　　　　end
　　　　　　　　　module_function :addRuby :addExt
　　　　　　　end
　　　　例文：filename = Independent::addRuby( "study" )
　　　　　　　extension = Independent::Ext_ruby
　　　　例文：filename = Independent.addRuby( "study" )
　　　　　　　extension = Independent.Ext_ruby
　　　　例文：include Independent
　　　　　　　filename = addExt( "study", Ext_ruby )
　　　　補足：メソッドではなくモジュール関数を定義するときは、
　　　　　　　module_function を使って関数名を公開すること。
　　　　　　　そうでなければ、このモジュールを使う側は常に include
　　　　　　　しなければならない。

　　　　説明：クラス定義内で include すると、そのクラスの
　　　　　　　メソッドとして使えるようになる
　　　　例文：module Additional
　　　　　　　　　def display( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　　　self.show( msg )
　　　　　　　　　　　puts("======")
　　　　　　　　　end
　　　　　　　end
　　　　　　　class Controller
　　　　　　　　　include Additional
　　　　　　　　　def show( msg )
　　　　　　　　　　　puts( msg )
　　　　　　　　　end
　　　　　　　end
　　　　　　　ctr = Controller.new
　　　　　　　ctr.display( "ruby" )
　　　　補足：モジュール内のメソッドから、当該クラスのインスタンスを
　　　　　　　指定するには self を使う

　　　　書式：begin
　　　　　　　　　通常処理
　　　　　　　rescue 例外クラス,例外クラス,... => 例外用の仮変数
　　　　　　　　　例外発生時の処理
　　　　　　　else
　　　　　　　　　例外が発生しなかったときの処理
　　　　　　　ensure
　　　　　　　　　後処理（通常時も例外発生時も処理する）
　　　　　　　end
　　　　説明：メソッド定義の場合は、def〜end が begin〜endを兼ねる。
　　　　説明：例外クラスの指定を省略したときは StandardError とその
　　　　　　　派生クラスを捕まえる。
　　　　　　　例外用の仮変数の指定を省略するときは、=> も省略すること。
　　　　　　　組み込み変数 $! は、最後に発生した例外クラスのオブジェクトを
　　　　　　　保持している。
　　　　　　　rescue 節は省略可であり複数指定可。
　　　　　　　else 節は省略可。
　　　　　　　ensure 節は省略可。
　　　　補足：すべての例外を捕まえるには、Exception（すべての例外クラスの
　　　　　　　スーパークラス）を rescue 節に指定すればできるというように
　　　　　　　書かれている書籍やネット上の情報もあるが、現実的ではない。
　　　　　　　確かに、理論上は間違ってはいないが、StandardError 以外の
　　　　　　　例外というのは、それが発生したらもうプログラムの実行は不可能
　　　　　　　であり、そこから先は１行たりともプログラムを進ませてはならない
　　　　　　　危険な状態になっているので、強制終了するしかない。
　　　　　　　そのような例外を捕まえる意味はまったくない。
　　　　　　　むしろ捕まえずに即、異常終了すべきである。

　　　　書式１：ex.class()
　　　　書式２：ex.message()
　　　　書式３：ex.backtrace()
　　　　説明１：例外の種類を返す。
　　　　説明２：例外のメッセージを返す。
　　　　説明３：例外の位置情報を返す。
　　　　補足：組み込み変数 $@ は、$!.backtrace() と同じ。
　　　　補足：例外クラスを作るときは、StandardError または
　　　　　　　そのサブクラスを継承すること。

　　　　説明：再度 begin から実行するときに、rescue 節で使う。
　　　　補足：ループ構文の中で使うと、そのループの初期値から再度実行する。

　　　　書式１： raise メッセージ（文字列）
　　　　書式２： raise 例外クラス
　　　　書式３： raise 例外クラス, メッセージ
　　　　書式４： raise
　　　　説明：書式１のとき、RuntimeError 例外で、指定文字列がメッセージに。
　　　　　　　書式４（例外クラスもメッセージも省略）のとき、
　　　　　　　rescue 節内であれば、最後に発生した例外（$!）を
　　　　　　　再度発生する。
　　　　　　　rescue 節外であれば、RuntimeError を発生する。
　　　　補足：例外クラスを作るときは、StandardError または
　　　　　　　そのサブクラスを継承すること。

　　　　例文１： a = func(b) rescue c
　　　　例文２： a = b / c rescue 0
　　　　例文３： f.close() rescue nil
　　　　説明１：メソッド func が例外を発生したときに a = c となる
　　　　説明２：０で整数除算したときは ZeroDivisionError 例外となるが、
　　　　　　　　この例文２では a = 0 が実行される。
　　　　説明３：クローズ処理での例外を無視する。
　　　　補足：この rescue修飾子は StandardError とその派生クラスの
　　　　　　　例外を捕まえる。

　　　　書式：catch( シンボルまたは文字列 ) do
　　　　　　　　　処理
　　　　　　　end
　　　　書式：a = catch( シンボルまたは文字列 ) { 処理 }
　　　　書式：throw( シンボルまたは文字列, 値 )
　　　　説明：処理の中で、throw があると、同じシンボルまたは文字列を
　　　　　　　持つ catch ブロックを抜ける。
　　　　　　　多重ループや多重呼び出しを一気に抜けるときに使える。
　　　　　　　throw の値は、catch の戻り値となる。
　　　　補足：catch/throw はメソッドである。
　　　　補足：throw には if/unless修飾子が使える。

　　　　書式：require "rubyソースファイル名"
　　　　例文：require "aaa.rb"
　　　　説明：この文が現れた時点で読み込まれ実行される
　　　　補足：拡張子(.rb)は省略可

　　　　補足：この include は、C言語等での #include とは違う。
　　　　　　　Ruby では、モジュール名を省略するために使う。
　　　　　　　Java の import に相当。
　　　　　　　C言語等での #include に似たものとしては require がある

　　　　説明：文法チェックのみおこなう。

　　　　説明：組み込みグローバル変数 $DEBUG が true になる。
　　　　例文：print("now, debug") if $DEBUG

　　　　説明：下記オプション -W2 と同じ。

　　　　説明：警告を出力しない。デフォルト

　　　　説明：重要な警告を出力する。

　　　　説明：すべての警告を出力する。

　　　　説明：配列型の組み込み定数。各コマンド引数は文字列として保持される。
　　　　補足：C言語等では、配列の最初の要素はコマンド自身の文字列となり、
　　　　　　　２番目以降に引数が保持されるが、
　　　　　　　Ruby では常に引数だけが保持される。

　　　　説明：実行時に指定した、トップレベルのスクリプトファイル名
　　　　例文：if $0 == __FILE__

　　　　説明：環境変数のハッシュオブジェクト

　　　　説明：スクリプトファイル内の __END__ 以降のファイルオブジェクト

　　　　説明：Ruby のバージョン（1.6.7 や 1.8.6 など）
　　　　例文：puts RUBY_VERSION

　　　　説明：漢字コード指定。s e u n のいずれか。
　　　　説明：s はシフトＪＩＳ
　　　　説明：e はＥＵＣ
　　　　説明：u はＵＴＦ−８
　　　　説明：n は指定なし

　　　　説明：コマンドラインオプションで -d を指定したときに true になる。

　　　　説明：実行時の安全レベルを指定する。
　　　　説明：0 IO,ENV,コマンド引数からの文字列に汚染マークを付ける
　　　　説明：1 汚染された文字列の操作を制限する
　　　　説明：2 プロセス、ファイルに関する操作を制限する
　　　　説明：3 新たに生成するすべてのオブジェクトに汚染マークを付ける
　　　　説明：4 グローバル変数の操作、ファイル出力を制限する

　　　　説明：警告レベルを指定する。
　　　　説明：nil   -W0 オプションと同じ。警告なし。
　　　　説明：false -W1 オプションと同じ
　　　　説明：true  -W2 オプションと同じ

　　　　説明：最後に発生した例外クラスのオブジェクト

　　　　説明：最後に発生した例外の位置情報。$!.backtrace() と同じ。