メソッド呼び出し

• super
• ブロック付きメソッド呼び出し
• yield
• ブロックパラメータの挙動
• 番号指定パラメータ
• it
• .() および ::() 形式のメソッド呼び出し（callメソッドの糖衣構文）

foo.bar()
foo.bar
bar()
print "hello world\n"
print
Class.new
Class::new

[式  `.'] 識別子 [`(' [[`*'] 式] ... [`&' 式] `)']
[式 `::'] 識別子 [`(' [[`*'] 式] ... [`&' 式] `)']

ここでの「識別子」はメソッド名を表します。メソッド名には通常の識別子の他、識別子に ? または ! の続いたものや、再定義可能な演算子(例: ==, +, - など)も使えます(クラス／メソッドの定義/メソッド定義参照)。

メソッド呼び出し式はレシーバ(. の左側の式の値)のメソッドを呼び出します。レシーバが指定されない時は self のメソッドを呼び出します。

. と :: とはほぼ同じ意味です。但し、定数を表す場合は、 :: を使わなければいけません(例: Math::PI)。逆に、

Klass::Foo

とした場合、常に定数と見なされるという制限があります。 :: を、クラスメソッド呼び出しに使うという流儀がありますが、この点は要注意です。大文字で始まるメソッド名を使用する場合は

Klass.Foo

と . を使うか、

Klass::Foo()

と括弧でメソッド呼び出しであることを明示する必要があります。

メソッド名には通常の識別子の他、識別子に ? または ! の続いたものが許されます。慣習として、述語(真偽値を返すメソッド)には ? をつけるようになっています。

! はメソッド名の一部です。同名の(! の無い)メソッドに比べて、より注意して使うべきメソッドであることを示します(例: tr と tr!)。破壊的なメソッドに使われることが多いですが、! が付いていないメソッドが破壊的でないとは限りません。

引数の直前に * がついている場合、その引数の値が展開されて渡されます。展開はメソッド to_a を経由して行なわれます。つまり:

foo(1,*[2,3,4])
foo(1,*[])
foo(1,*[2,3,4],5)
foo(1,*[2,3,4],5,*[6])

は、それぞれ

foo(1,2,3,4)
foo(1)
foo(1,2,3,4,5)
foo(1,2,3,4,5,6)

と同じです。

最後の引数の直前に & がついている場合、その引数で指定した手続きオブジェクト(Proc)やメソッドオブジェクト(Method)がブロックとしてメソッドに渡されます。詳細は ブロック付きメソッド呼び出し を参照してください。

メソッド呼び出しの際、private なメソッドは関数形式(レシーバを省略した形式)でしか呼び出すことができません。また protected なメソッドはそのメソッドを持つオブジェクトのメソッド定義式内でなければ呼び出せません。クラス／メソッドの定義/呼び出し制限 を参照して下さい。

ハッシュ式の解説(リテラル/ハッシュ式)にも書かれている通り、メソッド呼出の末尾にHashを渡す場合は {, } を省略できます。これを用いることでキーワード引数を渡すことができます。この Hash はクラス／メソッドの定義/メソッド定義で解説されているキーワード引数に分解されて引き渡されます。

メソッド呼び出しで . の代わりに &. を使うことができます。 &. は safe navigation operator と呼ばれます(「ぼっち演算子」と呼ばれることもあります)。この形式でメソッドを呼びだそうとすると、レシーバが nil の場合は以下のように働きます。

• 引数の評価が行なわれない
• メソッド呼び出しが行われない
• nil を返す

レシーバが nil でない場合は通常のメソッド呼び出しが行われます。

foo = 13
p foo&.to_s # => "13"
foo = nil
foo&.to_s # nil, not ""

&. は要素代入(アトリビュート)に対しても使えます。

foo&.bar = "abc" # for `bar=' method

super

super
super(1,2,3)

super
super(式, ... )

super は現在のメソッドがオーバーライドしているメソッドを呼び出します。括弧と引数が省略された場合には現在のメソッドの引数がそのまま引き渡されます。引数を渡さずにオーバーライドしたメソッドを呼び出すには super() と括弧を明示します。

class Foo
  def foo(arg=nil)
    p arg
  end
end

