把示例变量看作是存在于包含模块的任何类中的东西，这样就更有意义了：

module Stacklike
  def stack
    @stack ||= []
  end

  def add_to_stack(obj)
    stack.push(obj)
  end

  def take_from_stack
    stack.pop
  end
end

class ClownStack
  include Stacklike

  def size
    @stack.length
  end
end

cs = ClownStack.new
cs.add_to_stack(1)
puts cs.size

将输出“1”

参见以下内容：

p RUBY_VERSION
module Stacklike
  def stack
    @stack ||= []
  end

  def add_to_stack(obj)
    stack.push(obj)
  end

  def take_from_stack
    stack.pop
  end
end

class A
include Stacklike
end

a = A.new
p a.instance_variables #<~~ E
p a.instance_variable_defined?(:@stack) #<~~ A
a.add_to_stack(10) #<~~ B
p a.instance_variable_defined?(:@stack) #<~~ C
p a.instance_variables #<~~ D

• 输出：*

"1.9.3"
[]
false
true
[:@stack]

说明：是的，Module示例变量出现在class中，而您要在类中对它们执行include操作。但您可以看到p a.instance_variable_defined?(:@stack)显示false，因为@stack直到A才定义。在点B处，我定义了示例变量@stack。因此，点C中的语句输出为true。这意味着模块示例变量不是由模块本身创建的，但如果class包含该模块，则可以由class示例创建。E中的语句输出[]时仍显示为未定义示例变量的点，但如果您看到行D的输出，则证明@stack位于class A的对象a内部。
为何如此设计

这是设计或者有时来自需求。假设你被要求写一个栈操作代码，将被两家机票预订公司使用，比如说A和B。现在A是他们的客户要服务的堆栈策略，但他们也有更多的形式。B公司也使用堆栈策略，有自己的形式，与A不同。因此，在class A和class B内部设计Stack操作时，最好将其写在公共位置。因为A和B都有相同的功能。将来如果另一个公司C找你，你也可以在他们的类中使用那个模块，而不用为每个A重写相同的功能。B和C。可以有更多的想法，但希望这将帮助你回答你自己的最后一部分问题。
这就是所有的概念。希望它能有所帮助。
干杯！

当你在一个类中包含一个模块时，它的所有示例方法都被有效地“粘贴”到宿主类中。

class Lifo
  include Stacklike
end

l = Lifo.new
l.add_to_stack(:widget)

然后l现在有了一个示例变量@stack，它是从Stacklike引入的。

当你把模块Stacklike包含在其他类中时，示例变量就像是在那个类中定义的一样，这样你就可以选择从模块本身设置和处理基类的示例变量。

请注意，模块可以存储自己的示例变量，而不管它是否包含在类中。
考虑：

module Stacklike
  def self.stack(args = nil)
    @stack ||= (args)
  end
end

Stacklike.instance_variables
> []

Stacklike.stack("original stack")
> "original stack"

Stacklike.instance_variables
> [:@stack]

Stacklike.stack("new stack")
> "original stack"

当你定义模块StackLike时，这创建了一个名为StackLike的对象，它的类型为Class，因为它是一个对象，所以它可以有自己的示例变量，这些变量可以通过它的类方法访问。