zputee (zputee)

Ruby 的类变量 (修正版)

zputee — Sun, 05 May 2013 10:17:37 +0800

昨天和@zgm 等等的讨论，收益良多，感谢

昨天关于类变量的帖子，写的比较匆忙，论证不严谨，更主要水平有限，所以重新写了一篇。本文从类变量读写的角度，更清晰一些。

一、类变量的赋值 在本类的 ancestors，反向查找。（即 Ojbect 中的类变量最优先----从 Object 类开始查找） --> 找到，直接赋值 --> 找不到，在本类上创建类变量。

二、类变量的读取 在本类的 ancestors，反向查找。 --> 在父类中找到：返回父类中的类变量。(如果本类的有同名的类变量，同时被删除。) --> 在本类中找到：返回本类中的类变量。

--> 找不到：报错。

三、singleton 方法定义其他类中时，在外层类中查找（方法同以上）。

一、类变量的赋值

@@v = 100
Object.class_variables 

#1.在本类的ancestors，反向查找，父类Object有@@v
class C
  @@v = 90   #向父类中的@@v赋值。
end
@@v       #=>90
C.class_variables  #=>[]
Object.class_variables #[:@@v]

#2.反向查找，父类中无@@v1,
class C
  @@v1 = 80  #在C中创建类变量@@v1
end
C.class_variables   #=>[:@@v1]
Object.class_variables  #=[:@@v]

二、类变量的读取

@@w  = 111
Object.class_variables #[:@@w]

#1.反向查找，在父类Object中找到了
class C
  p @@w    #=>111 ,返回父类中的@@w
end
C.class_variables  #=>类C中无@@W

#----------------------------------------------------
#准备工作
class C
  @@w2 = 222        #新定义C类变量
end
@@w2 = 333          #在Object上，定义@@w2 
Object.class_variables  #=>Object中有@@w2
C.class_variables   #=>C中有@@W2
#现在父类Object和C类中都有@@w2

#2.开始读类变量。反向查找，在父类Object中找到了
C.class_variable_get :@@w2  #=>333  #读出Object中@@w2,  删除本类中的@ww2  
C.class_variables   #=>[]   #C中已经无@@w2
Object.class_variables  #=>Object有@@w2

三、singleton 方法定义其他类中时，在外层类查找。

#与外层不同类的single方法中，在外层类中查找！！
class A; @@v = "A"; end
class B; @@v = "B"; end
class C < A; end
 #B中有@@V, 类C的父类A 中也有@@v
class B     
  def C.v    
    @@v    #读方法外层类B中的@@v
   end       
end
C.v   #=>B

Ruby 的类变量

zputee — Sat, 04 May 2013 15:49:30 +0800

昨天（2013-5-4) 本帖子，写的比较匆忙，论证不严谨，更主要水平有限，和@zgm 等等的讨论，深受启发，收益良多，感谢

今天，重新写了一篇。http://ruby-china.org/topics/10715，从类变量读写的角度，更易理解。

附上新贴的三条主要观点。 一、类变量的赋值 在本类的 ancestors，反向查找。（即 Ojbect 中的类变量最优先----从 Object 类开始查找） 1.找到，直接赋值 2.找不到，在本类上创建类变量。 二、类变量的读取 在本类的 ancestors，反向查找。 1.在父类中找到：返回父类中的类变量。(如果本类的有同名的类变量，同时被删除。) 2.在本类中找到：返回本类中的类变量。 3.找不到：报错。三、singleton 方法定义其他类中时，在外层类及父类中读取类变量（方法与上面两点，基本相同)。

原观点，比较难于理解，所以

加了下划线，没有删除。^_^

~~在动态编程时，ruby 的类变量很容易出错。~~ ~~方法中访问类变量~~ ~~1. 方法定义的外层类的类变量。（外层，方法定义的静态位置！！！，注意 singleton 方法）~~ ~~2. 外层类的父类的 ancestors，反向查找。Ojbect 中的类变量最优先！~~ ~~3. inluded_modules 中查找。~~

~~类定义中的类变量~~ ~~1 .本类中的类变量。~~ ~~2. 父类的 ancestors，反向查找。Ojbect 中的类变量最优先！~~ ~~3. inluded_modules 中查找。~~

一、方法的外层类是 Object 类。

class C; @@var = 1; end
def C.hi2
  @@var
