Ruby 内置类的学习笔记

>> david = Person.new
=> #
>> david.name = 'David'
=> "David"
>> puts 'david is named ' + david + '.'
david is named David.
=> nil
to_ary

class Person
  attr_accessor :name, :age, "email"
  def to_ary
    [name, age, email]
  end
end
试下：

>> david = Person.new
=> #
>> david.name = "David"
=> "David"
>> david.age = 55
=> 55
>> david.email = "david@wherever"
=> "david@wherever"
>> array = []
=> []
>> array.concat(david)
=> ["David", 55, "david@wherever"]
>> p array
["David", 55, "david@wherever"]
=> ["David", 55, "david@wherever"]
布尔状态，布尔对象，nil

Ruby 的每个表达式都会计算出一个对象，每个对象里面都有一个布尔值，true 或 false 。true 与 false 本身也是对象。在很多情况下，在你想得到真或假值的地方，比如 if 声明，或比较两个数字，你不用直接处理这些特别的对象，在这种情况下，你可以把真假想成是状态，而不是对象。

作为状态的 true 与 false

Ruby 里的表达式要么是 true 要么就是 false。使用 if 语句你可以去验证表达式到底是 true 还是 false 。

做些实验：

if (class MyClass; end)
  puts '空白的对象是 true'
else
  puts '空白的对象是 false'
end

if (class MyClass; 1; end)
  puts '类定义里有个数字 1 是 true'
else
  puts '类定义里有个数字 1 是 false'
end

if (def m; return false; end)
  puts '方法定义是 true'
else
  puts '方法定义是 false'
end

if 'string'
  puts '字符串是 true'
else
  puts '字符串是 false'
end

if 100 > 50
  puts '100 大于 50'
else
  puts '100 不大于 50'
end
结果会是：

空白的对象是 false
类定义里有个数字 1 是 true
方法定义是 true
字符串是 true
100 大于 50
再来试一下，看看表达式到底返回的是什么东西：

>> class MyClass; end
=> nil
>> class MyClass; 1; end
=> 1
>> def m; return flase; end
=> :m
>> 'string'
=> "string"
>> 100 > 50
=> true
100 > 50 返回的是 true 这个对象。

作为对象的 true 与 false

true 与 false 是特别的对象，它们是 TrueClass 与 FalseClass 类的唯一的实例。

做个实验：

>> puts true.class
TrueClass
=> nil
>> puts false.class
FalseClass
=> nil
true 与 false 是关键词，所以你不能把它们用在变量或方法的名字里。

>> a = true
=> true
>> a = 1 unless a
=> nil
>> a
=> true
>> b = a
=> true
有时候你会看到把 true 或 false 作为方法的参数使用。比如你想让一个类显示它所有的实例方法，但不想显示在祖先类里的实例方法，可以这样做：

>> String.instance_methods(false)
nil

nil 是 NilClass 的唯一实例。nil 的布尔值是 false。nil 表示的是没有任何东西。

做个实验：

puts @x
puts 一个不存在的实例变量，输出的是 nil 。nil 也是不存在的元素的默认值，比如你创建了一个数组，里面有三个项目，当你访问数组里的第九个项目的时候，得到的值就是 nil 。试一下：

>> ['one', 'two', 'three'][9]
=> nil
nil 表示的就是没有还有不存在。不过 nil 本身是存在的，它也可以像其它对象一样响应方法地调用：

>> nil.to_s
=> ""
>> nil.to_i
=> 0
>> nil.object_id
=> 8
nil 与 false 是 Ruby 里面唯一的两个布尔值是 false 的对象。

下午2:53 ***

比较两个对象

下午3:28 ***

Ruby 的对象可以比较它们自己是否跟其它的对象相等。

相等测试

做些实验：

>> a = Object.new
=> #
>> b = Object.new
=> #
>> a == a
=> true
>> a == b
=> false
>> a != b
=> true
>> a.eql?(a)
=> true
>> a.eql?(b)
=> false
>> a.equal?(a)
=> true
>> a.equal?(b)
=> false
在上面的实验里，我们用了三种相等测试的方法，==，eql?，equal? ，它们给出的结果是一样的。a 跟 a 是相等的，a 跟 b 不相等。

