参考手册：标准库——内部类

* Object
    o Array
      + Values (ruby 1.9 特性)
    o Binding
    o Continuation
    o Data
    o Exception (参考异常类)
    o Dir
    o FalseClass
    o File::Stat
    o Hash
    o IO
      + File
    o MatchData
    o Method
      + (UnboundMethod) (ruby 1.7 特性 version 1.6以前的位置)
    o Module
      + Class
    o Numeric
      + Integer
        # Bignum
        # Fixnum
      + Float
    o Proc
    o Process::Status (ruby 1.7 特性)
    o Range
    o Regexp
    o String
    o Struct
    o Symbol
    o Thread
    o ThreadGroup
    o Time
    o TrueClass
    o UnboundMethod (ruby 1.7 特性)
    o NilClass

内部模块

  * Comparable
  * Enumerable
  * Errno
  * File::Constants
  * FileTest
  * GC
  * Kernel
  * Marshal
  * Math
  * ObjectSpace
  * Precision
  * Process
  * Process::GID (ruby 1.8 特性)
  * Process::Sys (ruby 1.8 特性)
  * Process::UID (ruby 1.8 特性)
  * Signal (ruby 1.7 特性)

异常类

  * Object
    o Exception
      + (Interrupt) (ruby 1.7 特性 version 1.6以前的位置)
      + NoMemoryError
      + ScriptError
        # LoadError
        # (NameError) (ruby 1.7 特性 version 1.6以前的位置)
        # NotImplementedError
        # SyntaxError
      + SignalException
        # Interrupt (ruby 1.7 特性)
      + StandardError
        # ArgumentError
        # IndexError
          * KeyError (ruby 1.9 特性)
        # IOError
          * EOFError
        # LocalJumpError
        # NameError (ruby 1.7 特性)
          * NoMethodError (ruby 1.7 特性)
        # RangeError
          * FloatDomainError
        # RegexpError
        # RuntimeError
        # SecurityError
        # SystemCallError
          * Errno::EXXX
        # SystemStackError
        # ThreadError
        # TypeError
        # ZeroDivisionError
      + SystemExit
      + fatal

所有类的超类.它定义了对象的一般行为.
包含的模块:

  * Kernel

方法:

self == other

  若self 等于 other 则返回真.默认情况下,它的效果等同于equal?.

  应该根据各类的具体性质来重新定义该方法.
self =~ other

  该方法可支持将正则表达式对象置于右边的,形如 obj =~ /RE/ 的正则表达式的匹配过程.通常返回false.

  根据此定义,例如

  nil =~ /re/

  通常返回 false .
self === other

  该方法通常用在case的比较句中.默认情况下,它的运作等同于Object#==,但在子类中进行归属检测时,需要对其进行适当的再定义.
class
type ((<obsolete>))

  返回被调(receiver)的类.

  ruby 1.7 特性: 在1.7 版本中,type已被停用.
clone
dup

  生成某对象的拷贝并返回它.

  clone生成的是完整的拷贝,它包括freeze、taint和特殊方法等信息; 而dup则只拷贝对象的内容.

  请注意,clone 和 dup 生成的都是"浅层(shallow)"拷贝.它们只拷贝对象本身,而不会拷贝对象的所指(例如数组的元素等).

  另外,如果对拷贝进行如下测试的话

  obj.equal?(obj.clone)

  通常都不成立.但是

  obj == obj.clone

  通常都会成立.

  若想对true, false, nil, Symbol对象等进行拷贝时,会引发TypeError异常.

  ruby 1.7 特性: 在1.7版本中,若想对Numeric对象等immutable(内容不可改变)的对象进行拷贝时,会引发TypeError.
display(out = $stdout)

  将对象输出到 out. 其定义如下.

  class Object
  def display(out=$stdout)
   out.print to_s
   nil
  end
  end

  返回nil.
eql?(other)

  若两个对象相等则返回真.常用来判断Hash中的两个索引是否相同.

  在对该方法进行再定义的同时,也必需对Object#hash方法进行再定义.

  默认情况下,eql?的定义与equal?相同,即判断对象的同一性.
equal?(other)

  若other就是self自己时,即返回真.

  该方法不能再定义.
extend(module ... )

  将参数所指模块的实例方法追加为self的特殊方法.返回self.

  include负责向类(的实例)追加功能,而extend则只向某特定的对象追加模块的功能.

  module Foo
  def a
   'ok'
  end
  end

  obj = Object.new
  obj.extend Foo
  p obj.a   #=> "ok"

  换言之,extend的功能就是"面向特殊类的include".

  ruby 1.7 特性: 若参数中包含了多个模块时,将从最后最后的参数开始逆向进行extand.
freeze

  禁止修改对象的内容.返回self.

  若强行修改则会引发TypeError异常.
frozen?

  若某对象禁止修改其内容则返回真.
hash

  返回对象的哈希表值.用来在Hash类中保存对象.

  当A.eql?(B)成立时,则A.hash == B.hash也必须成立.若再定义eql?时,也必须对该方法进行再定义.

  默认情况下,它的返回值与Object#id的返回值相同.但是,只有Fixnum,Symbol和String使用内部哈希表函数(不可改变).

  再定义hash时,将返回任意整数.
id ((<obsolete>))
__id__
object_id ((<ruby 1.7 特性>))

  返回与各个对象对应的唯一的整数.但是,为某对象分配整数的具体情形并不固定.

  为了应对您对id方法进行再定义,Ruby提供了别名__id__,我们推荐您在库中使用后者.另外,请不要对__id__进行再定义.

  ruby 1.7 特性: 在1.7版本中,id已被停用.
inspect

  将某对象转为人工可读的字符串并返回该字符串.

  内部函数p就是使用该方法来表示某对象的.
