文法の基本

1. 数値リテラル

   

   　　文字コード以外の数値リテラルには，

   123_456_789					

   のように，_ を含めることができます．Ruby インタプリタは，_ を無視し，特別な解釈は何もしません．これは，大きな数値の桁数がひと目でわかるように記述するのに便利です．上の例の場合，その出力は，123456789 になります．以下においても同様ですが，記号に特別な意味を与えて Ruby 独自の世界を作り上げることは，プログラムの「読みやすさ，理解しやすさ」といった点で，非常に問題だと思います．
   　　数値において，整数や ?a などは，Integer クラス のサブクラスである Fixnum クラスのインスタンスです．ただし，整数の大きさが Fixnum によって表現できる範囲を超えると Bignum クラスのインスタンスとして扱われます．また，浮動小数点数は，Float クラスのインスタンスです．数値リテラルは，以下のように記述しますが，? で始まる箇所を除いて，C/C++ においても同様です．
   • 123，0d123　　整数
   • -123　　符号つき整数
   • 123.45　　浮動小数点数．ピリオド（ . ）で始まる浮動小数点数は許されません．0.1 などと書く必要があります．
   • 1.2e-3　　浮動小数点数
   • 0xffff，0xFFFF　　16 進整数
   • 0377，0o377　　8 進整数
   • 0b1011　　2 進整数
   
   ?a　　文字 a のコード（ 97 ）．空白類を指定する場合は，?\s，?\t などとする必要があります．
   ?\C-a　　コントロール a のコード（ 1 ）
   ?\M-a　　メタ a のコード（ 225 ）
   ?\M-\C-a　　メタ-コントロール a のコード（ 129 ）

2. 文字列リテラル
   　　文字列リテラルは，ダブルクォート（ " ），または，シングルクォート（ ' ）で囲んで表現し，String クラスのインスタンスです．ダブルクォートで囲まれた文字列では，後に述べる，バックスラッシュ記法と式展開が有効になります．シングルクォートで囲まれた文字列では，\\ （バックスラッシュそのもの）と \' （シングルクォート），行末の \ （改行を無視）を除いて文字列の中身の解釈は行われません．C++ における string クラスを利用した文字列の扱いと似ていますが，多少異なっています．特に，C++ においては，式展開の機能はありません．

   　　文字列を複数行にわたって書くこともできます．この場合，含まれる改行文字は常に \n になります．また，空白を間に挟んだ文字列リテラルは，1 つの文字列リテラルと見倣されます．文字列の結合は，+ 演算子によって可能ですので，以下の 2 つの式は，同じ結果 abcefg になります．

   "abc" + "efg\n"
   "abc" "efg\n"					

   　　以下に示すように，バックスラッシュ（ \ ）を使用して，特別な文字（制御文字など）を表現することが可能です．これを，バックスラッシュ記法と呼びます．C/C++ などにおけるエスケープシーケンスに相当します．

   Seq.	説明	Seq.	説明
   \t	タブ（ 0x09 ）	\n	改行（ 0x0a ）
   \r	キャリッジリターン（ 0x0d ）	\f	改ページ（ 0x0c ）
   \b	バックスペース（ 0x08 ）	\a	ベル（ 0x07 ）
   \e	エスケープ（ 0x1b ）	\s	空白（ 0x20 ）
   \nnn	8 進数表記（ n は 0-7 ）	\xnn	16 進数表記（ n は 0-9，a-f ）
   \cx，\C-x	コントロール文字（ x は ASCII 文字）	\M-x	メタ x （ c | 0x80 ）
   \M-\C-x	メタコントロール x	\x	文字 x そのもの

   　　ダブルクォート（ " ），または，バッククォート（ ` ）で囲まれた文字列，及び，正規表現の中では，#{ 式 } という形式で式の内容（式を評価した結果）を埋め込むことができます．この機能を式展開と呼びます．式が変数記号 $，または，@ で始まる変数の場合には { } を省略して，「#変数名」という形式でも展開できます．文字 # に続く文字が {，$，@ でなければ，そのまま文字 # として解釈されます．明示的に式展開を止めるには # の前にバックスラッシュを置きます．式展開の中には，ダブルクォートなども含めて Ruby の式をそのまま書くことができます．コメントも許されます．次のプログラムを実行すると，その下に示すような結果が得られます．なお，print は，カンマで区切られたデータを順に出力するための関数です．

   $sei = "山田"
   $nam = "太郎"
   print "私は，#{ $sei + $nam } です\n"
   print "私は，#{ $sei } です\n"
   print "私は，#$sei です\n"
   print "私は，\#{ $sei } です\n"  # 式展開が行われない					

   （出力）

   私は，山田太郎 です
   私は，山田 です
   私は，山田 です
   私は，#{ $sei } です					

   　　バッククォート（ ` ）で囲まれた文字列は，ダブルクォートで囲まれた文字列と同様に，バックスラッシュ記法の解釈と式展開が行なわれた後，コマンドとして実行され，その標準出力が文字列として与えられます．コマンドの終了ステータスを得るには，組み込み変数 $? を参照します（このような仕様は許すべきではない）．次に示すプログラムは，「 ls -l 」コマンドを実行し，その結果を変数 y に代入しています．このプログラムを実行すると，次のような結果が得られます．C/C++ における system 関数の仕様に相当します．

   #! ruby -Ks
   y = ` ls -l `
   printf "%s\n", y
   printf "終了ステータス %d\n", $?					

   （出力）

   total 1
   -rwxr-xr-x   1 1005     everyone       44 Jun  8 13:45 test.rb
   
   終了ステータス 0					

3. ヒアドキュメント


　　普通の文字列リテラルは，デリミタ（ "，'，` など）で囲まれた文字列ですが，ヒアドキュメントは，

