Ruby学习笔记之反射和元编程

最新推荐文章于 2022-04-02 09:12:18 发布

ssjssh

最新推荐文章于 2022-04-02 09:12:18 发布

阅读量3k

点赞数

文章标签： Ruby

本文链接：https://blog.youkuaiyun.com/ssjssh/article/details/12125803

版权

反射和元编程

匿名Class对象

如果把一个Class对象，赋值给一个常量，那么这个常量就是一个类名。因此在Ruby中每一个类都是一个Class常量对象。因此Object.class = Class

例子:

C = Class.new # A new class with no body, assigned to a constant

c = C.new # Create an instance of the class

c.class.to_s # => "C": constant name becomes class name

类型信息

注意：o是一个对象，c是一个类

1.o.class

2.c.superclass

3.o.instance_of? c#相当于o.class == c

4.o.is_a? c 或者 o.kind_of? 或者 c === o。c#测试o的父类或者类型是否为c，或者o的类型是否包含c

5.只要创建了模块或者类，接下来就可以用开放类或者模块来添加各种东西。

模块相关的信息

module A; end # Empty module

module B; include A; end; # Module B includes A

class C; include B; end; # Class C includes module B

C < B # => true: C includes B

B < A # => true: B includes A

C < A # => true

Fixnum < Integer # => true: all fixnums are integers

Integer <Comparable # => true: integers are comparable

Integer < Fixnum # => false: not all integers are fixnums

String < Numeric # => nil: strings are not numbers

A.ancestors # => [A]

B.ancestors # => [B, A]

C.ancestors # => [C, B, A, Object, Kernel]

String.ancestors # => [String, Enumerable, Comparable, Object, Kernel]

# Note: in Ruby 1.9 String is no longer Enumerable

C.include?(B) # => true

C.include?(A) # => true

B.include?(A) # => true

A.include?(A) # => false

A.include?(B) # => false

A.included_modules # => []

B.included_modules # => [A]

C.included_modules # => [B, A, Kernel]

extend

Object的extend可以自动把模块的实例方法变成单例方法

module Greeter; def hi; "hello"; end; end # A silly module

s = "string object"

s.extend(Greeter) # Add hi as a singleton method to s

s.hi # => "hello"

String.extend(Greeter) # Add hi as a class method of String

String.hi # => "hello"

动态创建模块

每一个模块都是一个Nodule类的一个实例。因此可以通过创建Module常量来创建模块。

M = Module.new

或者用new的块语法

Fed = Module.new do

def meth1

"hello"

end

def meth2

"bye"

end

动态创建类

C = Class.new

D = Class.new(C) {

include M

}

属性

class Point

def initialize(x,y); @x,@y = x,y; end # Define instance variables

@@classvar = 1 # Define a class variable

ORIGIN = Point.new(0,0) # Define a constant

end

Point::ORIGIN.instance_variables # => ["@y", "@x"]

Point.class_variables # => ["@@classvar"]

Point.constants # => ["ORIGIN"]

动态添加属性

o = Object.new

o.instance_variable_set(:@x, 0) # Note required @ prefix

o.instance_variable_get(:@x) # => 0

o.instance_variable_defined?(:@x) # => true

Object.class_variable_set(:@@x, 1) # Private in Ruby 1.8

Object.class_variable_get(:@@x) # Private in Ruby 1.8

Object.class_variable_defined?(:@@x) # => true; Ruby 1.9 and later

Math.const_set(:EPI, Math::E*Math::PI)

Math.const_get(:EPI) # => 8.53973422267357

Math.const_defined? :EPI # => true

注意：这儿易受静态语言的影响，而认为这些变量或者常量是已经存在于类中的。事实上，在Ruby中，当变量或者常量在第一次出现时，会加入到类体中，动态添加的时候这种行为显得更加魔幻。但是由于一个属性必须有个访问方法，因此对于外界来说也是一种提示。

删除

o.instance_eval { remove_instance_variable :@x }

String.class_eval { remove_class_variable(:@@x) }

Math.send :remove_const, :EPI # Use send to invoke private method

注意：因为remove方法是私有的，因此只能用eval和send来包装调用

方法

o = "a string"

o.methods # => [ names of all public methods ]

o.public_methods # => the same thing

o.public_methods(false) # 不包含继承的公有方法

o.protected_methods # => []: there aren't any

o.private_methods # => array of all private methods

o.private_methods(false) # Exclude inherited private methods

def o.single; 1; end # Define a singleton method

o.singleton_methods # => ["single"] (or [:single] in 1.9)

在Module中定义的类方法