instance_eval(expr, [fname, [lineno=1]])
instance_eval {|obj| ... }

  在对象的context中计算字符串expr并返回结果.

  若给出了fname和lineno的话,将假定字符串位于在文件fname的第lineno行,然后开始编译,并能显示文件名/行号等栈跟踪信息.

  若给出了块的话,将在对象的context中计算该块并返回结果.self将被传递给块的参数obj.

  在对象的context进行计算是指,将self设为那个对象然后开始执行.同时,若在字符串/块中定义了方法的话,则相当于定义了self的特殊方法.

  但是,局部变量将被instance_eval内部和外侧的作用域所共享.

  注: 若在方法定义中,使用instance_eval 的块来定义一个方法的话,将会导致"nested method definition"编译错误. 这主要是受到Ruby语法分析器的限制所致.

  def foo
   instance_eval {
   def bar    # <- 被看做嵌套的方法定义
    "bar"
   end
   }
  end

  # => -:4: nested method definition

  若使用字符串传递形式则可绕过该限制.

  def foo
   instance_eval %Q{
   def bar
    "bar"
   end
   }
  end

  # 执行foo时,定义bar函数(实际上是
  # foo的receiver的方法)
  foo
  p bar
  # => "bar"

  ruby 1.7 特性: 已经取消了对嵌套方法定义的限制.而且,在1.7以后的版本中,即使不使用instance_eval 也可达到同样的效果(严格说来,还是有所不同的.请参考方法定义的嵌套).

  def foo
   def bar
   "bar"
   end
  end

  foo
  p bar
  # => "bar"

  另外,请参考Module#module_eval,Module#class_eval.
instance_of?(klass)

  若self为klass类的直接的实例时,返回真.

  通常,当obj.instance_of?(c)成立时,obj.kind_of?(c)也是成立的.

  请参考kind_of?.
instance_variable_get(var)

  ruby 1.8 特性

  取得并返回对象的实例变量的值.

  可以使用字符串或者Symbol来向var指定实例变量名.

  若实例变量尚未定义,则返回nil.

  class Foo
  def initialize
   @foo = 1
  end
  end

  obj = Foo.new
  p obj.instance_variable_get("@foo")  # => 1
  p obj.instance_variable_get(foo)  # => 1
  p obj.instance_variable_get(bar)  # => nil

instance_variable_set(var, val)

  ruby 1.8 特性

  将val的值赋值给对象的实例变量并返回该值.

  可以使用字符串或Symbol来向var设定实例变量名.

  若实例变量尚未定义,则重新定义.

  obj = Object.new
  p obj.instance_variable_set("@foo", 1) # => 1
  p obj.instance_variable_set(foo, 2) # => 2
  p obj.instance_variable_get(:@foo)  # => 2

instance_variables

  以字符串数组的形式返回对象的实例变量名.

  obj = Object.new
  obj.instance_eval { @foo, @bar = nil }
  p obj.instance_variables

  # => ["@foo", "@bar"]

  另外,请参考local_variables,global_variables,Module.constants,Module#constants,Module#class_variables.
is_a?(mod)
kind_of?(mod)

  只要self是下列任何一个类的实例就返回真,这些类是:mod类和它的子类,以及包括mod模块的类和它的子类.

  module M
  end
  class C < Object
  include M
  end
  class S < C
  end

  obj = S.new
  p obj.is_a? S   # true
  p obj.is_a? M   # true
  p obj.is_a? C   # true
  p obj.is_a? Object # true
  p obj.is_a? Hash  # false

  另外,请参考instance_of?, Module#===.
method(name)

  将self的方法name对象化后得到Method对象并返回该对象.可以使用字符串或Symbol来指定name.

  另外,请参考Module#instance_method.
method_missing(name, args, ... )

  Ruby在某方法尚未定义时,就调用该方法.

  调用失败的方法名(Symbol)和当时的参数被传递给name和arg ....

  默认情况下,该方法将引发NameError异常.
methods
public_methods
private_methods
protected_methods
methods([inherited_too]) ((<ruby 1.8 特性>))
public_methods([inherited_too]) ((<ruby 1.8 特性>))
private_methods([inherited_too]) ((<ruby 1.8 特性>))
protected_methods([inherited_too]) ((<ruby 1.8 特性>))

  以字符串数组的形式返回某方法能理解的 public/private/protected 方法名列表.

  methods与instance_methods相同.ruby 1.7 特性: methods以数组形式返回public和protected方法名的列表.

  ruby 1.8 特性: 可以使用参数了.若inherited_too为真,就会搜索超类中定义的方法.默认值为真.

  methods(false)与singleton_methods(false)相同.

  例:

  class Foo
  private; def private_foo() end
  protected; def protected_foo() end
  public;  def public_foo()  end
  end

  class Bar < Foo
  end

  p Bar.new.methods    - Object.new.methods
  p Bar.new.public_methods  - Object.new.public_methods
  p Bar.new.private_methods - Object.new.private_methods
  p Bar.new.protected_methods - Object.new.protected_methods
  => ["public_foo"] # version 1.7 以后、["protected_foo", "public_foo"]
   ["public_foo"]
   ["private_foo"]
   ["protected_foo"]

  另外,请参考Module#instance_methods, Module#public_instance_methods, Module#private_instance_methods, Module#protected_instance_methods.

  请参考Object#singleton_methods.
nil?

  若receiver为nil则返回真.
respond_to?(name[, priv=false])

  若对象中包含名为name的public方法时返回真.

  name可以是Symbol或字符串.若priv为真时,则对private 方法也会返回真.
send(name[, args ... ])
send(name[, args ... ]) { .... }
__send__(name[, args ... ])
__send__(name[, args ... ]) { ... }

  调用对象的name方法,并将args传给该方法的参数,然后返回方法的结果.

  若是带块调用的话,也会把块原封不动地传给方法.方法名name可以是字符串或Symbol.

  为了应对您对send进行的再定义,Ruby提供了别名__send__,在库中应该使用后者.另外,请不要对__send__进行再定义.

  send和__send__不受调用限制的影响,可以调用任何方法.
singleton_methods
singleton_methods([inherited_too]) ((<ruby 1.7 特性>))

  以字符串数组的形式返回该对象中定义的特殊类名的列表.

  ruby 1.7 特性: 可以指定参数了.若inherited_too为伪(1.8.0之前的默认值为伪,1.8.1之后的默认值为真),则不会显示超类中定义的方法名.

  ruby 1.8 特性: 可以返回public或protected属性的特殊方法名的列表了.特别是,当singleton_methods(false)时,它等同于methods(false).

  obj = Object.new
  module Foo
  private; def private_foo() end
  protected; def protected_foo() end
  public;  def public_foo()  end
  end

  class <<obj
  include Foo
  private; def private_bar() end
  protected; def protected_bar() end
  public;  def public_bar()  end
  end
  p obj.singleton_methods
  p obj.singleton_methods(false)

  # => ["public_foo", "public_bar", "protected_foo", "protected_bar"]
   ["public_bar", "protected_bar"]

  Object#extend是面向特殊类的include,所以下例也是如此.

  obj = Object.new

  module Foo
  private; def private_foo() end
  protected; def protected_foo() end
  public;  def public_foo()  end
  end

  obj.extend(Foo)
  p obj.singleton_methods
  p obj.singleton_methods(false)

  # => ["public_foo", "protected_foo"]
   []

  对于类方法(类对象的特殊方法)来说,若参数为真时,则会显示超类中的类方法名.

  class Foo
  def Foo.foo
  end
  end

  class Bar < Foo
  def Bar.bar
  end
  end

  p Bar.singleton_methods   #=> ["bar", "foo"]
  p Bar.singleton_methods(false) #=> ["bar"]

