Rubyでのメソッドディスパッチの仕組み

翻訳者のメモ：



みなさんこんにちは。 この記事は無料の翻訳です（最後のリンク）。 私は100％正しい翻訳のふりをしません。 しかし、私は、起こっていることの一般的な本質が完全に伝えられたと信じています。



この記事は誰に役立つでしょうか？ おそらく、Rubyの作業のいくつかのポイントを理解したいだけのRuby on Rails開発者の初心者向けです。



この記事は誰にとっても役に立ちませんか？ 最も可能性が高いのは、純血種のRubyプログラマーと筋金入りのRuby on Rails開発者です。 すでにこれを知っている可能性が高いです。



なぜ翻訳したのですか？ この記事は私にとっては面白そうで、ロシア語を話す（おそらく知識の乏しい）コミュニティ全体と共有したいという思いがありました。



PS英語を知っているなら、最後のリンクをたどってください。



以下は翻訳のテキストです。



先日、Rubyのオブジェクトとメソッドディスパッチシステムについての簡単でわかりやすい説明を誰かが知っているかどうかを皆に尋ねました。 そして、一部の人々の答えは「いいえ、あなたはそれについて書くべきです」でした。 だからここに記事があります。 メソッド検索、継承、スーパークラス、クラス、ミックスイン、シングルトンメソッドなど、Rubyのオブジェクトシステムがどのように機能するかを説明します。 私の理解は、MRIのソースを読むことからではなく、JavaScriptで一度、ルビーで一度、このシステムを再実装したことから来ました。 小さくてもほとんど正しい実装を読みたい場合は、ここから始めるのが良いでしょう。



実際にソースを読んでいなかったため、この記事では、実際に起こっていることの観点からではなく、論理の観点からルーブルで起こっていることを説明します。 これは、いくつかのことを理解できる単なるモデルです。



やり直しましょう。 モジュールからのみ、カットのオブジェクトのシステムをほぼ完全に作成できます。 モジュールはメソッドのバッグと考えてください。 たとえば、モジュールAにはメソッドfooとbarが含まれています。

+----------+ | module A | +----------+ | def foo | | def bar | +----------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

def foo ... endをモジュールruby内で記述すると、このメソッドがモジュールに追加されます。それだけです。 モジュールには複数の親を含めることができます。 あなたが書くとき：

 module B include A end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

AをBの親として追加するだけです。メソッドはコピーされません。BからAへのポインターを作成するだけです。

  +-----------+ | module A | +-----------+ | def foo | | def bar | +-----------+ ^ | +-----+-----+ | module B | +-----------+ | def hello | | def bye | +-----------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

モジュールは複数の親を持つことができ、それによってツリーが形成されます。 たとえば、これらのモジュール：

 module A def foo ; end def bar ; end end module B def hello ; end def bye ; end end module C include B def start ; end def stop ; end end module D include A include C end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それらは、包含の順序に従って、このツリーを形成します。

  +-----------+ | module B | +-----------+ | def hello | | def bye | +-----------+ ^ +-----------+ +-----+-----+ | module A | | module C | +-----------+ +-----------+ | def foo | | def start | | def bar | | def stop | +-----------+ +-----------+ ^ ^ +-------------------+-------------------+ | +-----+-----+ | module D | +-----------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

メソッドを定義する場所をRubyがどのように検索するかを説明する重要なポイントは、モデルの「血統」（モジュールの「祖先」）です。 モジュールに「血統」を提供するように依頼すると、モジュールの配列の形式で提供されます。

 >> D.ancestors => [D, C, B, A]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

重要なことは、それが木の形ではなく、単純なチェーンの形の血統であることです。 このチェーンは、メソッドを見つけるためにモジュールを反復する順序を決定します。 このリストを作成するために、Dから始めてより深く潜り、すべての親を右から左に見ていきます。 したがって、インクルードコールの順序は非常に重要です。 モジュールの親は順番に並べられ、これにより検索される順番が決まります。



メソッドが定義されている場所を見つけたいときは、定義されている最初のモジュールが見つかるまで継承チェーンを調べます。 モジュールにこのメソッドが含まれていない場合は、再度検索しますが、今回はmethod_missingというメソッドを探しています。 モジュールにメソッドが含まれていない場合、NoMethodError例外がスローされます。 モジュール継承チェーンは、2つのモジュールに同じメソッドが含まれる場合の問題を解決します。 モジュールが継承チェーンの最初であるメソッドが呼び出されます。