String.instance_methods == "s".public_methods # => true

String.instance_methods(false) == "s".public_methods(false) # => true

String.public_instance_methods == String.instance_methods # => true

String.protected_instance_methods # => []

String.private_instance_methods(false) # => ["initialize_copy", "initialize"]

Math.singleton_methods # => ["acos", "log10", "atan2", ... ]

参见: Method (相同)

测试特定方法

String.public_method_defined? :reverse # => true

String.protected_method_defined? :reverse # => false

String.private_method_defined? :initialize # => true

String.method_defined? :upcase! # => true

对于对象来说

o.respond_to? name 测试o是否有一个方法，另一个参数如果为true，那么也可以测试private方法

动态调用方法

1，得到一个method来调用

2，用send或者public_send来发送消息

3，类和方法都可以调用，谁调用就在谁上面执行方法

"hello".send :upcase # => "HELLO": invoke an instance method

Math.send(:sin, Math::PI/2) # => 1.0: invoke a class method

"hello".public_send :puts, "world" # raises NoMethodError

4，模块也可以调用这个方法

def define_methods

shared = 0

Kernel.send :define_method, :counter do

shared

end

Kernel.send :define_method, :inc do |x|

shared += x

end

动态添加方法

1.添加实例方法

def add_method(c, m, &b)

c.class_eval {

define_method(m, &b)

}

end

add_method(String, :greet) { "Hello, " + self }

"world".greet # => "Hello, world"

注意的define_method是kernel的私有的方法，因此要用class_eval来包装他的调用

2.添加类方法

String.define_singleton_method(:greet) {|name| "Hello, " + name }

在Ruby中，一个类调用instance_eval和define_method都是为了创建实例方法（这两个方法都是由高层类和模块调用的，因此类和对象中都会有这两个方法）。既然是实例方法，那么就会调用实例属性和实例方法。这在Java中是不可思议的，因为Java中所有的类方法都不可以调用实例方法。但是在Ruby中这些方法仅仅会把得到的块传递给类，而并不会检测其中的内容，也不会在类定义期间执行，因此不用担心是否会有实例属性未初始化的情况。这种做法就像C语言中的宏替换。

重命名方法

def backup(c, m, prefix="original")

n = :"#{prefix}_#{m}" # Compute the alias

c.class_eval { # Because alias_method is private

alias_method n, m # Make n an alias for m

}

end

鉴于这些方法都是Module中的私有方法，因此必须用class_eval来包装调用

动态删除

remove_method和undef_method

它们的不同之处是：undef_method会删除继承的方法，也就是说删除之后就没有了这个方法；remove_method仅仅删除子类的定义，父类的方法大这是被继承。

改变可见性

1.可以简单的用开类来实现

String.class_eval { private :reverse }

2.Module中的方法

禁止动态变化

一个类要想禁止动态变化，可以简单的调用freeze方法冻结

eval

eval "x + 1" # => 2

1.eval可以执行任何有效的Ruby语句，这样甚至可以用生成String的方式来处理代码

2.eval好用，但是容易滥用，因此要注意用其他的特性来代替它

3.eval可能不安全

Binding类

每一个的属性都一个特定的上下文，一般而言是一个对象。这样的状态用Binding对象来表示。Kernel.binding可以得到一个Binding对象（注意这个方法是私有的，因此要想办法变成共有）。接下来就可以用eval来的得到属性的值。

class Object

def bindings

binding # This is the predefined Kernel method

end

class Test

def initialize(x); @x = x; end

end

t = Test.new(10)

eval("@x", t.bindings) # => 10

或者在Ruby1.9中。

t.bindings.eval("@a")

instance_eval和class_eval

1.instance_eval和class_eval是在特定的类和对象上执行代码

o.instance_eval("@x") # Return the value of o's instance variable @x

String.class_eval("def len; size; end")

String.class_eval("alias len size")

String.instance_eval("def empty; ''; end")

另外可以用快语法

o.instance_eval { @x }

String.class_eval {

def len

size

end

}

String.class_eval { alias len size }

String.instance_eval { def empty; ""; end }

2.要注意的是instance_eval定义在BasicObject中，而Module中定义了class_eval，同时不是每一对象都是一个Module类实例，而每一个Class都是一个Module（Class->Module->Object）。因此在对象上只能调用instance_eval，而类上可以调用instance_eval和class_eval，当使用这种方法定义方法是，差别是instance_eval定义了一个单例方法（即使没有用前缀），这意味着对类来说，定义了一个类方法，对对象来说定义了一个对象的特有方法。另一方面，class_eval定义了实例方法，这对于对象也无意义。