taint

  设定对象的"污染标记".返回self.

  关于对象的污染问题,请参考安全模型.
tainted?

  若对象已经有"污染标记"则返回真.

  关于对象的污染问题,请参考安全模型.
to_a ((<obsolete>))

  将对象转换为数组之后返回该数组.

  若遇到不能转为数组的对象时,将返回只包含该对象本身且长度为1的数组.

  (ruby 1.7 特性: 以后可能会取消Object的这个方法.在1.7版本中将显示警告)。

  例

  p( {'a'=>1}.to_a ) # [["a", 1]]
  p ['array'].to_a  # ["array"]
  p 1.to_a    # [1]   (warning: default `to_a' will be obsolete)
  p 'str'.to_a   # ["str"]

  ruby 1.8 特性:在多重赋值表达式的右边出现带*的对象时,若该对象中定义了to_a方法的话,就使用它.若没有的话,就把它转换为只包含自身且长度为1的数组,然后再进行赋值.

  class Foo
  def to_a
   [1, 2, 3]
  end
  end

  a, b, c = *Foo.new
  p [a, b, c]

  # => [1, 2, 3]

to_ary

  将对象转换为数组并返回该数组.

  若需要将对象隐式地转换为数组时,会在内部自动调用.

  若某对象中定义了该方法时,就可以把它单独置入多重赋值表达式的右边进行调用.

  class Foo
  def to_ary
   [1, 2, 3]
  end
  end

  a, b, c = Foo.new
  p [a, b, c]

  => [1, 2, 3]

to_hash

  若需要将对象隐式地转换为哈希表时,会在内部自动调用.
to_int

  若需要将对象隐式地转换为整数时,会在内部自动调用.
to_s

  将对象转换为字符串并返回该字符串.

  如果把非字符串对象当做参数传给print或sprintf时,将调用该方法把非字符串对象转换为字符串.
to_str

  若需要将对象隐式地转换为字符串时,会自动调用它.
untaint

  取消对象的"污染标记".返回self.

  取消污染标记所带来的风险由程序员承担.

  若安全等级在3以上时,会引发SecurityError异常.

  关于对象的污染问题,请参考安全模型.

private方法:

initialize

  用户定义类的对象初始化方法.

  在对由Class#new新生成的对象进行初始化时要调用该方法.默认情况下,没有任何的动作.通常会在子类中根据需要对其进行再定义.传递给Class#new的参数会被原封不动地传递给initialize.

  initialize方法会被自动地设定为 private类型.