ハックの機能を使用して、呼び出したときに誰のメソッドが使用されたかを判断できます。

 >> D.instance_method(:foo) => #<UnboundMethod: D(A)#foo> >> D.instance_method(:hello) => #<UnboundMethod: D(B)#hello> >> D.instance_method(:start) => #<UnboundMethod: D(C)#start>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

UnboundMethodは、オブジェクトにバインドされる前のモデルのメソッドの単なる表現です。 D（A）#fooが表示された場合、DはAから#fooメソッドを継承したことを意味します。Dを含むオブジェクトで#fooを呼び出すと、Aで定義されたメソッドが取得されます。



オブジェクトといえば、なぜここまでやらなかったのですか？ それを適用できるオブジェクトがなければ、メソッドのバッグは良いものです。 そこで、ここでクラスが実行されます。 Rubyでは、クラスはモジュールのサブクラスであり、奇妙に聞こえますが、メソッドを格納するデータ構造であることに注意してください。 クラスは、メソッドを格納し、他のモジュールを含めることができるという観点からは、ほとんどモジュールに似ていますが、いくつかの追加機能があります。 その1つは、オブジェクトを作成する機能です。

 class K include D end k = K.new
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

オブジェクトのメソッドがどこから来たのかを判断する機会が再びあります。

 >> k.method(:start) => #<Method: K(C)#start>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは、k.startを呼び出すと、モジュールCから#startメソッドを取得することを示しています。モジュールのinstance_methodを呼び出すと、UnboundMethodが返され、Methodオブジェクトの場合は返されます。 違いは、メソッドがオブジェクトに関連付けられていることです。 オブジェクトに対して#callを呼び出すと、動作はk.startと同じになります。 UnboundMethodsは、次のように直接呼び出すことはできません それらを呼び出すことができるオブジェクトはありません。



オブジェクトが属するクラスから始まるメソッドを探しているように見えます。次に、メソッドを定義する場所が見つかるまで、継承チェーン全体を調べます。 まあ、それはほとんど真実ですが、もう一つの秘trickがあります：シングルトンメソッド。 クラスに追加せずに、新しいメソッドをオブジェクトに追加できます。このオブジェクトにのみ追加できます。 参照：

 >> def k.mart ; end >> k.method(:mart) => #<Method: #<K:0x00000001f78248>.mart>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

また、モジュールに追加することもできます。 モジュールはオブジェクトの一種です。

 >> def B.roll ; end >> B.method(:roll) => #<Method: B.roll>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

メソッド名にハッシュ（＃）の代わりに（。）が含まれる場合、これはメソッドがモジュール内にあるのではなく、このオブジェクトに対してのみ存在することを意味します。 ただし、Rubyはモジュールを使用してメソッドを保存すると以前に述べました。 単純な古いオブジェクトには、このような機会はありませんでした。 それでは、シングルトンメソッドはどこに保存されますか？



rubyの各オブジェクト（および、モジュールとクラスもオブジェクトであることを忘れないでください）には、シングルトンクラス、固有クラス、または仮想クラスとも呼ばれる、いわゆるメタクラスがあります。 これらのクラスの仕事は、オブジェクトのシングルトンメソッドを保存することです。 最初は、メソッドは含まれず、唯一の親としてオブジェクトクラスがあります。 オブジェクトkの場合、継承チェーンは次のようになります。

  +-----------+ | module B | +-----------+ ^ +-----------+ +-----+-----+ | module A | | module C | +-----------+ +-----------+ ^ ^ +-------------------+-------------------+ | +-----+-----+ | module D | +-----------+ ^ +-----+-----+ | class K | +-----------+ ^ +-----+-----+ +---+ | metaclass |<~~~~~~~~+ k | +-----------+ +---+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

オブジェクトのメタクラスを表示するようRubyに依頼できます。 ここで、メタクラスはオブジェクトkにアタッチされた匿名クラスであり、Kクラスには存在しないインスタンスメソッド#martがあることがわかります。

 >> k.singleton_class => #<Class:#<K:0x00000001f78248>> >> k.singleton_class.instance_method(:mart) => #<UnboundMethod: #<Class:#<K:0x00000001f78248>>#mart> >> K.instance_method(:mart) NameError: undefined method `mart' for class `K'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

注目に値する点の1つは、メタクラスが継承チェーンに表示されないことですが、メソッドが定義されている場所の検索チェーンに関与していることを理解する必要があります。