<<識別子
　　文字列
　　・・・
識別子					

のように，「<<識別子 」を含む行の次の行から，「識別子」だけの行の直前までを文字列とする行指向のリテラルです．ヒアドキュメントも，通常の文字列と同様，String クラスのインスタンスです．一つの文字列リテラルだと考えたとき，以下に示す例に見るように，その仕様があまりにも不自然だと思います．例えば，

<<EXAMPLE
  Test String 1
  Test String 2
EXAMPLE					

は，文字列 " Test String 1\n Test String 2\n" と同じになります．また，「<<EXAMPLE」が，文字列全体に対応する識別子（文法要素としての式）となりますので，例えば，String クラスのメソッド upcase （すべての文字を大文字に変換するメソッド）などを使用するには，下に示すプログラムのように記述します．このプログラムを実行するとその下に示すような出力結果が得られます．

print <<EXAMPLE.upcase
  Test String 1
  Test String 2
EXAMPLE
=begin
	以下の 4 行は error（この方が自然では？）
print <<EXAMPLE
  Test String 1
  Test String 2
EXAMPLE.upcase
	以下の 4 行でも同じ（この方が理解しやすい）
str = <<EXAMPLE
  Test String 1
  Test String 2
EXAMPLE
print str
	以下の 1 行でも同じ
print "  Test String 1\n  Test String 2\n".upcase
	以下の 4 行は error
<<EXAMPLE
  Test String 1
  Test String 2
EXAMPLE
print <<EXAMPLE
=end
					

（出力）

  TEST STRING 1
  TEST STRING 2					

　　また，ヒアドキュメントをメソッドの引数とするには，下に示すプログラムのようにして行います．なお，このプログラムは，2 つのヒアドキュメントを引数にした例です．なお，メソッドに関しては，メソッド（関数）を参照してください．

def func (par1, par2, par3)
	print par1
	print par2
	print "Number of Line ", par3, "\n"
end
	# 以下の記述方法は不自然
func <<EXAMPLE1, <<EXAMPLE2, 3
  Test String 1
  Test String 2
EXAMPLE1
  Test String 3
EXAMPLE2
=begin
	以下のように記述しても良い（この方が理解しやすい）
str1 = <<EXAMPLE1
  Test String 1
  Test String 2
EXAMPLE1
str2 = <<EXAMPLE2
  Test String 3
EXAMPLE2
func str1, str2, 3
=end
					

（出力）

  Test String 1
  Test String 2
  Test String 3