在自己的类里你可以重新定义 == 与 eql? 方法。一般会留着 equal? 方法，你可以用它比较两个对象表示的是不是同一个对象。比如在 String 类里就重新定义了 == 与 eql? 方法：

>> string1 = 'text'
=> "text"
>> string2 = 'text'
=> "text"
>> string1 == string2
=> true
>> string1.eql?(string2)
=> true
>> string1.equal?(string2)
=> false
Comparable 模块

最常见的重定义的相等测试方法是 == 。它是相等测试方法大家族里的一员，也是比较方法家族的成员，==，!==，>，<，>=，<= 。

如果你需要让 MyClass 这个类的对象拥有所有的这些比较方法，你只需要：

把 Comparable 模块混合到 MyClass 里面。
在 MyClass 里使用 <=> 名字定义一个比较方法。
<=> 比较方法有时候也叫飞船操作符或者飞船方法。在这个方法里你可以定义小于，等于，大于到底是什么意思。完成以后，Ruby 就会给你提供对应的比较方法。

例如，你有一个投标类，名字是 Bid，可以跟踪进来的投标，你希望有一些比较的功能可以比较两个 Bid 对象，基于 estimate 属性。比较的时候可以使用 > ，< 这些简单的操作符。

class Bid
  include Comparable
  attr_accessor :estimate
  def <=>(other_bid)
    if self.estimate < other_bid.estimate
      -1
    elsif self.estimate > other_bid.estimate
      1
    else
      0
    end
  end
end
简单点，可以这样；

def <=>(other_bid)
  self.estimate <=> other_bid.estimate
end
实验一下：

>> bid1 = Bid.new
=> #
>> bid2 = Bid.new
=> #
>> bid1.estimate = 100
=> 100
>> bid2.estimate = 105
=> 105
>> bid1 < bid2
=> true
检查对象的能力

inspection 与 reflection，就是让 Ruby 对象在它的生命周期里关于它自己的一些事儿。

列出对象的方法

你想知道一个对象能懂什么信息，也就是能在它上面调用什么方法，试一下：

>> '我是个字符串对象'.methods
你会看到大量的方法，排下顺序可以：

>> '我是个字符串对象'.methods.sort
methods 方法也可以在模块对象与类对象上用：

>> String.methods.sort
列表里的方法是 String 这个类对象的方法。

在一个字符串对象上定义一个独立方法，再查看这个对象的方法列表，你会找到在这个对象上定义的这个独立方法：

>> str = 'A plain old string'
=> "A plain old string"
>> def str.shout
>> self.upcase + "!!!"
>> end
=> :shout
>> str.shout
=> "A PLAIN OLD STRING!!!"
>> str.methods.sort
你也可以单独显示对象的独立方法：

>> str.singleton_methods
=> [:shout]
在一个类里混合了模块，在模块里的方法，类的实例对象也可以调用，再做个实验：

>> str = 'Another plain old string.'
=> "Another plain old string."
>> module StringExtras
>> def shout
>> self.upcase + '!!!'
>> end
>> end
=> :shout
>> class String
>> include StringExtras
>> end
=> String
>> str.methods.include?(:shout)
=> true
先创建了一个字符串对象，又创建了一个模块，又把这个模块混合到了 String 类里面，再查看最开始创建的字符串对象是否包含在模块里定义的 :shout 方法的时候，会返回 true 。

查询类与模块对象

在 irb 里执行 String.methods.sort 的时候，你会找到一个 instance_methods 方法，它会告诉我们 String 类的实例能使用的实例方法：

>> String.instance_methods.sort
也可以问一下模块：

>> Enumerable.instance_methods.sort
过滤与选择的方法列表

有时候你想知道某个特定类上面定义的实例方法，不想包含这个类的祖先上面定义的方法，可以这样做：

String.instance_methods(false).sort
你看到的就只是在 String 类上定义的实例方法。还有几种列出方法的方法：

obj.private_methods
obj.public_methods
obj.protected_methods
obj.singleton_methods
类与模块上的实例方法：

MyClass.private_instance_methods
MyClass.protected_instance_methods
MyClass.public_instance_methods
public_instance_methods 跟 instance_methods 是一个意思。