有些刚刚学习编程的人员见到Ruby这个词的是很，可能会很迷茫，不知道这是个什么东西。其实它是一种解释型编程语言，能够帮助我们简便的完成许多操作。比如Ruby对象操作等等。#t#

Ruby不仅可以打开一个类，而且可以打开一个对象，给这个对象添加或定制功能，而不影响其他对象：

1. a = "hello"   
2. b = "goodbye"   
3. def b.upcase   
4. gsub(/(.)(.)/)($1.upcase + $2)   
5. end   
6. puts a.upcase #HELLO   
7. puts b.upcase #GoOdBye   

我们发现b.upcase方法被定制成我们自己的了。如果想给一个对象添加或定制多个功能，我们不想多个def b.method1 def b.method2这么做我们可以有更模块化的Ruby对象操作方式：

b = "goodbye"   
class << b   
def upcase # create single method   
gsub(/(.)(.)/) { $1.upcase + $2 }   
end   
def upcase!   
gsub!(/(.)(.)/) { $1.upcase + $2 }   
end   
end   
puts b.upcase # GoOdBye   
puts b # goodbye   
b.upcase!   
puts b # GoOdBye   

这个class被叫做singleton class,因为这个class是针对b这个对象的。和设计模式singleton object类似，只会发生一次的东东我们叫singleton.

self 给你定义的class添加行为

class TheClass   
class << self   
def hello   
puts "hello!"   
end   
end   
end   
TheClass.hello #hello! 

 
self修改了你定义class的class,这是个很有用的技术，他可以定义class级别的helper方法，然后在这个class的其他的定义中使用。下面一个Ruby对象操作列子定义了访问函数，我们希望访问的时候把成员数据都转化成string,我们可以通过这个技术来定义一个Class-Level的方法accessor_string：

class MyClass   
class << self   
def accessor_string(*names)   
names.each do |name|   
class_eval <<-EOF   
def #{name}   
@#{name}.to_s   
end   
EOF   
end   
end   
end   
def initialize   
@a = [ 1, 2, 3 ]   
@b = Time.now   
end   
accessor_string :a, :b   
end   
o = MyClass.new   
puts o.a # 123   
puts o.b # Fri Nov 21 
09:50:51 +0800 2008  

通过extend module的Ruby对象操作给你的对象添加行为,module里面的方法变成了对象里面的实例方法：

Ruby代码   
module Quantifier   
def any?   
self.each { |x| return true 
if yield x }   
false   
end   
def all?   
self.each { |x| return false 
if not yield x }   
true   
end   
end   
list = [1, 2, 3, 4, 5]   
list.extend(Quantifier)   
flag1 = list.any? {|x| x > 5 } # false   
flag2 = list.any? {|x| x >= 5 } # true   
flag3 = list.all? {|x| x <= 10 } # true   
flag4 = list.all? {|x| x % 2 == 0 } # false 

以上就是对Ruby对象操作的一些使用方法介绍。