end   
C.hi2            #err 因为此时方法的外层类是Ojbect，
self.class.class_variable_defined? :@@var  #=>false, Object类无@@var类变量，所以出错。

#这时可以使用class_eval方法切换 context
C.class_eval %{         
  def self.hi3;@@var; end
}
C.hi3   #=>1

#--多谢12楼 @zgm 指出， 下面D2例子有错---------------------------------
class C2;@@var2 = 200;end 
class D
  def self.hi1          #外层D类中没有定义@@var
    @@var
  end
end
D.hi1   #err
class C2
  def D.hi;@@var;end    # 方法的外层类的类变量@@var=200
end
D.hi   #=>200
#--- 方法的外层类中没有定义@@var=200,所以报错。这验证了关于外层的结论。----------------

二、父类 Object 中的@@var 覆盖子类 C3 中的@@var

class C3; @@var3=100; end
class C33 < C3           
  def self.hi
     @@var3     #可以访问父类C3中的类变量
  end
end
C33.hi  #=>100

@@var3 = 200    #总父类Object中的@@var3，优先C3中的@@var
C33.hi  #=>>200
class C33
  @@var = 300   #修改的是Object类中的@@var
end
C33.hi     #=>300
@@var   #=>300

三、模块中的类变量（容易出错!!!）

module Mm; @@m=800; end
class CC
  include Mm
  def self.hi
    @@m
  end
end
CC.hi          #=>800
class CC2 < CC
  @@m = 900    #=>覆盖了Mm中的@@m
end
CC2.hi       #=>900
Mm.class_variable_get :@@m  #=>900,已经改变了Mm中的@@m

class CC3
  include Mm
  @@m    #=>这里@@m已经为900了！！！
end

四、class 关键字是类变量的切换门（静态位置）

class Q
  @@q= 1
  class Q2                      #class关键字，类变量门, 访问不到外层了。
    def self.hi
      @@q                      #访问不到外层的@@q
    end
  end
  @@q
end
Q::Q2.hi    #=>err  Q2中无类变量@@q

五、静态位置 > 继承 > include

# 静态位置优先与继承
class W; @@w = 1;end
class W11 < W; end
class W1x 
  @@w =2
  def W11.hi
      @@w
  end
end
W11.hi           #=>2 , ( 静态位置优先与继承）
W11.class_variable_get :@@w  #=>1

#----------------------------------------------
# 继承优先 include
class W2; @@w2=1; end
module M2  @@w2 =2; end
class W22 <W2 
  include M2
  p  @@w2       #=>1, 继承优先 include
end
M2.class_variable_get :@@w2  #=>2

#------------------------------------------------
# 静态位置有先与 include
module M3  @@w3 =2; end
class W3
  include M3
end
class W3x
  @@w3 = 1
  def W3.hi
      @@w3
  end
end
W3.hi     #=>3 , 静态位置有先与 include
W3.class_variable_get :@@w3  #=>2

总结

和常量类似，静态位置> 继承 > inlude
class 关键字是类变量空间切换门
Object 中的类变量，相当于全局变量。（如果在 Kernel 中猴子补丁可访问？）
父类中的类变量与子类中的同名类变量是同一个类变量。
singleton 方法定义中访问类中的类变量，可以用 class_eval 方法切换

Ruby 中的常量

zputee — Sat, 04 May 2013 11:57:43 +0800

看了http://ruby-china.org/topics/10654 7 楼的例子，很受启发。

常量，“戴帽”访问最好，如 M::N。
常量，搜索顺序
1. Module.nesting（静态位置)
2. include
3. Class inherence

一、静态位置（Module.nesting）优先 include。

module M ; N = 1; end
module M2
   N=2
  class C
    include M
    def self.n; N; end
  end
end

M2::C.n   #=>>2

.. 二、静态位置优先继承

class C1; N=1 ; end
class C2
  N=2                     #位置优先继承
  class C3 < C2              
    def self.n; N ; end
  end
end

C2::C3.n  #=>2

.. 三、include 优先继承

class C5; N=1 ; end
module M3; N=2 ; end

class C55 < C5            
  include M3         #include优先继承
  def self.n; N; end
end

C55.n     #=>2

关于类名常量

zputee — Mon, 29 Apr 2013 10:16:49 +0800

看了 RubyChina 关于常量的发言，引发了我对常量的兴趣：

