Example.instance_eval{ def square(n); n*n; end }
Example.square(2) #=> 4
# you can pass instance_eval a string as well.
Example.instance_eval "def multiply(x,y); x*y; end" 
Example.multiply(3,9) #=> 27

至于上面的区别,你会混淆2件事情：

你定义的元类是在Ruby社区中叫做singelton类或者eigen类的.那个单例类是你可以添加类(单例)方法的类.

对于您尝试使用class_instance方法定义的类实例,只不过是类本身,以证明它,只需尝试向类Example添加实例方法,并检查您定义的class_instance方法是否返回类示例本身通过检查该方法的存在：

class Example
  def self.Meta; (class << self; self; end); end
  def self.class_instance; self; end
  def hey; puts hey; end
end

Example.class_instance.instance_methods(false) #=> ['hey']

无论如何,为了总结它,当你想添加类方法,只需将它们添加到该元类.至于class_instance方法是无用的,只需删除它.

无论如何,我建议你阅读this post来掌握Ruby反思系统的一些概念.

UPDATE

我建议你阅读这个漂亮的帖子：Fun with Ruby’s instance_eval and class_eval,
不幸的是,class_eval和instance_eval是混乱的,因为他们以某种方式反对他们的命名！

Use ClassName.instance_eval to define class methods.

Use ClassName.class_eval to define instance methods.

现在回答你的假设：

If I have an instance method which
calls self.instance_eval and defines a
method,it will only affect the
particular instance of that class.

是：

class Foo
  def assumption1()
    self.instance_eval("def test_assumption_1; puts 'works'; end")
  end
end

f1 = Foo.new
f1.assumption1
f1.methods(false) #=> ["test_assumption_1"]
f2 = Foo.new.methods(false) #=> []

If I have an instance method which
calls self.class.instance_eval (which
would be the same as calling
class_eval) and defines a method it
will affect all instances of that
particular class resulting in a new
instance method.

在该上下文中没有instance_eval将定义类本身上的单例方法(不是实例)

class Foo
  def assumption2()
    self.class.instance_eval("def test_assumption_2; puts 'works'; end")
  end
end

f3 = Foo.new
f3.assumption2
f3.methods(false) #=> []
Foo.singleton_methods(false) #=> ["test_assumption_2"]

为了工作,将上述的class_eval替换为instance_eval.

If I have a class method which calls
instance_eval and defines a method it
will result in a new instance method
for all instances.

不：

class Foo
  instance_eval do
    def assumption3()
      puts 'works'
    end
  end
end

Foo.instance_methods(false) #=> []

Foo.singleton_methods(false) #=> ["assumption_3"]

这将使单例方法,而不是实例方法.为了工作,将上述的class_eval替换为instance_eval.

If I have a class method which calls
instance_eval on the Meta/eigen class
and defines a method it will result in
a class method.

好吧,那会做出如此复杂的东西,因为它会添加单例方法到单身阶级,我不认为这将有任何实际的用途.