オブジェクトkのメソッドを呼び出すと、オブジェクトはメタクラスにこのメソッドが含まれているかどうかを尋ね、メタクラスはさらにメソッドの場所を決定するために継承チェーンを調べます。 シングルトンメソッドはメタクラスにあり、オブジェクトのクラスとそのすべての親で定義されているメソッドよりも優先されます。



現在、オブジェクトを作成する機能に加えて、クラスの2番目の特別なプロパティに近づいています。 クラスには、サブクラス化と呼ばれる特別な形式の継承があります。 各クラスにはスーパークラスが1つだけあり、デフォルトではオブジェクトです。 メソッド呼び出しの観点から、スーパークラスはクラスの最初の親モジュールと考えることができます。

 class Foo < Bar class Foo include Extras =~ include Bar end include Extras end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、継承チェーンはどちらの場合も[Foo、Extras、Bar]を提供し、以前と同様にメソッド検索の順序を決定します。 （実際には、この[Foo、Extras、Bar、Object、Kernel、BasicObject]のように見えますが、すぐに見ていきます）。 Rubyは、クラスのインクルードを許可しないことにより、リスコフの置換の原則に違反することに注意してください。この方法で使用できるのはモジュールのみで、サブタイプは使用できません。 上記のスニペットは、サブクラス化がメソッドの検索順序にどのように影響するかを示しています。Barがクラスの場合、右側のコードは機能しません。



サブクラス化が包含と同じ場合、なぜこれらの機能の両方が必要なのですか？ まあ、それは私たちに別の機会を与えます。 クラスはスーパークラスからシングルトンメソッドを継承しますが、これはモジュールでは発生しません。

 module Z def self.z ; :z ; end end class Bar def self.bar ; :bar ; end end class Foo < Bar include Z end # Singleton methods from Bar work on Foo ... >> Bar.bar => :bar >> Foo.bar => :bar # ... but singleton methods from Z don't >> Zz => :z >> Foo.z NoMethodError: undefined method `z' for Foo:Class
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サブクラスメタクラスには親としてスーパークラスメタクラスがあると言うことで、これを親の観点からモデル化できます。

  +-----+ +--------------+ | Bar +~~~~~~~~>| #<Class:Bar> | +-----+ +--------------+ ^ ^ | | +--+--+ +-------+------+ | Foo +~~~~~~~~>| #<Class:Foo> | +-----+ +--------------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

実際、Fooを見ると、その#barメソッドがメタクラスBarから来ていることがわかります。

 >> Foo.method(:bar) => #<Method: Foo(Bar).bar> >> Foo.singleton_class.instance_method(:bar) => #<UnboundMethod: #<Class:Bar>#bar>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ルーブル内のメソッドの継承と検索順序を、包含とサブクラス化を含むモジュールのツリーとして表現し、異なる親関係を作成する方法を見ました。 また、オブジェクトメソッドとシングルトンメソッドの単一および複数の継承についても説明しました。 ここで、このモデルの先端にあるいくつかのことを見てみましょう。



1つ目はObject＃extendメソッドです。 object.extend（M）を呼び出すことにより、モジュールMのメソッドをオブジェクトで使用できるようにします。 メソッドをコピーするのではなく、このオブジェクトのメタクラスの親としてMを追加するだけです。 オブジェクトにThingクラスがある場合、次の関係が得られます。

  +-------+ +-----+ | Thing | | M | +-------+ +-----+ ^ ^ +-------+-----+ | +--------+ +---------+-------+ | object +~~~~~~~~>| #<Class:object> | +--------+ +-----------------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、モジュールを使用したオブジェクトの拡張は、オブジェクトのメタクラスにこのモジュールを含めることと同じです。 （実際、いくつかの違いがありますが、これはこのトピックには適用されません）。 このツリーを見ると、オブジェクトのメソッドを呼び出すと、メソッドのディスパッチシステムはThing（Mのメソッドが使用されます）よりもモジュールMで定義されたメソッドを優先し、次に、メタクラスオブジェクトは、MおよびThingよりも優先されます。



