インスタンスのクラスのextendメソッドが継承とは異なる動作をするのはなぜですか？

まず、いくつかの概念を紹介します。

まず、を使用してクラスメソッドをdef self.a定義することは、クラスのシングルトンクラスでメソッドを定義することと同じです。

class C
  def self.a; end

  class << self
    def b; end
  end
end

C.method(:a) # => #<Method: C.a>
C.method(:b) # => #<Method: C.b>

さらに、オブジェクトのメソッドは、そのオブジェクトのシングルトンクラスのインスタンスメソッドです。

C.singleton_class.instance_method(:a) # => #<UnboundMethod: #<Class:C>#a>
C.singleton_class.instance_method(:b) # => #<UnboundMethod: #<Class:C>#b>

#b上記で定義した方法を見るとself、プレフィックスが付いていないことがわかります。したがって、これは単なるインスタンスメソッドです。

次に、シングルトンクラス#extendと同じ#includeです。

module M; end

class C1
  extend M
end

class C2
  class << self
    include M
  end
end

C1.ancestors # => [#<Class:C2>, M, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
C2.ancestors # => [#<Class:C1>, M, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

通知はどのようにM今の祖先の一部であるC1とC2同じようインチ

含める（または拡張する）Mことも、次のように達成できます。

C1.extend M
C2.singleton_class.include M

最後に、#includeモジュールを作成すると祖先がどうなるかに注意してください。

module M1; end
module M2; end
class C; end

C.include M1
C.ancestors # => [C, M1, Object, Kernel, BasicObject]

C.include M2
C.ancestors # => [C, M2, M1, Object, Kernel, BasicObject]

すべては、#include（受信した後に挿入されたモジュールが得られC先祖連鎖この場合）。

それでは、あなたの定義を見てみましょう（本文を省略します）：

module B; end

class A
  extend B
end

覚えておいてください、#extendと同じである#includeに#singleton_class。したがって、次のように書き直すことができます。

module B; end
class A; end
A.singleton_class.include B

シングルトンクラスの祖先は、B最初の項目の後にあります。これは、Aクラスメソッドが定義されているシングルトンクラスです（したがって、クラスメソッドは、問題のクラスのシングルトンクラスのインスタンスメソッドにすぎないことに注意してください）。

A.singleton_class.ancestors # => [#<Class:A>, B, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

コードの2番目の部分に移ります。

a = A.new
a.extend B

を使用して書き直します#include：

a = A.new
a.singleton_class.include B

祖先を確認しましょう：

a.singleton_class.ancestors # => [#<Class:#<A:0x00007f83e714be88>>, B, A, Object, Kernel, BasicObject]

この場合も#include、モジュールを祖先チェーンの最初の要素の後に配置し、結果として。のB前に配置しましたA。

これは、（つまり）に送信#aするときに、に応答する最初の祖先を探すことを意味します。この場合はそうです。次に、を呼び出します。これは、に応答する祖先チェーンに沿って続行されます。aa.a#aBBsuperA#a

さてA.a、それは異なります。Aのシングルトンクラスの祖先を思い出してください。

A.singleton_class.ancestors # => [#<Class:A>, B, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

のB後に来ることに注意してください#<Class:A>。のクラスメソッドである、に#<Class:A>すでに応答しています。そのメソッドはを呼び出さないため、は呼び出されません。したがって、同じ出力は得られません。#aAsuperB#a

あなたが持っているしたい場合はB前に#<Class:A>、あなたはプリペンドBにする必要があると思いますAのシングルトンクラス。最初のアイテムの後に#prependオブジェクトを挿入する、とは異なり#include、祖先チェーンの最初にオブジェクトを挿入します（これを機能させるにextend Bは、コード内のを削除する必要があります。そうしないBと、すでに祖先である場合は何も起こりません）。

A.singleton_class.prepend B
A.singleton_class.ancestors # => [B, #<Class:A>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

呼び出すA.aと、と同じa.a、つまりprintが生成されますBA。