类名为什么是常量？
类名常量的作用域？
类名常量和类的关系？ 感谢@chenge @lgn21st @luikore 等等的鼓励和指教，感谢 RubyChina。

一、类名为什么是常量？

#当前类是Object
self.class
#=>Object
#添加一个类C
class C ; end
Object.constants.grep  /^C$/ 
#=>[:C]      
#这时在当前类Object中添加了常量 :C
#:所以类名是常量。

二、这里的类名常量 C，为什么是所有作用域可见？

类名常量 C 添加在 Object 类中 Object 是所有类的 superclass（BasicObject 除外），所以在所有类中都可见。

如果：

module M 
  class C; end
end
Object.constants.grep  /^M$/ 
#=>[:M]
Object.constants.grep  /^C$/ 
#=>[]
M.constants
#=>[:C]

#---------关于 Kernel#load 方法的实验----------
#person.rb
#class Person; end

class C
  class D
    def self.init
      load './person.rb'     
     end
     init              #load到Object，而不是C::D
  end
end
Object.constants.grep /^C$|^Person$/
#=>[:C,:Person]
Object.constants.grep /^D$/
#=>[]
C.constants
#=>[:D]

三、类名常量 C 和类 C 的关系

#类名常量C是指向（reference）类C的对象

class C
  def hi
    p 'hi, in class C'
  end
end
#变量cc
cc = C           
cc.name
#=>"C"
cc.new.hi
#=> 'hi, in class C'         

#改变常量C，（实验需要，平时不建议改变常量^_^）
C = "i'm string now"   #assign
#=>warning.....        
#C还是常量
Object.constants.grep  /^C$/
#=>[:C]  
C
#=>"i'm string now"
#指向了String类的对象。

#变量cc没变，指向类C
cc.name
#=>"C"
cc.new.hi        
#=> 'hi, in class C'

#D是常量
D = cc         
Object.constants.grep  /^C$|^D$/
#=>[:C,:D]
D.name
#=>"C"
#常量D指向类C

#打开类C，添加方法sing
class D       # D是指向类C的常量!!!
  def sing
    'singing'
  end
end
#常量D和变量cc共同指向C类
D.instance_methods(false)  
cc.instance_methods(false)
#=>[:hi,:sing] 

#通过变量cc，向类C 添加方法
cc.send(:define_method, :dance){"dance"}  
cc.instance_methods(false)
D.instance_methods(false)
#=>[:hi,:sing,:dance]

ruby 的 Block，Proc，Lambda ---4

zputee — Fri, 26 Apr 2013 09:53:51 +0800

一、代码块不是对象。

#{p "hi"} 是代码块
#代码块不是对象。
 {p 'hi'}.class
#=>SyntaxError: unexpected '}', expecting $end

#所以代码块不能调用方法call
{p 'hi'}.call
#=>{p 'hi'}.call
#        ^

二、 &proc 只存在于方法和方法调用的参数中，但不是一般的参数。（&proc 像 Proc 类的对象的指针，可以这么理解，&proc 不是对象）

def m
  yield
end
pp = lambda{ p "hi, world"}
m(&pp)        #<---- &pp 方法调用的参数中, 但不是一般的参数。
#=>"hi, world"

pp            #是Proc的对象
"#<Proc: (lambda)>"
&pp            #不是对象
#=>SyntaxError: unexpected tAMPER, expecting $end

三、Proc 类的对象与 Method 类的对象很像，可带调用参数，它们可以相互转换。 http://ruby-china.org/topics/10470

def m
end
pp = lambda{p "hi, world"}
method(:m).class
#=>Method
pp.class
#=>Proc

动态添加类方法 (eigenclass --- 2)

zputee — Wed, 24 Apr 2013 21:51:46 +0800

类是类的 singleton_class 类（eigenclass 类）的实例对象 先有蛋还是先有鸡？类、类、类....，有点累吧，^_^

一、向类添加的实例方法，（添加类的 singleton_method）

class MyClass
end
a = MyClass.new
#方法1(动态)
MyClass.class_eval %{  
  def hi
    p "hi,world"
  end
}
#方法2(动态）
MyClass.send(:define_method, :hi2){p 'hi, world'}

#调用
a.hi
a.hi2
#=>"hi,world"
#检查
a.methods.grep /^hi+/
MyClass.instance_methods (false)

二、添加类方法，（添加类的 singleton_method）