Number of Line 3					

　　開始ラベル「<<識別子」の識別子を ダブルクォート（ " ），シングルクォート（ ' ），または，バッククォート（ ` ）によって囲むことによって，ヒアドキュメントとなる文字列リテラルの性質は，対応する文字列リテラルと同じ扱いになります．なお，識別子がクォートで囲まれていないときは，ダブルクォートで囲まれている場合と同じです．詳細については，以下に示すプログラム例とその出力結果を見て下さい．

$name = "太郎"

# 式展開を行う
print <<"EXAMPLE"
My name is #{$name}.
EXAMPLE

# 式展開を行わない
print <<'EXAMPLE'
My name is #{$name}.
EXAMPLE

# コマンドを実行
x =  <<`EXAMPLE`
ls -l
EXAMPLE
print x
					

（出力）

My name is 太郎.
My name is #{$name}.
total 1
-rw-r--r--   1 1005     everyone      242 Jun  9 11:40 test.rb					

4. シンボル
   　　シンボルは，Symbol クラスのインスタンスであり，Symbol オブジェクトは，特定の文字列と一対一に対応します．シンボルはプログラム内で一意の整数値であり，

   :abc					

   と記述することによって，文字列 "abc" をシンボル :abc （整数値）に一対一で対応させます．Ruby においては，予約後，変数名，リテラルなどはシンボルを使用して管理しています．例えば，文字列リテラルは，出現するたびに新しい String クラスのインスタンスを生成し，それらに異なるシンボルを対応させます．枠内に示すプログラムにおいて，ダブルクォートで囲まれた文字列は，すべて異なるシンボルに対応しています．従って，その内容が同じであっても，引数が self 自身であるとき真を返す Object クラスのメソッド equal? を使用して比較すると false を返します．なお，このプログラムにおいて，to_s は，シンボルに対応する文字列を返す Symbol クラスのメソッドです．

   print ("abc" == "abc") ? true : false, "\n"
   print ("abc".equal?("abc")) ? true : false, "\n"
   print ("abc" == :abc) ? true : false, "\n"
   print ("abc" == :abc.to_s) ? true : false, "\n"
   print ("abc".equal?(:abc.to_s)) ? true : false, "\n"
   print (:abc == :abc) ? true : false, "\n"
   print (:abc.equal?(:abc)) ? true : false, "\n"
   print (:abc == :"abc") ? true : false, "\n"
   print (:abc.equal?(:"abc")) ? true : false, "\n"
   					

   （出力）

   true
   false
   false
   true
   false
   true
   true
   true
   true
   					

   　　シンボルは，ハッシュテーブルにおいて良く使用されます．ハッシュとは，任意のオブジェクトをキー（添字）として持つ配列であり，Hash クラスのインスタンスです．下のプログラムでは，:name，及び，:address をキーとする 2 つのデータからなるハッシュテーブルを作成しています．

   #! ruby -Ks
   
   def func(x)
   	print x[:name], "\n"
   	print x[:address], "\n"
   end
   
   func ({:name => "山田太郎", :address => "静岡県"})					

   （出力）

   山田太郎
   静岡県					

5. % 記法


　　文字列リテラル，コマンド出力，正規表現リテラル，配列式，シンボルでは，% で始まる形式の記法（% 記法）を用いることによって，通常の区切り文字を他の文字に変更することができます．例えば，次のプログラム例（先に示した例と同じ）では，コマンドの実行の際に使われる区切り文字 ` ` を，{ } に変更しています．このような仕様が必要なのでしょうか？プログラムを理解しにくくするだけではないでしょうか？

#! ruby -Ks
y = %x{ ls -l }
print y					