class Bar < Foo
  def foo(arg)
    super(5)       # 5 を引数にして呼び出す
    super(arg)     # 5 を引数にして呼び出す
    super          # 5 を引数にして呼び出す super(arg) の略記法
    arg = 1
    super          # 1 を引数にして呼び出す super(arg) の略記法
    super()        # 引数なしで呼び出す
  end
end
Bar.new.foo 5

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

[1,2,3].each do |i| print i*2, "\n" end
[1,2,3].each {|i| print i*2, "\n" }

method(arg1, arg2, ...)  do [`|' 式 ... [`;' 識別子 ... ] `|'] 式 ... end
method(arg1, arg2, ...) `{' [`|' 式 ... [`;' 識別子 ... ] `|'] 式 ... `}'
method(arg1, arg2, ..., `&' proc_object)

ブロック付きメソッドとは制御構造の抽象化のために用いられるメソッドです。最初はループの抽象化のために用いられていたため、特にイテレータと呼ばれることもあります。 do ... end または { ... } で囲まれたコードの断片 (ブロックと呼ばれる)を後ろに付けてメソッドを呼び出すと、そのメソッドの内部からブロックを評価できます。ブロック付きメソッドを自分で定義するには yield 式を使います。

{ ... } の方が do ... end ブロックよりも強く結合します。次に例を挙げますが、このような違いが影響するコードは読み辛いので避けましょう:

foobar a, b do body end   # foobarの引数はa, bの値とブロック
foobar a, b { body }      # ブロックはメソッドbの引数、aの値とbの返り値とがfoobarの引数

ブロックの中で初めて代入された(宣言された)ローカル変数はそのブロックの中でだけ有効です。例えば:

foobar {
  i = 20                # ローカル変数 `i' が宣言された
  # ...
}
print defined? i        # `i' はここでは未定義なので false
foobar a, b do
  i = 11                # まったく別の変数 i の宣言
  # ...
end

以下は逆にブロック外でも有効な例です。

i = 10
[1,2,3].each do |m|
  p i * m               # いきなり i を使える
end

ブロックパラメータの後に ; で区切って識別子を並べると、それらは ブロックローカル変数になります。ブロックローカル変数は、外側のスコープに同名のローカル変数があってもそれとは別の変数になり(シャドーイング)、外側の変数に影響を与えずに同じ名前を使えます。値はブロックの呼び出しごとに nil に初期化されます。

x = 10
[1, 2, 3].each do |i; x|  # x はブロックローカル変数
  x = i * 10              # 外側の x とは別の変数
  p x                     # => 10, 20, 30
end
p x                       # => 10

ブロックの部分だけを先に定義して変数に保存しておき、後からブロック付きメソッドに渡すことも出来ます。それを実現するのが手続きオブジェクト(Proc)です。それをブロックとして渡すにはブロック付きメソッドの最後の引数として & で修飾した手続きオブジェクトを渡します。Proc の代わりにメソッドオブジェクト(Method)を渡すことも出来ます。この場合、そのメソッドを呼ぶ手続きオブジェクトが生成され渡されます。

# 1引数の手続き(その働きは引数をpで印字すること)を生成し、変数pobjに格納
pobj = proc {|v|
  p v
}

p [1,2,3].each(&pobj) # 手続きオブジェクトをブロックの代わりに渡している
# => 1
#    2
#    3

to_proc メソッドを持つオブジェクトならば、& 修飾した引数として渡すことができます。デフォルトで Proc、Method オブジェクトは共に to_proc メソッドを持ちます。to_proc はメソッド呼び出し時に実行され、Proc オブジェクトを返すことが期待されます。

class Foo
  def to_proc
    Proc.new {|v| p v}
  end
end

p [1,2,3].each(&Foo.new)
# => 1
#    2
#    3

ブロック付きメソッドの戻り値は、通常のメソッドと同様ですが、ブロックの中から 制御構造/break により中断された場合は nil を返します。

break に引数を指定した場合はその値がブロック付きメソッドの戻り値になります。

yield

自分で定義したブロック付きメソッドでブロックを呼び出すときに使います。 yield に渡された値はブロック記法において | と | の間にはさまれた変数(ブロックパラメータ)に代入されます。

yield data