class MyClass
end

#方法1，使用class_eval(动态）
MyClass.class_eval %{  
  def self.hi
    p "hi,world"
  end
}
#方法2，使用send(动态）
MyClass.singleton_class.send(:define_method, :hi2){p 'hi, world'}

#方法3, 打开MyClass.singleton_class (eigenclass)
class <<MyClass
  def hi3
    p "hi,world"
  end
end
MyClass.hi
MyClass.hi2
MyClass.hi3

MyClass.methods(false)
MyClass.singleton_methods(false)
MyClass.singleton_class.instance_methods(false)

三、向 engenclass 类方法，（可以继承，很少用!）

class <<MyClass #很少用
  def self.hello
    p "i'm in 'MyClass.singleton_classs.methods'"
  end
end
MyClass.singleton_class.hello
MyClass.singleton_class.methods(false)

动态添加对象的方法 ( eigenclass --- 1 )

zputee — Wed, 24 Apr 2013 20:55:54 +0800

一、简介 对象的 singleton_class，Matz 也称 eigenclass。表面上看不到，但它就像影子一样，一直伴随着对象，无处不在，比较神秘吧。

我给它起了别名，对象伴侣类。类也是对象，类也有对象伴侣类。

二、动态向对象添加方法，即对象的单例方法 (对象的 eigenclass 类的实例方法)

class MyClass
end
my_object = MyClass.new

#方法1
class << my_object
  def hello1
    p 'hello,world'
  end
end
#方法2 , send
my_object.singleton_class.send(:define_method, :hello2){'hello, world2 '}

#方法3，通过给类添加了实例方法
my_object.class.send(:define_method, :hello3){'hello, world3 '}

#方法4（等效）
my_object.instance_eval %{
  def hello4
    p 'hello,world4'
  end
}
#方法5（等效，但self 语义有点乱，不提倡本方法）
my_object.instance_eval %{
  def self.hello5
    p 'hello,world5'
  end
}
#写法6   ---  2013.4.25 
def my_object.hello6
    p 'hello,world6'
end
#写法7  ---  2012.4.25
module M
  def hello7
    p 'hello world7'
  end
end
class <<my_object
  include M
end  

my_object.hello   #=>"hello,world"
my_object.hello2 #=>"hello,world2"
my_object.hello3 #=>"hello,world3"
my_object.hello4 #=>"hello,world4"
my_object.hello5 #=>"hello,world5"
my_object.hello6 #=>"hello,world6"
my_object.hello7 #=>"hello,world7"

my_object.singleton_methods
my_object.singleton_class.instance_methods(false)

my_object.class.instance_methods(false)

总结：

向对象的 singleton_class 类添加（对象单例方法）
向对象的类添加（所有实例都可调用）
my_object 是 my_object.singleton_class 的实例，现有蛋还是现有鸡，有点乱？
X + y = my_object.methods = my_object.singleton_class.instance_methods 其中： X=my_object.instance_methods Y=my_object.singleton_methods = my_object.singleton_class.instance_methods(false)

三、向对象的 eigenclass 添加方法（理论上可行，不常用）

class <<my_object
  def self.hi
    p 'hi,world'
  end
end
my_object.singleton_class.hi  #=>"hi, world"
my_object.singleton_class.methods

反思” 题目太大了，hold 不住 “

zputee — Wed, 24 Apr 2013 19:52:03 +0800

反思： 原帖题目太大，hold 不住。其实主要想讲两点体会和一个猜测：

.英雄不问出路，即 ruby 著名的 Duck Typing 概念，如果它走路来像鸭子，叫声像鸭子，它就可以当作鸭子。
ruby 的 程序块 挑战 好莱坞准则：叫我做什么，不要叫我怎么做。
BDD 发展方向：-。CDD（convention 驱动开发） -> 动态学习规则 -> 智能软件？（又有点大

ruby 对传统面向对象编程的挑战

用 ruby 编程，是面向对象的编程吗？

面向对象编程的发展历史： 血统论：起初面向对象编程是以继承为基础，面向对象编程。 党派论：Java 出现后，面向对象编程转向面向接口编程。 能力论：ruby 出现了著名的 Duck Typing 概念，如果它走路来像鸭子，叫声像鸭>子，它就是鸭子。

ruby 的 程序块挑战了面向对象编程的 好莱坞准则：叫我做什么，不要叫我怎么>做。