　　% 記法には，以下のようなものがあります．! の部分には，改行を含めた任意の非英数字を使うことができます．始まりの区切り文字が括弧（ (，[，{，< ）である時には，終りの区切り文字は対応する括弧になります．括弧を区切り文字にした場合，対応が取れていれば区切り文字と同じ括弧を要素に含めることができます．

• %!STRING!　　ダブルクォート文字列
• %Q!STRING!　　同上
• %q!STRING!　　シングルクォート文字列
• %x!STRING!　　コマンド出力
• %r!STRING!　　正規表現
• %w!STRING!　　要素が文字列の配列（空白区切り）
• %W!STRING!　　要素が文字列の配列（空白区切り）．式展開，バックスラッシュ記法が有効
• %s!STRING!　　シンボル．式展開，バックスラッシュ記法は無効

x = x + 5				

x += 5				

+, -, *, /, %, **, &, |, ^, <<, >>, &&, ||				

［プログラム例 2.1］ 簡単なプログラム

01	#include <stdio.h>
02	
03	int main()
04	{
05				// データの入力
06		double x, y;
07		printf("２つのデータを入力して下さい ");
08		scanf("%lf %lf", &x, &y);
09				// 乗算と除算
10		double mul = x * y;
11		double div = x / y;
12				// 結果の出力
13		printf("乗算＝%f 除算＝%f\n", mul, div);
14	
15		return 0;
16	}
				

01	############################
02	# ２つのデータの乗算と除算 #
03	#      coded by Y.Suganuma #
04	############################
05				# データの入力
06	printf "２つのデータを入力して下さい ";
07	#print "２つのデータを入力して下さい ";
08	str = gets().strip();   # gets でも良い（以下の関数も同様）;
09	a   = str.split(" ");
10	x   = Integer(a[0]);
11	y   = Integer(a[1]);
12				# 和と差の計算
13	mul = x * y;
14	div = x / y;
15				# 結果の出力
16	printf "乗算＝%d 除算＝%d\n", mul, div;
17	#print "乗算＝", mul, " 除算＝", div, "\n";
				

print "   順番に代入\n";
a, b, c = 1, 2, 3
print "a = ", a, ", b = ", b, ", c = ", c, "\n"
print "   左辺の式が 1 つ（配列に代入）\n";
a = 1, 2, 3
print "a[0] = ", a[0], ", a[1] = ", a[1], ", a[2] = ", a[2], "\n"
print "   右辺の要素の数の方が多い\n";
a, b = 1, 2, 3
print "a = ", a, ", b = ", b, "\n"
print "   左辺の要素の数の方が多い\n";
a, b, c = 1, 2
print "a = ", a, ", b = ", b, ", c = nil\n"
print "   左辺に * を利用（余った要素を配列に代入）\n";
a, *b = 1, 2, 3
print "a = ", a, ", b[0] = ", b[0], ", b[1] = ", b[1], "\n"
print "   右辺に配列（x = [1, 2, 3]）\n";
x = [1, 2, 3]
a, b, c = 5, x
print "a = ", a, ", b = ", b, ", c = ", c, "\n"
print "   右辺の配列に * を利用（左辺の各要素に分割）\n";
a, b, c = 5, *x
print "a = ", a, ", b = ", b, ", c = ", c, "\n"
				

   順番に代入
a = 1, b = 2, c = 3
   左辺の式が 1 つ（配列に代入）
a[0] = 1, a[1] = 2, a[2] = 3
   右辺の要素の数の方が多い
a = 1, b = 2
   左辺の要素の数の方が多い
a = 1, b = 2, c = nil
   左辺に * を利用（余った要素を配列に代入）
a = 1, b[0] = 2, b[1] = 3
   右辺に配列（x = [1, 2, 3]）
a = 5, b = [1, 2, 3], c =
   右辺の配列に * を利用（左辺の各要素に分割）
a = 5, b = 1, c = 2
				

• if 文

  if 式１ [then]
  	式２
  [elsif 式３ [then]
  	式４ ]
  ・・・
  [else
  	式５ ]
  end					

  　　式１が真であれば式２，式３が真であれば式４，・・・，そうでなければ式５が評価されます．C/C++ における if 文とほぼ等価です．意味も分かりやすく，たぶん多くの人が使い慣れた「 else if 」から「 elsif 」に変更する必要があるのでしょうか．Ruby は，意味の無い記号に特別な意味を与えるなど，記述を簡単にすることが目的かもしれませんが，理解しにくくなり，誤りを誘発する原因となりかねません．．

• if 修飾子（このような機能，必要？ 条件演算子で十分？）


式１ if 式２					

　　式２が真であれば，式１を評価してその結果を返します．

x = 5
y = 10 if x > 0
z = 20 if x < 0
printf "y = %d, z = %d\n", y, z					

（出力）

y = 10, z = 0					

• unless 文（このような機能，必要？）


unless 式１ [then]
	式２
[else
	式３]
end					

　　if の逆であり，式１が偽であれば式２を，そうでなければ式３を実行します．
• unless 修飾子（このような機能，必要？）


式１ unless 式２					

　　式２が偽であれば，式１を評価してその結果を返します．
• case 文


case [式０]
	[when 式１ [, 式２] ・・・ [, *式ｍ] [then]
		式ｎ]
	・・・
	[when *式ｐ [then]
		式ｑ]
	・・・
	[else
		式ｒ]
end					

　　式０を評価した結果と，when 節で指定された各式を評価した結果とを，演算子 === を用いて比較し，一致する場合には when 節の本体を評価します．when 節の最後の式に * を前置すれば，その式は配列展開されます．以下に示すプログラムにおいて，コメント行で区切って示した各プログラムは，ほぼ等価であり，「結果は負」というメッセージを出力します．C/C++ における switch 文と似ていますが，かなり異なっています．いずれにしろ，Ruby の仕様は複雑すぎます．確かに，この仕様によって，プログラムの記述が簡単になるかもしれませんが，分かり難くなるだけではないでしょうか．

x = 5
y = -6
			# case 例１
case x+y
	when 1, 2, 3
		printf "結果は正\n"
	when -3, -2, -1
		printf "結果は負\n"
	else
		printf "結果は０\n"
end
			# case 例２（範囲式）
case x+y
	when 1 .. 3
		printf "結果は正\n"
	when -3 .. -1
		printf "結果は負\n"
	else
		printf "結果は０\n"
end
			# case 例３（配列）
a = [1, 2, 3]
b = [-3, -2, -1]
case x+y
	when *a
		printf "結果は正\n"
	when *b
		printf "結果は負\n"
	else
		printf "結果は０\n"
end
			# case 例４（ if による書き換え）
z = x + y
if z === 1 || z === 2 || z === 3
	printf "結果は正\n"
elseif z === -1 || z === -2 || z === -3
	printf "結果は負\n"
else
	printf "結果は０\n"
end
					

• while 文

while 式１ [do]
	式２
end					

　　式１が真の間，式２を繰り返し実行します．C/C++ における while 文とほぼ同等です．
• while 修飾子（このような機能，必要？）


式１ while 式２					

　　式２を評価した結果が真の間，式１を繰り返し実行します．
• until 文（このような機能，必要？）


until 式１ [do]
	式２
end					

　　式１を評価した結果が真になるまで，式２を繰り返して実行します．
• until 修飾子（このような機能，必要？）


式１ until 式２					

　　式２を評価した結果が真になるまで，式１を繰り返して実行します．
• for 文

for ループ変数 in 式１ [do]
	式２
end					

　　式１を評価した結果のオブジェクトの各要素に対して，式２を繰り返して実行します．C/C++ における範囲 for 文と似た機能です．C/C++ における通常の for 文のような機能もあった方が良いのではないでしょうか．プログラム例 3.1 に示すように，複数のループ変数を指定することも可能です（このような機能，必要ですか？．分かり難くなるだけ！）．

［プログラム例 3.1］ for 文　

01	############################
02	# for 文                   #
03	#      coded by Y.Suganuma #
04	############################
05				# Range クラスを利用
06	for i in Range.new(1, 3)   # Range.new(1, 4, true) でも良い
07		printf "%d ", i
08	end
09	printf "\n"
10				# 配列の利用
11	for i in Array[1.5, 5.1, 3.14]
12		printf "%.2f ", i
13	end
14	printf "\n"
15				# 複数のループ変数（ 2 次元配列）
16				# このような機能は必要ない
17				# プログラムが読みにくくなるだけ
18	for i, j in Array[[1, 2], [3, 4], [5, 6]]   # [[1, 2], [3, 4], [5, 6]] でも良い
19		printf "%d,%d  ", i, j
20	end
21	printf "\n"
					

06 行目～ 09 行目

　　「式１」として，Range クラスを使用した場合です．1 から 3 までの値を出力しています．C/C++ における通常の if 文にほぼ相当しています．

11 行目～ 14 行目

　　「式１」として，1 次元配列を使用した場合です．配列の各要素の値を出力しています．

18 行目～ 21 行目

　　「式１」として，2 次元配列を使用した場合です．複数のループ変数を指定して，配列の各要素の値を出力しています．

（出力）

1 2 3
1.50 5.10 3.14
1,2  3,4  5,6					

• break 文

break					

　　もっとも内側のループを脱出します．

for i in Array[1, 5, -1, 6, 7]
	if i < 0
		break
	end
	printf "%d ", i
end
printf "\n"					

• next 文

next					

　　もっとも内側のループの次の繰り返しにジャンプします．C/C++ における continue に相当します．

for i in Array[1, 5, -1, 6, 7]
	if i < 0
		next
	end
	printf "%d ", i
end
printf "\n"					

• redo 文


redo					

　　ループ条件のチェックを行なわず，現在の繰り返しをやり直します．next や redo のような機能を設ける必要がありますか？ continue だけで十分ではないでしょうか．誤りの原因になりかねません．

sw = 0
for i in Array[1, 5, -1, 6, 7]
	if i < 0 && sw == 0
		sw = 1
		redo
	end
	printf "%d ", i
end
printf "\n"					

• retry 文


retry					

　　イテレータ，ブロック，または，for 文の中で使われた場合には，そのイテレータを起動しなおします．イテレータの引数も再評価されます．retry は，ループ以外に例外処理の rescue 節でも使えます．この場合は，begin 式を始めからもう一度実行します．retry を使うことである処理が成功するまで処理を繰り返すようなループを作ることができます．

　　以下に示すのは，break，next，redo，及び，retry の違いを示したプログラム例とその出力結果です．なぜ，このように複雑で，分かり難い仕様を設定するのか理解できません．多少プログラムが長くなっても，読みやすく，理解しやすいことが第一です．

printf "Example of break\n"
for i in [1, 2, 3]
	printf "   i(first) = %d\n", i
	if i == 2
		break
	end
	printf "   i(second) = %d\n", i
end

printf "Example of next\n"
for i in [1, 2, 3]
	printf "   i(first) = %d\n", i
	if i == 2
		next
	end
	printf "   i(second) = %d\n", i
end

printf "Example of redo\n"
state = 0
for i in [1, 2, 3]
	printf "   i(first) = %d\n", i
	if i == 2 && state == 0
		state = 1
		redo
	end
	printf "   i(second) = %d\n", i
end

printf "Example of retry\n"
state = 0
for i in [1, 2, 3]
	printf "   i(first) = %d\n", i
	if i == 2 && state == 0
		state = 1
		retry
	end
	printf "   i(second) = %d\n", i
end
					

（出力）

Example of break
   i(first) = 1
   i(second) = 1
   i(first) = 2
Example of next
   i(first) = 1
   i(second) = 1
   i(first) = 2
   i(first) = 3
   i(second) = 3
Example of redo
   i(first) = 1
   i(second) = 1
   i(first) = 2
   i(first) = 2
   i(second) = 2
   i(first) = 3
   i(second) = 3
Example of retry
   i(first) = 1
   i(second) = 1
   i(first) = 2
   i(first) = 1
   i(second) = 1
   i(first) = 2
   i(second) = 2
   i(first) = 3
   i(second) = 3
					

• BEGIN { 文 }
  　　初期化ルーチンを登録します．BEGIN ブロックで指定した文は，当該ファイルのどの文が実行されるより前に実行されます．複数の BEGIN が指定された場合には指定された順に実行されます．

• END { 文 }
  　　後始末ルーチンを登録します．END ブロックで指定した文は，インタプリタが終了する時に実行されます．複数の END ブロックを登録した場合は，登録したときと逆の順序で実行されます．

def メソッド名 [ 引数の並び ]
　　　式
　　・・・
　　[rescue [error_type,..] [=> evar] [then]
　　　　　式..]..
　　[else
　　　　　式..]
　　[ensure
　　　　　式..]
end				

return [ 式 [ , 式 ... ] ]				

01	def fun(a, b, x)
02		a   *= 2
03		x[0] = a + b
04		x[1] = a - b
05		x[2] = a * b
06		x[3] = a / b
07		return x[0], x[1], x[2], x[3]
08	#	return x
09	end
10	
11	a  = 5
12	b  = 2
13	x1 = Array.new(4)
14	print "関数を呼ぶ前： a = ", a, ", b = ", b, "\n"
15	
16	y1 = fun(a, b, x1)
17	
18	print "関数を呼んだ後： a = ", a, ", b = ", b, "\n"
19	print "x1 = ", x1, "\n"
20	print "y1 = ", y1, "\n"
				

関数を呼ぶ前： a = 5, b = 2
関数を呼んだ後： a = 5, b = 2
x1 = [12, 8, 20, 5]
y1 = [12, 8, 20, 5]				

def func (par1, par2=10, par3=30)
	x = par1 + par2 + par3
	return x
end
print func(100, 50)				

	# 可変長引数
def func1 (par, *x)
	print "par: ", par, "  x:", x, "\n"
end
func1(0)          # 出力結果 par: 0  x:[]
func1(1, 10)      # 出力結果 par: 1  x:[10]
func1(2, 10, 20)  # 出力結果 par: 2  x:[10, 20]
	# 配列を使用した場合
def func2 (par, x)
	print "par: ", par, "  x;", x, "\n"
end
x = Array.new
func2(0, x)  # 出力結果 par: 0  x;[]
x.push(10)
func2(1, x)  # 出力結果 par: 1  x;[10]
x.push(20)
func2(2, x)  # 出力結果 par: 2  x;[10, 20]
				

• デフォルト式のない引数(複数指定可)
• デフォルト式のある引数(複数指定可)
• * を伴う引数(1つだけ指定可)
• & を伴う引数(1つだけ指定可)

class 識別子 [ < superclass ]
　　式（演算式，メソッド，クラスなど）
　　　　・・・
end				

obj1 = Test.new
obj2 = Test.new(10, 20)   # 引数がある場合				

［プログラム例 6.1］ クラスの定義と参照　

01	#************************/
02	# クラスの定義と参照    */
03	#   coded by Y.Suganuma */
04	#************************/
05	v_local_1    = 5
06	$_global_1   = 15
07	V_const_1    = 25
08	@_instance_1 = 35
09	@@_class_1   = 45   # 警告メッセージ出力
10	
11	class Test
12		v_local_2    = 10
13		$_global_2   = 20
14		V_const_2    = 30
15		@_instance_2 = 40
16		@@_class_2   = 50
17	
18		print "クラス内からクラス外の変数を参照\n"
19	#	print "     v_local_1    : ", v_local_1, "\n"   # 参照不可（エラー）
20		print "     $_global_1   : ", $_global_1, "\n"
21		print "     V_const_1    : ", V_const_1, "\n"
22		print "     @_instance_1 : ", @_instance_1, "\n"   # 参照不可
23		print "     @@_class_1   : ", @@_class_1, "\n"
24	
25		print "クラス内からクラス内の変数を参照\n"
26		print "     v_local_2    : ", v_local_2, "\n"
27		print "     $_global_2   : ", $_global_2, "\n"
28		print "     V_const_2    : ", V_const_2, "\n"
29		print "     @_instance_2 : ", @_instance_2, "\n"
30		print "     @@_class_2   : ", @@_class_2, "\n"
31				# コンストラクタ
32		def initialize(par = 100)
33			@_instance_2 = par
34		end
35				# インスタンス変数の出力
36		def out
37			print "     @_instance_2 : ", @_instance_2, "\n"
38		end
39				# インスタンス変数を外部から参照可能にする
40		attr("_instance_2", true)
41	end
42	
43	print "クラス外からクラス外の変数を参照\n"
44	print "     v_local_1    : ", v_local_1, "\n"
45	print "     $_global_1   : ", $_global_1, "\n"
46	print "     V_const_1    : ", V_const_1, "\n"
47	print "     @_instance_1 : ", @_instance_1, "\n"
48	print "     @@_class_1   : ", @@_class_1, "\n"   # 警告メッセージ出力
49	
50	print "クラス外からクラス内の変数を参照\n"
51	#print "     v_local_2    : ", Test::v_local_2, "\n"   # 参照不可（エラー）
52	print "     $_global_2   : ", $_global_2, "\n"   # Test:: を付加するとエラー
53	print "     V_const_2    : ", Test::V_const_2, "\n"
54	print "     @_instance_2 : ", @_instance_2, "\n"   # 参照不可
55	#print "     @@_class_2   : ", @@_class_2, "\n"   # 参照不可（エラー）
56				# インスタンスの生成
57	obj1 = Test.new
58	obj2 = Test.new(200)
59	
60	print "インスタンスからクラス内の変数を参照\n"
61	#print "     v_local_2    : ", obj1.v_local_2, "\n"   # 参照不可（エラー）
62	#print "     $_global_2   : ", obj1.$_global_2, "\n"   # 参照不可（エラー）
63	#print "     V_const_2    : ", obj1.V_const_2, "\n"   # 参照不可（エラー）
64	obj1.out()
65	obj2.out()
66	#print "     @_instance_2 : ", obj1.@_instance_2, "\n"   # 参照不可（エラー）
67	print "     @_instance_2 : ", obj1._instance_2, "\n"   # attr による設定が必要
68	print "     @_instance_2 : ", obj2._instance_2, "\n"
69	#print "     @@_class_2   : ", obj1.@@_class_2, "\n"   # 参照不可（エラー）
				

test.rb:9: warning: class variable access from toplevel
クラス内からクラス外の変数を参照
     $_global_1   : 15
     V_const_1    : 25
     @_instance_1 :
     @@_class_1   : 45
クラス内からクラス内の変数を参照
     v_local_2    : 10
     $_global_2   : 20
     V_const_2    : 30
     @_instance_2 : 40
     @@_class_2   : 50
クラス外からクラス外の変数を参照
     v_local_1    : 5
     $_global_1   : 15
     V_const_1    : 25
     @_instance_1 : 35
test.rb:48: warning: class variable access from toplevel
     @@_class_1   : 45
クラス外からクラス内の変数を参照
     $_global_2   : 20
     V_const_2    : 30
     @_instance_2 :
オブジェクトからクラス内の変数を参照
     @_instance_2 : 100
     @_instance_2 : 200
     @_instance_2 : 100
     @_instance_2 : 200
				

# 二項演算子
　　def +(other)　　　# obj + other
　　def -(other)　　　# obj - other

# 単項プラス/マイナス
　　def +@　　　# +obj
　　def -@　　　# -obj

# [] と []=
　　def [](key)　　　　　　　　　　# obj[key]
　　def []=(key, value)　　　　　　# obj[key] = value
　　def []=(key, key2, value)　　　# obj[key, key2] = value				

class Comp
	def initialize(_real = 0, _imag = 0)
		@_real = _real
		@_imag = _imag
	end
	def out(cr = "")
		print "(", @_real, ", ", @_imag, ")", cr
	end
	def real
		return @_real
	end
	def imag
		return @_imag
	end
	def +(obj)
		c = Comp.new(@_real+obj.real, @_imag+obj.imag)
		return c
	end
end

a = Comp.new(1, 2)
b = Comp.new(2, 3)
a.out("\n")
b.out("\n")
c = a + b
c.out("\n")
				

(1, 2)
(2, 3)
(3, 5)				

単項 - 演算子の多重定義　

class Comp
	def initialize(_real = 0, _imag = 0)
		@_real = _real
		@_imag = _imag
	end
	def out(cr = "")
		print "(", @_real, ", ", @_imag, ")", cr
	end
	def -@
		c = Comp.new(-@_real, -@_imag)
		return c
	end
end

a = Comp.new(1, 2)
a.out("\n")
c = -a
c.out("\n")
				

(1, 2)
(-1, -2)