yield `(' [式 [`,' 式 ... ]] `)'
yield [式 [`,' 式 ... ]]

引数をブロックパラメータとして渡してブロックを評価します。yield はイテレータを定義するために クラス／メソッドの定義/メソッド定義 内で使用します。

# ブロック付きメソッドの定義、
# その働きは与えられたブロック(手続き)に引数1, 2を渡して実行すること
def foo
  yield(1,2)
end

# fooに「2引数手続き、その働きは引数を配列に括ってpで印字する」というものを渡して実行させる
foo {|a,b|
  p [a, b]
}  # => [1, 2] (要するに p [1, 2] を実行した)

# 今度は「2引数手続き、その働きは足し算をしてpで印字する」というものを渡して実行させる
foo {|a, b|
  p a + b
}  # => 3 (要するに p 1 + 2 を実行した)

# 今度のブロック付きメソッドの働きは、
# 与えられたブロックに引数10を渡して起動し、続けざまに引数20を渡して起動し、
# さらに引数30を渡して起動すること
def bar
  yield 10
  yield 20
  yield 30
end

# barに「1引数手続き、その働きは引数に3を足してpで印字する」というものを渡して実行させる
bar {|v|
  p v + 3
}
# => 13
#    23
#    33 (同じブロックが3つのyieldで3回起動された。
#        具体的には p 10 + 3; p 20 + 3; p 30 + 3 を実行した)

# Array#eachの(粗製乱造の)類似品
def iich(arr) # 引数に配列を取る
  idx = 0
  while idx < arr.size
    yield(arr[idx]) # 引数の各要素毎に、その要素を引数にしてブロックを起動
    idx += 1
  end
end

sum = 0
iich([1, 4, 9, 16, 25]) {|elem|
  sum += elem
}
p sum # => 55

ブロックパラメータの代入は演算子式/多重代入と同じルールで行われます。また yield を実行したメソッドにブロックが渡されていない (ブロック付きメソッド呼び出しではない)時は例外 LocalJumpError が発生します。

yield はブロック内で最後に評価した式の値を返します。また、 制御構造/next によりブロックの実行が中断された場合は nil を返します。

next に引数を指定した場合はその値が yield の戻り値になります。

ブロックパラメータの挙動

メソッド呼び出しと挙動が異なります。 lambda でないブロックを呼び出したとき

• 引数の数が違ってもエラーになりません。
• 配列をひとつ渡したときにそれが引数の並びとして展開されることがあります。

def foo
  yield 1,2,3
end

p foo{|v| p v}     #=> 1

def bar
  yield [1,2,3]
end

p bar{|a, b, c| p a} #=> 1

def hoge
  yield [1,2,3],4,5
end

p hoge{|a, b, c| p a} #=> [1,2,3]

http://www.a-k-r.org/d/2007-08.html#a2007_08_16_1

番号指定パラメータ

ブロックに渡された値を参照するには、上記のようにブロックパラメータを定義する方法のほか、_1 や _2 といった暗黙に定義される変数を用いる方法もあります。この変数のことを番号指定パラメータ（Numbered parameters）と言います。番号指定パラメータは、_1 から _9 までの9つが使用可能です。

def foo
  yield "a", "b", "c"
end

p foo{|a, b, c| p [a, b, c] } # => ["a", "b", "c"]
p foo{ p [_1, _2, _3] } # => ["a", "b", "c"]

ブロックパラメータと番号指定パラメータを同時に使うことはできません。

def foo
  yield "a","b","c"
end

foo {|a, b, c| p [_1, a] } # => ordinary parameter is defined (SyntaxError)

なお、ブロック内で _2 以降が使用されているかどうかで、_1 の意味が異なります。

def foo
  yield ["a", "b", "c"]
end

foo {
  p _1 # => ["a", "b", "c"]
}
foo {
  p _1 # => "a"
  p _2 # => "b"
}

これは、ブロックパラメータを定義した個数によって代入される値が異なることに対応します。

def foo
  yield ["a", "b", "c"]
end

foo {|a|
  p a # => ["a", "b", "c"]
}
foo {|a,b|
  p a # => "a"
  p b # => "b"
}

.() および ::() 形式のメソッド呼び出し（callメソッドの糖衣構文）

下記はcallメソッドの糖衣構文です。 Proc#callにも言及がありますが、Proc以外のオブジェクトに対しても（callメソッドさえ定義されていれば）使えます。

foo.(100)      # foo.call(100)と全く同じ意味
foo::(100)     # foo.call(100)と全く同じ意味

式  `.' `(' [[`*'] 式] ... [`&' 式] `)'
式 `::' `(' [[`*'] 式] ... [`&' 式] `)'