结论：ruby 是以对象为基层的面向规则的编程

ruby 的 Block，Proc，Lambda ---3

zputee — Wed, 24 Apr 2013 15:52:32 +0800

一、’Proc 类的对象‘和对象的’method‘关系

Proc 类的对象运行在定义时程序的 Context。
对象的 method 运行在对象的 Context。
对象的 method 是 Method 类的实例。
它们可与相互转换。
由 method 转换到 Proc 类的对象时，不绑定当前域的局部变量。

二、method 转到 Proc 的对象

def plus(a,b)
  a + b
end
method(:plus).methods.grep /^to./  # to_proc 方法
p1=method(:plus).to_proc           # 转换为
p1.class                           # Proc的对象

def math(a,b)                      #在函数中使用上面生成的p1
  yield(a,b)
end
puts math(2,3,&p1) 
#=>5

p2=method(:plus)               # 2013.4.25    
puts math(2,3,&p)              #default call  to_proc method
$=>5

[1,2,3].map(&:to_s)            #2013,4.25
#=>["1", "2", "3"]
#其中 &:to_s  ===>   proc{ | o | o.send(self) }

三 Proc 的对象转到 method

p1 = proc{p 'hi,world'}

class A
end
a = A.new
#1.添加类的实例方法
A.send(:define_method, :hi, &p1)   
A.instance_methods(false)  
a.hi   #=>"hi,world"
#2.添加为类方法
A.singleton_class.send(:define_method, :hi, &p1)
A.methods(false)
A.hi   #=>"hi,world"

ruby 的 Block，Proc，Lambda ---2

zputee — Wed, 24 Apr 2013 15:47:00 +0800

一、什么是 ruby 中的代码块？

大括号 + 代码 { p 'hi'}
do ... end，也是代码块
ruby 中万物皆对象，块不是。

二、块怎样转换成对象？

proc + 代码块
Proc.new + 代码块
lambda + 代码块
-> + 代码块

三、使用参数

#一、关于&block的参数
def teach_math(a,b,&block)
  puts "let's begin teach math"
  block.call(a,b)       #<=
end

#二、关于yield的参数 （与方法一完全等效）
def teach_math2(a,b)
  puts "let's begin teach math"
  yield(a,b)               #<=
end
#--------------------------------------
#1、最简洁，最常用的
teach_math2(10,2){|x,y| x+y} #加法

#2、Proc实例          
pp = Proc.new {|x,y| x-y}    #减法
teach_math2(10,2,&pp)

#3、简写Proc实例 
p = proc{|x,y| x-y}
teach_math2(10,2,&p)

#4、lambda
ll= lambda{|x,y| x*y}        # 乘法
teach_math2(10,2,&ll)

#5、简写的lambda
l = ->(x,y){x*y}
teach_math2(10,2,&l)

总结

1、3、5 比较简洁。
lambda 更严谨些。
lambda，和 Proc.new 有两点细微的差别（1.return，2.参数数量严格否）

ruby 的 Block，Proc，Lambda ---1

zputee — Wed, 24 Apr 2013 15:36:31 +0800

一、简介

任何函数的调用，都可以传入 Proc 的对象。
在任何函数中，添加一条语句（yield），就可以处理传入的：Proc 的对象
ruby 的块操作，使用十分方便，无处不在。

二、例子（可在 irb 中运行）

class A
 #一般的函数调用时加入块，不处理而已，不会报错。
  def hi 
    'morning'
  end
  #方式1,任何函数只要加入一条语句，立刻具有处理块的能力，神奇吧
  def hi2
    yield if block_given？     # 只要这一句
  end  
  #方式2,传入Proc 完全等价方式1, 繁琐，没有必要使用。
  def hi3(&block)     
    block.call if block      #注意 & 字符
  end  
  #方式3, 传入Proc对象是为了保存。
  def save_it(&block)
    @block = block if block  #存入实例变量@block中    
  end
  #续方式3, 保存Proc是为了以后调用。 
  def call_it
    @block.call if @block
  end
end

a = A.new
a.hi{|x| p x} #=>"morning"
a.hi2{p 'hi'} #=>"hi"
a.hi3{p 'hi'} #=>"hi"
a.save_it{p 'hi, proc'} #=>"#<Proc:...>"
a.call_it               #=>"hi,proc"
a.call_it               #=>"hi,proc"