呵呵

#10 楼 @chenge

@baxiaopeng 借花献佛

Class.superclass == Module; 
Module.superclass==Object; 
# (mixin Kernel)
Object.superclass == BasicObject;                      
BasicObject.superclass == nil
Kernel.class == Module
BasicObject.class = Class
Module.class == Class
Object.class == Class                     
Class.class == Class

以上错综复杂的关系，我给它起了个名字：Ruby 云! ，Ruby 云孕育了 Ruby 世界！

先有鸡还是先有蛋？ Ask：Matz!

《元编程》有相似的图，最近有点心得，准备写一篇，到时请大家小拍。

@chenge

类是对像，对象不是类。

class MyClass;end obj=MyClass.new 请来个 obj 中有 new 吗，能添加 instance_method，然后 new 一个对象吗？ （obj.clone，obj.dup 不算，在 Javascript 中，基本可以说 对象是类，类是对象 )

#3 楼 @baxiaopeng @chenge

class MyClass;end
obj=MyClass.new

MyClass.instance_methods.length
MyClass.methods.length
obj.methods.length

MyClass.methods
Module.instance_methods(false)
Class.instance_methods(false)

```

#1 楼 @baxiaopeng ruby 毕竟不是 JavaScript。类是对象。不是普通对象。‘ 对象中不能定义常量，对象不能 new，对象没有 Module 中 instance_methods

#30 楼 @luikore

#14 楼 @chenge “铁打的营盘流水的兵..”可能指 wave.unshift(1) 不改变 wave.object_id，

wave = []
wave.object_id    
wave.unshift(1)
wave.unshift(1)
wave.object_id      #object_id 没变

wave=[1]
wave.object_id      #object_id 变了 

#24 楼 @luikore

x = 0
y = 0
loop do
  dot = '-' * ((1 + Math.sin(x += 0.018)) * ((1 + Math.sin(y += 0.15))) * 20)
  puts dot.center 80
  sleep 0.01
end

#4 楼 @luikore 借花献佛

x = 0
loop do
  space = ' ' * (30-((1+Math.sin(x+=0.15))*15))
  dot = '-' * ((1+Math.sin(x)) * 15) *2
  puts space + dot
  sleep 0.01
end

#37 楼 @kayakjiang 再来个嵌入

class C
  @name = "zhong3"
end

@name="li4"

ll = ->(word){p "#{word},#{@name}"}
C.singleton_class.send(:define_method,:say ,&ll)

C.say("hi")
#"hi,zhong3"

#35 楼 @kayakjiang ，代码块加引号就是字符串 ，来一个真的代码块嵌入：

class C
  def initialize(name)
    @name = name
  end
end
cc = C.new("zhong 3")

@name = "li 4"
cc.instance_eval{
  def hi
    p @name          #调用嵌入对象cc中的实例变量 @name
  end
}
cc.methods(false)   #检查嵌入的代码
#=>[:hi]    
cc.hi              #调用嵌入的代码
#=>"zhong 3"

好想法

#26 楼 @ericguo #19 楼 @goinaction “嵌入代码”只是便于理解。 block 更接近 method，传入的是 类似 Java 中的 “函数指针”。函数可以有调用参数。

#32 楼例子中的”张三“可以通过块参数进入块中，这时用带参数的块调用。

def m
  name = "张三"     
  yield(name)   #调用传入参数
end
name = "李四"                  #这次和李四没有关系了。
m{|name|p "hi, #{name}"}   #name 是参数
#=>"hi, 张三“

不绑定变量，嵌入代码：

def m(mimic) 
  name="zhang 3"
  instance_eval(mimic) 
end 
name = "li 4"
m %{p name}
#=>"zhang 3"

#26 楼 @ericguo #19 楼 @goinaction

我一直的笨办法就是记住：block 就是一段代码，call 的时候就是当前位置嵌入了代码；lambda 相当于一个方法，call 的时候就是方法调用

形象、好记忆。加一句“block 就是一段 绑定了当前作用域变量的代码，call 的时候就在当前位置嵌入了代码”，就更完整了。

def m
  name = "张三"   
  yield              #这里和“张三”没有关系
end

m{p "hi, #{name}"}
#NameError: undefined local variable or method `name' for main:Object
name = "李四"        #当前域生成了name变量
m{p "hi, #{name}"}   #这时,name绑定了   ----（1）
#=>"hi 李四"
name = "王 二"
p1 = lambda{p "hi, #{name}"}    #这时name绑定了， 速度比（1）慢
m(&p1)  
#=>"hi 王二"

m{p "hi, #{name}"} 时，生成了内部 Proc 的对象。

block 不是对象，可以转换成 Proc 对象，对象可以传递。

Proc 的对象 和 Method 的对象 可以相互转换。http://ruby-china.org/topics/10470

#3 楼 @skandhas 很早就接触 ruby，一直没有认真

#7 楼 @jasl 谢谢分享喜感网，不错

#1 楼 @lgn21st谢谢，本人也刚开始认真学，请多指教。gravatar 上不了呀

#3 楼 @luikore If it walks like a duck, quacks like a duck, then we can eat it as a duck...

#1 楼 @chenge 多谢，已改正

zputee#gmail.com 感谢

学习了，谢谢

 thanks