initialize_copy(obj)

  ruby 1.8 特性

  (基于扩展库)用户定义类的对象拷贝(clone,dup)的初始化方法.

  该方法以obj的内容来置换self. 但self的实例变量以及特殊方法不会发生变化.

  当receiver被freeze时,或者obj的类与receiver的类不同时,将引发TypeError异常.

  在默认情况下(Object#initialize_copy)只会进行上述的freeze检查和类型检查,然后就返回self.

  obj.dup对新生成的对象调用initialize_copy

  obj2 = obj.class.allocate
  obj2.initialize_copy(obj)

  对obj2,则拷贝obj的污染状态,实例变量,finalizer,然后生成拷贝.而clone甚至会拷贝特殊方法.

  obj = Object.new
  class <<obj
  attr_accessor :foo
  def bar
   :bar
  end
  end

  def check(obj)
  puts "instance variables: #{obj.inspect}"
  puts "tainted?: #{obj.tainted?}"
  print "singleton methods: "
  begin
   p obj.bar
  rescue NameError
   p $!
  end
  end

  obj.foo = 1
  obj.taint

  check Object.new.send(:initialize_copy, obj)
    # => instance variables: #<Object:0x4019c9d4>
    #  tainted?: false
    #  singleton methods: #<NoMethodError: ...>
  check obj.dup
    # => instance variables: #<Object:0x4019c9c0 @foo=1>
    #  tainted?: true
    #  singleton methods: #<NoMethodError: ...>
  check obj.clone
    # => instance variables: #<Object:0x4019c880 @foo=1>
    #  tainted?: true
    #  singleton methods: :bar

  initialize_copy主要用来拷贝Ruby解释器无法理解的信息.例如有时使用C语言来定义类,而有时不想让实例变量保存信息,此时,若使用initialize_copy将这些内部信息拷贝下来的话,就不必对dup或clone进行再定义了.

  initialize_copy方法会自动被设定为private类型.
remove_instance_variable(name)

  从对象中删除实例变量name,并返回该实例变量中的值.name可以是Symbol或字符串.

  若对象中不包含实例变量name的话,将引发NameError异常.

  class Foo
  def foo
   @foo = 1
   p remove_instance_variable :@foo # => 1
   p remove_instance_variable :@foo # => instance variable @foo not defined (NameError)
  end
  end
  Foo.new.foo

  请参考Module#remove_class_variable, Module#remove_const.
singleton_method_added(name)

  若追加了特殊方法时,解释器会调用此方法.name可以是被追加的方法名或Symbol.

  class Foo
  def singleton_method_added(name)
   puts "singleton method \"#{name}\" was added"
  end
  end

  obj = Foo.new
  def obj.foo
  end

  => singleton method "foo" was added

  若想对普通的方法追加过程添加钩子时,可使用Module#method_added.
singleton_method_removed(name)

  ruby 1.7 特性

  若使用Module#remove_method删除特殊方法时,解释器会调用此方法.name可以是被删除的方法名或Symbol.

  class Foo
  def singleton_method_removed(name)
   puts "singleton method \"#{name}\" was removed"
  end
  end

  obj = Foo.new
  def obj.foo
  end

  class << obj
  remove_method :foo
  end

  => singleton method "foo" was removed

  若想对普通的删除方法过程添加钩子时,请使用Module#method_removed.
singleton_method_undefined(name)

  ruby 1.7 特性

  当特殊方法因Module#undef_method或undef的关系而处于未定义状态时,解释器就会调用此方法.name可以是未定义的方法名或Symbol.

  class Foo
  def singleton_method_undefined(name)
   puts "singleton method \"#{name}\" was undefined"
  end
  end

  obj = Foo.new
  def obj.foo
  end
  def obj.bar
  end

  class << obj
  undef_method :foo
  end
  obj.instance_eval {undef bar}

  => singleton method "foo" was undefined
   singleton method "bar" was undefined

  若想对普通方法的未定义状态设定钩子时,请使用Module#method_undefined.

数组类。数组的元素可以是任意的Ruby对象。通常使用数组表达式

[1, 2, 3]

来生成数组。
超类:

  * Object

包含的模块:

  * Enumerable

类方法:

Array[item,...]

  生成一个以参数为数组元素的数组。
Array.new([size[, val]])
Array.new(ary) ((<ruby 1.7 特性>))
Array.new(size) {|index| ... } ((<ruby 1.7 特性>))

  生成数组。若指定了size的话，就生成一个相应大小的数组，并以nil进行初始化。若指定了val的话，则把该对象设定给每个数组元素。(这并不意味着将nil复制给每个元素。此时，所有元素都会调用同一个对象val trap::Array)。

  ruby 1.7 特性：若使用第二种形式的话，则将拷贝参数所指的数组并将其返回。

  p Array.new([1,2,3]) # => [1,2,3]

  在第三种形式中，将使用块的计算结果来设定值。在设定每个数组元素时都会即计算该块，因此可以将所有元素都变成某对象的拷贝。

  p Array.new(5) {|i| i }   # => [0, 1, 2, 3, 4]

  ary = Array.new(3, "foo")
  ary.each {|obj| p obj.id }
  # => 537774036
   537774036
   537774036

  ary = Array.new(3) { "foo" }
  ary.each {|obj| p obj.id }
  # => 537770448
   537770436
   537770424

方法:

self[nth]

  返回第nth个数组元素。首元素算做第0个元素。若nth值为负，则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若第nth个元素不存在，则返回nil。
self[start..end]

  以数组形式返回从第start个元素到第end个元素间的所有元素。若start值为负，则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若start的值超出数组范围则返回nil。若end的值超出数组长度时，超出的部分将被忽略。另外，若范围的起点比终点还大时，返回nil。
self[start, length]

  以数组形式返回从第start个元素算起的length个数组元素。若start值为负，则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若length超出从第start个元素算起的剩余长度时，超过部分将被忽略。若length为负，则返回nil。
self[nth]=val

  将第nth个数组元素的值设定为val。若nth超出数组范围时，将自动加长数组并以nil对新增部分进行初始化。

  返回val。
self[start..end]=val

  将从第start个数组元素到第end个数组元素间的所有元素替换为val的内容。若val并非数组时，则就以val进行替换。若val的元素个数过多时，后面的元素将会发生移位。

  若val为nil或空数组[]时，将删除从start到end的元素。

  例:

  ary = [0, 1, 2, 3, 4, 5]
  ary[0..2] = ["a", "b"]
  p ary

  # => ["a", "b", 3, 4, 5]

  ary[2..4] = nil
  p ary

  # => ["a", "b"]

  返回val。
self[start, length]=val

  将从索引start算起的length个数组元素替换为val的内容。若val不是数组时，则调用val.to_ary或使用[val]进行替换。返回val。

  例:

  ary = [0, 1, 2, 3]
  ary[1, 2] = ['a', 'b', 'c']
  p ary        # => [0, "a", "b", "c", 3]
  ary[2, 1] = 99
  p ary        # => [0, "a", 99, "c", 3]
  ary[1, 0] = ['inserted']
  p ary        # => [0, "inserted", "a", 99, "c", 3]

self + other

  将self和other的内容连起来后生成新数组并返回该数组。若other并非数组时则使用other.to_ary的返回值。若该返回值依然不是数组时，则引发TypeError异常。

  例:

  a = [1, 2]
  b = [8, 9]
  p a + b  #=> [1, 2, 8, 9]
  p a   #=> [1, 2]   (没有变化)
  p b   #=> [8, 9]   (也没有变化)

self * times

  将数组内容重复多次后生成一个新数组并返回该数组。请注意，数组元素的值并没有被拷贝 trap::Array。

  例:

  p [1, 2, 3] * 3 #=> [1, 2, 3, 1, 2, 3, 1, 2, 3]

  若times为字符串，则其动作等同于self.join(times)。

  p [1,2,3] * ","
  # => "1,2,3"

self - other

  集合的补集运算。从self中删除other的元素后生成一个新数组并返回该数组。重复元素将被清除。

  若other并非数组的话，将尝试隐式地调用to_ary方法进行变换。

  ruby 1.8 特性: 重复元素将被保留。

  p([1, 2, 1, 3, 1, 4, 1, 5] - [2, 3, 4, 5])
  # => [1, 1, 1, 1]

  p([1, 2, 1, 3, 1, 4, 1, 5] - [1, 2, 3, 4, 5])
  # => []

self & other

  集合的交集运算。将同属于两个数组的元素重组为一个新数组并返回该数组。重复元素将被清除。若other并非数组的话，将尝试隐式地调用to_ary方法进行变换。

  由Object#eql?判断元素是否重复。
self | other

  集合的并集运算。将任属两数组之一的元素重组为一个新数组并返回该数组。重复元素将被清除。若other并非数组的话，将尝试隐式地调用to_ary方法进行变换。

  由Object#eql?判断元素是否重复。
self << obj

  将obj追加到数组尾部。效果等同于Array#push。

  ary = [1]
  ary << 2
  p ary  # [1, 2]

  因该方法返回值为self，所以可以连写，如下所示。

  ary = [1]
  ary << 2 << 3 << 4
  p ary #=> [1, 2, 3, 4]

self <=> other

  使用<=>来依次比较self和other中的各个元素。若self大则返回正整数；若相等返回0；若小则返回负整数。如果各个元素均相等，且其中一个数组已到达尾部时，则认定较短的数组为小。
self == other

  使用==来依次比较self和other中的各个元素，若所有元素均相等时返回真。
assoc(key)

  对数组中的元素数组进行检索，若某元素数组的首元素与key相等时就返回该元素数组。使用==操作符进行比较。若没有符合条件的元素数组就返回nil。

  例:

  ary = [[1,15], [2,25], [3,35]]
  p ary.assoc(2)    # => [2, 25]
  p ary.assoc(100)   # => nil
  p ary.assoc(15)    # => nil

  另外，请参考Array#rassoc。
at(pos)

  返回位于pos的数组元素。与self[pos]相同。
clear

  删除数组中的所有元素。返回self。

  例:

  ary = [1, 2]
  ary.clear
  p ary  #=> []

clone
dup

  生成一个与receiver内容一样的新数组并返回它。clone会拷贝frozen tainted singleton-class等信息，而dup则只拷贝内容。

  然而，无论是哪个方法都不会拷贝数组元素本身。也就是进行“浅层(shallow)”拷贝。

  例:

  ary = ['string']
  p ary     #=> ["string"]
  copy = ary.dup
  p copy    #=> ["string"]

  ary[0][0...3] = ''
  p ary     #=> ["ing"]
  p copy    #=> ["ing"]

collect! {|item| ..}
map! {|item| ..}

  依次将数组的各个元素传给块进行计算，然后以计算结果来替换该数组元素。请参考Enumerable#collect。

  返回self。

  例:

  ary = [1, 2, 3]
  ary.map! {|i| i * 3 }
  p ary #=> [3, 6, 9]

compact
compact!

  compact从self中删除值为nil的元素后生成新数组并返回它。compact!是具有破坏性的，若对原数组进行了改动就返回self，若没有进行改动则返回nil。

  例:

  ary = [1, nil, 2, nil, 3, nil]
  p ary.compact #=> [1, 2, 3]
  p ary    #=> [1, nil, 2, nil, 3, nil]
  ary.compact!
  p ary    #=> [1, 2, 3]
  p ary.compact! #=> nil

concat(other)

  将other连接到self末尾(该动作具有破坏性)。返回self。

  例:

  array = [1, 2]
  a  = [3, 4]
  array.concat a
  p array    # => [1, 2, 3, 4]
  p a     # => [3, 4]   # 没有变化

delete(val)
delete(val) { ... }

  使用==来分别比较val与每个数组元素，若相等则删除该元素。若发现了与val相等的元素就返回val。

  若没有发现与val相等的元素则返回nil，若指定了块的话就对块进行计算并返回结果。

  例:

  array = [1, 2, 3, 2, 1]
  p array.delete(2)   #=> 2
  p array      #=> [1, 3, 1]

  # 若向无块的参数传递了 nil 时，则无法从其返回值中判断
  # 到底有没有进行删除
  ary = [nil,nil,nil]
  p ary.delete(nil)   #=> nil
  p ary       #=> []
  p ary.delete(nil)   #=> nil

delete_at(pos)

  删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil。

  与at一样，可以使用负的索引从尾部起指定元素。

  例:

  array = [0, 1, 2, 3, 4]
  array.delete_at 2
  p array     #=> [0, 1, 3, 4]

delete_if {|x| ... }
reject! {|x| ... }

  依次将元素传给块进行计算，若结果为真就删除相应元素。

  delete_if通常返回self。若没有删除任何元素时，reject!会返回nil。
each {|item| .... }

  依次使用每个元素来计算块。返回self。

  例:

  # 依次显示1、2、3
  [1, 2, 3].each do |i|
  puts i
  end

  不能使用each(或标准的方法)来取出多个值进行循环。目前，必需定义下列方法才能达到目的。

  例:

  class Array
  def every(&block)
   arity = block.arity
   return self.each(&block) if arity <= 0

   i = 0
   while i < self.size
    yield(*self[i, arity])
    i += arity
   end
   self
  end
  end

  ary = [1,2,3]
  ary.every {|i| p i}
  # => 1
  #  2
  #  3
  ary.every {|i,j| p [i,j]}
  # => [1, 2]
  #  [3, nil]
  ary.every {|i,j,k| p [i,j,k]}
  # => [1, 2, 3]
  ary.every {|*i| p *i}
  # => 1
  #  2
  #  3

each_index {|index| .... }

  依次使用每个元素的索引来对块进行计算。同下

  (0 ... ary.size).each {|index| .... }

  返回self。
empty?

  若数组元素数目为0则返回真。
eql?(other)

  使用Object#eql?来依次计算self和other的各个元素，若所有元素均相等则返回真。
fetch(nth) ((<ruby 1.7 特性>))
fetch(nth, ifnone) ((<ruby 1.7 特性>))
fetch(nth) {|nth| ... } ((<ruby 1.7 特性>))

  与Array#[nth]一样，返回第nth个元素。但若没有第nth个元素的话，它的运作就有别于Array#[nth]了。

  第一种形式会引发IndexError异常。第二种形式会返回参数ifnone。而第三种形式会返回块的计算结果。

  Array#[nth]与Array#fetch(nth, nil)相同。
fill(val)
fill(val, start[, length])
fill(val, start..end)
fill {|index| ... } ((<ruby 1.7 特性>))
fill(start[, length]) {|index| ... } ((<ruby 1.7 特性>))
fill(start..end) {|index| ... } ((<ruby 1.7 特性>))

  将val赋值给数组中被指定的范围内的所有元素。在第二种形式中，若省略length则意味着将指定范围扩大到数组尾部。若指定范围最终超出原数组的长度时，将自动加长原数组，并以val来对新增元素进行初始化。

  该方法并不是使用val的拷贝，而是用val本身进行赋值(trap::Array)。

  ruby 1.7 特性:

  若没有指定val，而是代之以块时，则以块的计算值进行赋值。对每个元素进行赋值时都会重新计算块，所以被赋值的元素都是某对象的拷贝。传给块的形参的值，是从start开始的索引。

  ary = []
  p ary.fill(1..2) {|i| i}   # => [nil, 1, 2]
  p ary.fill(0,3) {|i| i}   # => [0, 1, 2]
  p ary.fill { "foo" }    # => ["foo", "foo", "foo"]
  p ary.collect {|v| v.id }   # => [537770124, 537770112, 537770100]

  ruby 1.8 特性：在1.8.0版本中有bug，块的形参会出问题。

  ary = []
  p ary.fill(1..2) {|i| i}   # => [2, 4, 6] <- bug
  p ary.fill(0,3) {|i| i}   # => [1, 3, 5] <- bug
  p ary.fill { "foo" }    # => ["foo", "foo", "foo"]
  p ary.collect {|v| v.id }   # => [537770124, 537770112, 537770100]

first
first(n) ((<ruby 1.8 特性>))

  返回数组的首元素。若没有首元素则返回nil。

  例:

  p [0, 1, 2].first #=> 0
  p [].first    #=> nil

  ruby 1.8 特性：若指定了可选参数n时，将以数组形式返回前n个元素。n必须大于0。

  ary = [0, 1, 2]
  p ary.first(0)
  p ary.first(1)
  p ary.first(2)
  p ary.first(3)
  p ary.first(4)
  # => []
   [0]
   [0, 1]
   [0, 1, 2]
   [0, 1, 2]

  请参考Array#last。
flatten
flatten!

  将带嵌套的数组重整为不带嵌套的单纯数组，并返回它。flatten!的重整具有破环性，若原数组不带嵌套则返回nil。

  例:

  p [1, [2, 3, [4], 5]].flatten #=> [1, 2, 3, 4, 5]

  array = [[[1, [2, 3]]]]
  array.flatten!
  p array         #=> [1, 2, 3]

include?(val)

  若数组中包含==val的元素就返回真。
index(val)

  返回数组中第一个==val的元素的位置。若没有与其相等的元素则返回nil。
indexes(index_1, ... , index_n) ((<obsolete>))
indices(index_1, ... , index_n) ((<obsolete>))

  以数组形式返回其索引值与各参数值相等的元素。若指定了超出范围的索引值时，将指派nil与其对应。

  例:

  ary = %w( a b c d e )
  p ary.indexes( 0, 2, 4 )    #=> ["a", "c", "e"]
  p ary.indexes( 3, 4, 5, 6, 35 ) #=> ["d", "e", nil, nil]
  p ary.indexes( 0, -1, -2 )   #=> ["a", "e", "d"]
  p ary.indexes( -4, -5, -6, -35 ) #=> ["b", "a", nil, nil]

  ruby 1.8 特性：在1.8版本中，该方法已被禁用。使用时会出现警告。您可以使用Array#values_at来取代它。
insert(nth, val[, val2 ...])
insert(nth, [val[, val2 ...]]) ((<ruby 1.8 特性>))

  ruby 1.7 特性

  在索引为nth的元素前面插入第2参数以后的值。返回self。其定义如下。

  class Array
  def insert( n, *vals )
   self[n, 0] = vals
   self
  end
  end

  例:

  ary = %w( foo bar baz )
  ary.insert 2, 'a', 'b'
  p ary      # => ["foo", "bar", "a", "b", "baz"]

  ruby 1.8 特性：若没有指定任何val时，将不作任何动作。
join([sep])

  将sep字符串夹在各元素中间使数组转换为字符串，并返回该字符串。

  若数组元素并非字符串的话，就调用to_s然后再进行连接。若元素依然是数组时，将再归调用(同样适用sep)join来连接字符串。

  若sep为nil则使用空字符串。

  若参数sep被省略，则使用变量$,的值。$,的默认值为nil。

  注:若元素中包含数组本身造成无限嵌套时，将作如下处理。

  ary = [1,2,3]
  ary.push ary
  p ary    # => [1, 2, 3, [...]]
  p ary.join  # => "123123[...]"

last
last(n) ((<ruby 1.8 特性>))

  返回数组末尾的元素。若数组为空时，返回nil。

  p [0, 1, 2].last #=> 2
  p [].last    #=> nil

  ruby 1.8 特性：若指定了可选参数n时，将返回末尾的n个元素。n必须大于0。

  ary = [0, 1, 2]
  p ary.last(0)
  p ary.last(1)
  p ary.last(2)
  p ary.last(3)
  p ary.last(4)
  # => []
   [2]
   [1, 2]
   [0, 1, 2]
   [0, 1, 2]

  请参考Array#first。
length
size

  返回数组长度。若数组为空则返回0。
nitems

  返回非nil元素的个数。
pack(template)

  按照template所指字符串的样式，以二进制的形式将数组的内容打包成字符串，并返回该字符串。模板(template)中包含规定形式的字符串和长度(省略时为1)。若指定的地方出现了*表示“所有剩余数据”的长度。关于规定形式的字符串，请参考pack模板字符串。
pop

  删除末尾元素并返回它。若数组为空则返回nil。

  请参考push, shift, unshift。

  例:

  array = [1, [2, 3], 4]
  p array.pop  # => 4
  p array.pop  # => [2, 3]
  p array    # => [1]

  p array.pop  # => 1
  p array.pop  # => nil
  p array    # => []

push(obj1[, obj2 ...])
push([obj1[, obj2 ...]]) ((<ruby 1.8 特性>))

  依次将obj1, obj2 ...添加到数组结尾。

  请参考pop, shift, unshift。

  返回self。

  例:

  array = [1, 2, 3]
  array.push 4
  array.push [5, 6]
  array.push 7, 8
  p array    # => [1, 2, 3, 4, [5, 6], 7, 8]

  ruby 1.8 特性：若未指定参数则不作任何动作。
rassoc(obj)

  假定self是数组中的元素数组，若首次发现元素数组中索引为1的元素与obj相等时就返回该元素。使用==操作符进行比较。

  若没有符合条件的元素数组则返回nil。

  例:

  a = [[15,1], [25,2], [35,3]]
  p a.rassoc(2)  # => [25, 2]

  请参考Array#assoc。
replace(another)

  以数组another来替换该数组的内容。返回self。

  例:

  a = [1, 2, 3]
  a.replace [4, 5, 6]
  p a      #=> [4, 5, 6]

reverse
reverse!

  reverse将所有元素以逆序重新排列生成新数组并返回它。reverse!的逆序排列过程具有破环性。

  reverse通常返回新数组。若数组只有1个元素，reverse!会返回nil，除此以外将返回self。

  ruby 1.8 特性:通常返回self。
reverse_each {|item| ... }

  对各个元素以逆序对块进行计算。返回self。
rindex(val)

  返回最后一个== val的元素的索引值。若没有符合条件的元素时返回nil。

  例:

  p [1, 0, 0, 1, 0].rindex(1) #=> 3
  p [1, 0, 0, 0, 0].rindex(1) #=> 0
  p [0, 0, 0, 0, 0].rindex(1) #=> nil

shift

  删除数组的首元素并返回它。剩余元素依次提前。若数组为空返回nil。

  请参考push, pop, unshift。
slice(pos[, len])
slice(start..last)

  与self[]相同。
slice!(pos[, len])
slice!(start..last)

  删除指定的元素并返回它。若没有可删除的元素时返回nil。
sort
sort!
sort {|a, b| ... }
sort! {|a, b| ... }

  对数组内容进行排序。若带块调用时，将把2个参数传给块，然后使用块的计算结果进行比较。若没有块时，使用<=>操作符进行比较。sort将生成一个经过排序的新数组并返回它。sort!的对self的排序过程具有破环性。

  ruby 1.7 特性:在1.6以前的版本中，当数组元素的个数少于2个时，sort!会返回nil。而在1.7版本中通常返回self。
to_a
to_ary

  原封不动地返回self。
to_s

  与self.join($,)相同。
transpose

  ruby 1.7 特性：

  将self看作是由行和列构成的矩阵，然后进行行列互调(将行和列互换)。生成一个新数组并返回它。若原数组为空，则生成空数组并返回它。若原数组为一维数组会引发TypeError异常。若各个元素中包含的子元素个数不一时，会引发IndexError异常。

  p [[1,2],
   [3,4],
   [5,6]].transpose
  # => [[1, 3, 5], [2, 4, 6]]

  p [].transpose
  # => []

  p [1,2,3].transpose

  # => -:1:in `transpose': cannot convert Fixnum into Array (TypeError)
    from -:1

  p [[1,2],
   [3,4,5],
   [6,7]].transpose
  # => -:3:in `transpose': element size differ (3 should be 2) (IndexError)

uniq
uniq!

  uniq会删除数组中的重复元素后生成新数组并返回它。剩下的元素会向前移动。uniq!具有破环性，若进行了删除则返回self，若没有删除则返回nil。

  使用Object#eql?来判定元素是否重复。

  例:

  p [1, 1, 1].uniq   #=> [1]
  p [1, 4, 1].uniq   #=> [1, 4]
  p [1, 3, 2, 2, 3].uniq #=> [1, 3, 2]

unshift(obj1[, obj2 ...])
unshift([obj1[, obj2 ...]]) ((<ruby 1.8 特性>))

  依次将obj1, obj2 ...插到数组的头部。返回self。

  请参考push, pop, shift。

  例:

  arr = [1,2,3]
  arr.unshift 0
  p arr     #=> [0, 1, 2, 3]
  arr.unshift [0]
  p arr     #=> [[0], 0, 1, 2, 3]
  arr.unshift 1, 2
  p arr     #=> [1, 2, [0], 0, 1, 2, 3]

  ruby 1.8 特性：若未指定参数则不作任何动作。
values_at(index_1, ... , index_n)

  ruby 1.8 特性

  以数组形式返回其索引值与各参数值相等的元素。若指定了超出范围的索引值时，将指派nil与其对应。(与indexes, indices相同)

  例:

  ary = %w( a b c d e )
  p ary.values_at( 0, 2, 4 )    #=> ["a", "c", "e"]
  p ary.values_at( 3, 4, 5, 6, 35 ) #=> ["d", "e", nil, nil, nil]
  p ary.values_at( 0, -1, -2 )   #=> ["a", "e", "d"]
  p ary.values_at( -4, -5, -6, -35 ) #=> ["b", "a", nil, nil]

用于保存局部变量表、self以及模块的嵌套等信息的对象的类。由内部函数binding生成，并用于eval的第2参数中。

另外，Ruby还提供了内部常数TOPLEVEL_BINDING以用作顶层的Binding对象。
超类:

  * Object

调用内部函数 callcc{ |cont| ... }时，它会将此前的状态(局部变量的定义、栈框架)保存到cont中然后执行块。cont是Continuation类的实例，使用Continuation#call 方法就可以随时调出保存的状态然后继续运行。

熟悉C语言的setjmp()/longjmp()的人可以把它想成

setjmp() == callcc {|c| }
longjmp() == c.call

这样或许就好理解了(但有一点不同，当栈朝向纵深发展时，callcc也可以跳转到那里)。

callcc()返回块的返回值，但Continuation#call(args)返回args。

例：

  下例是由Continuation构成的无限循环

  def LOOP
  c = nil
  yield callcc {|c| true}
  c.call(false)
  end

  LOOP {|v| p v}

  => true
   false
   false
   false
   :
   :

callcc是call-with-current-continuation的缩写形式。
超类:

  * Object

方法:

self[ret[,ret2[,...]]] ((<ruby 1.8 特性>))
call(ret[,ret2[,...]])

  在self所保存的状态的基础上继续运行。参数将原封不动地变为callcc的返回值。

在书写扩展库的过程中，有时并不适合定义new，所以该类就是Object中只对new进行undef的类。在Ruby层面中完全不必在意。
超类:

  * Object

所有异常的原始类。
超类:

  * Object

类方法:

Exception.new([error_message])
Exception.exception([error_message])

  生成并返回异常对象。可以将错误信息字符串传给参数。该错误信息将变成message属性的值，并由默认的异常处理程序显示出来。

方法:

exception([error_message])

  若未指定参数时返回self。除此以外，将生成并返回自身的拷贝，同时将message属性设定为error_message。

  实际上，raise调用的是异常对象的exception方法。
backtrace

  返回回描(backtrace)信息。

   *

    "#{sourcefile}:#{sourceline}:in `#{method}'"

    (在方法内时)
   *

    "#{sourcefile}:#{sourceline}"

    (在顶层时)

  如上形式(默认情况下)的String数组。
message
to_s
to_str

  返回描述错误信息的字符串。
set_backtrace(errinfo)

  向回描信息中添加errinfo后返回该回描信息。errinfo必须是nil、String或String数组这三者中的一个。

为实现目录流操作而设置的类，它可以依次返回目录中的元素。
超类:

  * Object

包含的模块:

  * Enumerable

类方法:

Dir[pattern]
Dir.glob(pattern)
Dir.glob(pattern) {|file| ...}
Dir.glob(pattern[, flags]) ((<ruby 1.7 特性>))
Dir.glob(pattern[, flags]) {|file| ...} ((<ruby 1.7 特性>))

  以字符串数组的形式返回通配符匹配结果。若指定了块的话，将以匹配成功的文件为参数，依次计算该块，然后返回nil。

  可以一次指定多个pattern，此时需要使用空白(space,tab,换行)或"\0"将它们分割开来。

  p Dir.glob("f* b*")
  => ["foo", "bar"]

  可用的通配符如下。

   *

    *

    匹配任何字符串，包括空字符串。
   *

    ?

    匹配任何一个字符。
   *

    [ ]

    只要匹配方括号中任何一个字符即可。若使用-则表示字符范围。若方括号中的首字符是^时，表示匹配^后的字符以外的任意字符。(在ksh或POSIX shell中可以使用!来代替^。)
   *

    { }

    表示依次与括号内的字符进行组合。例如，foo{a,b,c}将变为fooa, foob, fooc，然后再依次进行匹配。

    括号可以嵌套。例如，{foo,bar{foo,bar}}表示将依次与foo, barfoo, barbar进行匹配。
   *

    **/

    表示通配符*/重复出现0次以上，这将对目录进行再归式地搜索。例如，foo/**/bar表示将依次对foo/bar, foo/*/bar, foo/*/*/bar ... (此后无限延伸)进行匹配。

  ruby 1.7 特性:可使用反斜线对通配符进行转义处理。(请注意，在双引号内的字符串中必须进行2层转义)另外，空白类字符将失去特殊意义(但"\0"依然有效)。若想进行与1.6版本相同的处理时，应使用String#chomp等将多余的空白去掉，或使用gsub(/[\t\n]/,"\0"])进行转换即可。

  ruby 1.7 特性:可以为第2可选参数指定一个类似于File.fnmatch中所使用的标识。指定标识后就可改变匹配的运作情况。
Dir.chdir([path])
Dir.chdir([path]) {|path| ... } ((<ruby 1.7 特性>))

  将当前目录改为path。若省略path时，则会调用环境变量HOME或LOGDIR。若它们中包含设定值时，就将当前目录改为它们的值。

  若当前目录变更成功就返回0，若失败则引发Errno::EXXX异常。

  ruby 1.7 特性：若指定了块的话，则只会在块的执行过程中变更当前目录。这等价于

  savedir = Dir.pwd
  Dir.chdir(newdir)
  begin
  ...
  ensure
  Dir.chdir(savedir)
  end

  此时，带块方法的返回值就是块的执行结果。
Dir.chroot(path)

  将根目录改为path。请参考chroot(2)。只有超级用户才能改变根目录。

  您将无法还原到原来的根目录。

  根目录变更成功时返回0，失败时将引发Errno::EXXX异常。
Dir.delete(path)
Dir.rmdir(path)
Dir.unlink(path)

  删除目录。目录必须为空。

  若删除成功则返回0，若失败则引发Errno::EXXX异常。
Dir.entries(path)

  以数组形式返回path目录中所含的文件项名。等同于

  def dir_s_entries( path )
  Dir.open(path) {|d|
   return d.to_a
  }
  end

Dir.foreach(path) {|file| ...}

  针对path目录中的元素的迭代器。该方法的运作方式如下。

  dir = Dir.open(path)
  begin
  dir.each {|file|
   ...
  }
  ensure
  dir.close
  end

  返回nil。
Dir.getwd
Dir.pwd

  返回当前目录的完整路径。

  若无法取得当前目录时会引发Errno::EXXX异常(一般不会失败)。
Dir.mkdir(path[, mode])

  生成新目录path。permission的值要取决于mode(默认值0777)和umask的按位与计算结果(mode & ~umask)(请参考mkdir(2))。

  若成功生成新目录就返回0，若失败则引发Errno::EXXX异常。
Dir.new(path)
Dir.open(path)
Dir.open(path) {|dir| ...}

  打开并返回一个针对path的目录流。若打开失败则引发Errno::EXXX异常。

  open()方法可以带块。若带块调用时，将执行该块。当块的运行结束时，目录将被自动关闭。

  ruby 1.7 特性：带块调用该方法的返回值为块的运行结果。在1.6版本中，其返回值恒为nil。

方法:

close

  关闭目录流。此后若再对目录进行操作则会引发IOError异常。

  若成功关闭则返回nil。若失败则引发IOError异常。
each {|item| ... }

  为目录中的各个元素计算块的内容。返回self。
path ((<ruby 1.7 特性>))

  以字符串形式返回当前打开目录的路径名。
pos
tell

  以整数形式返回目录流的当前位置。

  Dir.open("/tmp") {|d|
   d.each {|f|
    p d.pos
   }
  }

pos=(pos)
seek(pos)

  将目录流的读入位置移动到pos。pos必须是使用Dir#tell所得到值。

  pos=返回右边，而seek则返回self。
read

  从目录流中读出并返回下一个元素。若读到最后一个元素则返回nil。

  若读取目录失败则引发Errno::EXXX异常。
rewind

  将目录流的读取位置移到开头。返回self。

false的类. false是FalseClass类的唯一的实例. false和nil对象都表示假. 其余的所有对象都表示真.
超类:

  * Object

方法:

self & other

  通常返回false.
self | other
self ^ other

  若other为真则返回true,若为假则返回false.

保存文件信息的对象的类.
超类:

  * Object

包含的模块:

  * Comparable

类方法:

File::Stat.new(path)

  生成并返回一个关于path的File::Stat对象. 与File.stat相同.

方法:

self <=> other

  比较文件的最终更新时间.若self比other新就返回正数,相等就返回0,旧则返回负数.
ftype

  返回一个表示文件类型的字符串.该字符串应是下列之一.

  "file"
  "directory"
  "characterSpecial"
  "blockSpecial"
  "fifo"
  "link"
  "socket"

  "unknown"

在下列属性方法中,若系统不支持某方法时就会返回0. ruby 1.7 特性: 在1.7版本中返回nil.

dev

  设备号(文件系统)
dev_major ((<ruby 1.9 特性>))

  dev的major号码部分
dev_minor ((<ruby 1.9 特性>))

  dev的minor号码部分
ino

  i-node 号
mode

  文件模式
nlink

  hard link数
uid

  owner的userID
gid

  owner的groupID
rdev

  设备类型(只有专用文件)
rdev_major ((<ruby 1.7 特性>))

  rdev的major号码部分
rdev_minor ((<ruby 1.7 特性>))

  rdev的minor号码部分
size

  文件大小(以字节为单位)
blksize

  理想的I/O的块大小
blocks

  被分配的块数
atime

  最终访问时间
mtime

  最终更新时间
ctime

  最终i-node变更时间

下列判断方法等同于那些与FileTest同名的模块函数. 虽然它们的参数中使用的是文件名,但却对Stat本身进行判断.

directory?

  若为目录则为真
readable?

  若可读则为真
readable_real?

  若实用户/实组可以读取就为真
writable?

  若可写则返回真
writable_real?

  若实用户/实组可以写入就为真
executable?

  若有效用户/组ID能执行就为真
executable_real?

  若实用户/组ID能执行就为真
file?

  若为普通文件则返回真
zero?

  若大小为0就为真
size?

  文件大小(若为0则为伪)
owned?

  若属于自己则为真
grpowned?

  若组ID与执行组ID相等则为真
pipe?

  若是带名称管道(FIFO)则为真
symlink?

  若是符号连接则为真
socket?

  若是socket则为真
blockdev?

  若是块专用文件则为真
chardev?

  若是字符专用文件则为真
setuid?

  若被setuid则为真
setgid?

  若被setgid则为真
sticky?

  若设定了粘着位(sticky bit)则为真