このコンテキストは重要です。一般的な意味では、MのメソッドがThingよりも優先されるとは言えませんが、オブジェクトメソッドの呼び出しについて話すときだけです。 メソッドが求められる継承の連鎖が重要です。 そして、これは、スーパーの仕事を調べるときに現れます。 次のモジュールセットをご覧ください。

 module X def call ; [:x] ; end end module Y def call ; super + [:y] ; end end class Test include X include Y end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Testの継承チェーンは次のとおりです：[Test、Y、X]。したがって、Test.new.callを呼び出すと、Yから#callメソッドを呼び出します。しかし、Yがsuperを呼び出すとどうなりますか？ Yには独自の継承チェーンがありません。つまり、Yがこのメソッドを呼び出すことができる人はいません。



しかし、ありません。 スーパーコールに出くわしたとき、重要なことは、オブジェクト継承チェーンへのメソッド呼び出しを行ったことです。それだけです。 メソッドの検索は、オブジェクトのメタクラスの継承チェーン内の特定のメソッドのすべての定義の検索として想像できます。

 >> t = Test.new >> t.singleton_class.ancestors.map { |m| m.instance_methods(false).include?(:call) ? m.instance_method(:call) : nil }.compact => [#<UnboundMethod: Y#call>, #<UnboundMethod: X#call>]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

メソッドの場所を決定するために、継承チェーンの最初のメソッドを呼び出します。 このメソッドがsuperを呼び出した場合、検索が完了するまで次のメソッドにジャンプします。 TestにモジュールXが含まれていない場合、Yで定義されたもの以外の#call実装はないため、superを呼び出すとエラーになります。



実際、この場合、Test.new.callは[：x ,: y]を返します。



ほぼ完了しましたが、Object、Kernel、BasicObjectが何であるかを説明することを約束しました。 BasicObjectはシステム全体のルートクラスです。 これはスーパークラスのないクラスです。 オブジェクトはBasicObjectを継承し、すべてのユーザークラスの基本スーパークラスです。 それらの違いは、BasicObjectにはメソッドがほとんどないのに対し、Objectには多くのメソッドがあるということです：＃==、＃__ send __、＃dup、＃inspect、＃instance_eval、＃is_a？、＃などのコアメソッドをカットします。メソッド、＃respond_to？、および#to_s。 実際、オブジェクト自体にはこれらすべてのメソッドが含まれているわけではありませんが、カーネルから取得します。 カーネルは、Rubyカーネルのすべてのオブジェクトメソッドのセットを持つ単なるモジュールです。 したがって、rubyカーネルのオブジェクトのシステムを表示しようとすると、次のようになります。

  +---------------+ +------------+ | | | | | +-----------+----------+ +-------------+ +--------+ +--------+--------+ | | | #<Class:BasicObject> |<~~~~+ BasicObject | | Kernel +~~~~>| #<Class:Kernel> | | | +----------------------+ +-------------+ +--------+ +-----------------+ | | ^ ^ ^ | | | +-------+--------+ | | | | | | +--------+--------+ +----+---+ | | | #<Class:Object> |<~~~~~~~~~~~~~~~~+ Object | | | +-----------------+ +--------+ | | ^ ^ | | | | | | +--------+--------+ +----+---+ | | | #<Class:Module> |<~~~~~~~~~~~~~~~~+ Module |<-----------------------------------+ | +-----------------+ +--------+ | ^ ^ | | | | +--------+--------+ +----+---+ | | #<Class:Class> |<~~~~~~~~~~~~~~~~+ Class | | +-----------------+ +--------+ | ^ | | +-----------------------------------------------+
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この図は、Rubyカーネルのモジュールとクラス、BasicObject、Kernel、Object、Module、Class、それらのメタクラス、およびそれらがすべてどのように関連しているかを示しています。 はい、BasicObject.singleton_class.superclassはクラスです。 ルビーは、この樽型オルガンを得るためにちょっとしたブードゥー教の魔法をかけます（翻訳者のメモ）。 いずれにせよ、Rubyでのメソッドのディスパッチを理解する場合は、次のことを覚えておいてください。

• モジュールはメソッドのバッグです
• モジュールには多くの親を含めることができます。
• クラスは、オブジェクトを作成できるモジュールです。
• 各オブジェクトには、オブジェクトのクラスを親として持つメタクラスがあります
• サブクラス化は、2つのクラスとそれらのメタクラスのバインディングを指します
• メソッドは、ツリー「家系図」に浸漬し、枝を右から左に見て検索されます。

いいえ、私はこの仕事のすべての微妙さを知りません。 誰も知らない。



元の記事： blog.jcoglan.com/2013/05/08/how-ruby-method-dispatch-works