# test.rb
class Greeting
 def initialize(text)
  @text = text
 end

 def welcome
  @text
 end
end
my_obj = Greeting.new("hello")
puts my_obj.class
puts my_obj.class.instance_methods(false) #false means not inherited
puts my_obj.instance_variables

result =>
Greeting
welcome
@text

mongo API for ruby => Mongo::MongoClient

# testmongo.rb
require 'mongo'
require 'pp'

include Mongo

# the members of replcation-set
# test mongodb server version 2.6.0
host = "192.168.11.51"
# The port of members
# If the port is 27017 by default then otherport don't need to assignment
otherport = ""
port = otherport.length != 0 "htmlcode">

Constant, Instance Attribute, Instance Method


笔记二：动态调用

当你调用一个方法时，实际是给一个对象发送了一条消息。


class MyClass
 def my_method(args)
  args * 10
 end
end
obj = MyClass.new

puts obj.my_method(5)
puts "**"
puts obj.send(:my_method, 6)





结果：


50
**
60



可以使用object#send()取代点标记符来调用MyClass#my_method()方法：




obj.send(:my_method, 6)



send()方法第一个参数是要发送给对象的消息，可以是符号(:symbol)或字符串，其他参数会直接传递给调用的方法。

可以动态的决定调用哪个方法的技术，成为Dynamic Dispatch。
笔记三：符号和字符串的区别

1. 符号不可变，可以修改字符串中的字符。

2. 针对符号的操作更快些。

3. 通常符号用来表示事物的名字。

例如：




puts 1.send(:+, 4) => 5
String#to_sym(),String#intern() => string to symbol
String#to_s(),String#id2name() => symbol to string
"caoqing".to_sym() => :caoqing
:caoqing.to_s() => "caoqing"



动态派发中使用模式派发(pattern dispatch)的方法。




puts obj.class.instance_methods(true).delete_if{ |method_name| method_name !~ /^my/}
result => 
my_method



笔记四：动态定义

使用Module#define_method()方法定义一个方法。




class MyClass
 define_method :my_method do |args|
  args * 3
 end
end
obj = MyClass.new
puts obj.my_method(10)



结果：30


单件方法允许给单个对象增加一个方法。singleton methods




# test.rb
str = "My name is caoqing."
def str.title"htmlcode">

false
title"htmlcode">

obj.my_method
Cla.class_method



Duck Typing:对象能不能响应方法，可以是普通方法或者单件方法。

类方法的实质就是他们是类的一个单件方法。




def obj.method
 # method body
end



obj可以是对象引用，常量类名或self。
类宏(Class Macro)

Ruby对象没有属性，可以使用拟态方法定义属性。

Module#attr_*()方法中的一员来定义访问器。类宏不是关键字而是方法。
Eigenclass

单件方法按照常规的方法查找在祖先链无法找到保存的地方，obj是对象不能保存，也不能存在于class内，否则所有的实例都可以共享这个方法。

对象拥有一个特有的隐藏类，称为该对象的eigenclass。

进入eigenclass作用域:




class << obj
 code
end



如果想获取eigenclass的引用，则可以在离开该作用域时返回self：
附录：

类变量，实例变量，类方法，实例方法区别

@@                            ：var类变量

@                            ：实例变量

self("htmlcode">

# test.rb
class Foo
 @@var = "lion"
 def self.method01
  puts "cat"
  @name = "cat"
  @@var = "cat"
  puts @name
 end

 def self.method02
  puts "tiger"
  @name = "tiger"
  @@var = "tiger"
  puts @name
 end

 def self.method03
  puts "dog"
  @name = "dog"
  @@var = "dog"
  puts @name
 end

 def putsname
  puts @name
  puts @@var
 end
end

obj = Foo.new
# obj.method01   => (NoMethodError)

obj.putsname   => lion

Foo.method01
Foo.method02
Foo.method03
obj.putsname




结果：


lion
cat
cat
tiger
tiger
dog
dog

dog






                                
                                

                                    Ruby,元编程 
                                

                                    标签：
                                        
Ruby,元编程
                                     

                                
圆月山庄资源网 Design By www.vgjia.com