隐式转换¶ ↑

一些 Ruby 方法接受一个或多个对象，这些对象可以是

给定类的，因此按原样接受。
可以隐式转换为该类的，在这种情况下，被调用的方法会转换该对象。

对于每个相关的类，转换都是通过调用特定的转换方法来完成的

数组：to_ary
哈希：to_hash
整数：to_int
字符串：to_str

可转换为数组的对象¶ ↑

一个可转换为数组的对象 是指一个满足以下条件的对象：

具有实例方法 to_ary。
该方法不接受任何参数。
该方法返回一个对象 obj，对于该对象，obj.kind_of?(Array) 返回 true。

满足这些要求的 Ruby 核心类是

数组

本节中的示例使用方法 Array#replace，该方法接受可转换为数组的参数。

这个类是可转换为数组的

class ArrayConvertible
  def to_ary
    [:foo, 'bar', 2]
  end
end
a = []
a.replace(ArrayConvertible.new) # => [:foo, "bar", 2]

这个类不可转换为数组（没有 to_ary 方法）

class NotArrayConvertible; end
a = []
# Raises TypeError (no implicit conversion of NotArrayConvertible into Array)
a.replace(NotArrayConvertible.new)

这个类不可转换为数组（方法 to_ary 接受参数）

class NotArrayConvertible
  def to_ary(x)
    [:foo, 'bar', 2]
  end
end
a = []
# Raises ArgumentError (wrong number of arguments (given 0, expected 1))
a.replace(NotArrayConvertible.new)

这个类不可转换为数组（方法 to_ary 返回非数组）

class NotArrayConvertible
  def to_ary
    :foo
  end
end
a = []
# Raises TypeError (can't convert NotArrayConvertible to Array (NotArrayConvertible#to_ary gives Symbol))
a.replace(NotArrayConvertible.new)

可转换为哈希的对象¶ ↑

一个可转换为哈希的对象是指一个满足以下条件的对象：

具有实例方法 to_hash。
该方法不接受任何参数。
该方法返回一个对象 obj，对于该对象，obj.kind_of?(Hash) 返回 true。

满足这些要求的 Ruby 核心类是

哈希

本节中的示例使用方法 Hash#merge，该方法接受可转换为哈希的参数。

这个类是可转换为哈希的

class HashConvertible
  def to_hash
    {foo: 0, bar: 1, baz: 2}
  end
end
h = {}
h.merge(HashConvertible.new) # => {:foo=>0, :bar=>1, :baz=>2}

这个类不可转换为哈希（没有 to_hash 方法）

class NotHashConvertible; end
h = {}
# Raises TypeError (no implicit conversion of NotHashConvertible into Hash)
h.merge(NotHashConvertible.new)

这个类不可转换为哈希（方法 to_hash 接受参数）

class NotHashConvertible
  def to_hash(x)
    {foo: 0, bar: 1, baz: 2}
  end
end
h = {}
# Raises ArgumentError (wrong number of arguments (given 0, expected 1))
h.merge(NotHashConvertible.new)

这个类不可转换为哈希（方法 to_hash 返回非哈希）

class NotHashConvertible
  def to_hash
    :foo
  end
end
h = {}
# Raises TypeError (can't convert NotHashConvertible to Hash (ToHashReturnsNonHash#to_hash gives Symbol))
h.merge(NotHashConvertible.new)

可转换为整数的对象¶ ↑

一个可转换为整数的对象 是指一个满足以下条件的对象：

具有实例方法 to_int。
该方法不接受任何参数。
该方法返回一个对象 obj，对于该对象，obj.kind_of?(Integer) 返回 true。

满足这些要求的 Ruby 核心类是

本节中的示例使用方法 Array.new，该方法接受可转换为整数的参数。

这个用户定义的类是可转换为整数的

class IntegerConvertible
  def to_int
    3
  end
end
a = Array.new(IntegerConvertible.new).size
a # => 3

这个类不可转换为整数（方法 to_int 接受参数）

class NotIntegerConvertible
  def to_int(x)
    3
  end
end
# Raises ArgumentError (wrong number of arguments (given 0, expected 1))
Array.new(NotIntegerConvertible.new)

这个类不可转换为整数（方法 to_int 返回非整数）

class NotIntegerConvertible
  def to_int
    :foo
  end
end
# Raises TypeError (can't convert NotIntegerConvertible to Integer (NotIntegerConvertible#to_int gives Symbol))
Array.new(NotIntegerConvertible.new)

可转换为字符串的对象¶ ↑

一个可转换为字符串的对象 是指一个满足以下条件的对象：

具有实例方法 to_str。
该方法不接受任何参数。
该方法返回一个对象 obj，对于该对象，obj.kind_of?(String) 返回 true。

满足这些要求的 Ruby 核心类是

字符串

本节中的示例使用方法 String::new，该方法接受可转换为字符串的参数。

这个类是可转换为字符串的

class StringConvertible
  def to_str
    'foo'
  end
end
String.new(StringConvertible.new) # => "foo"

这个类不可转换为字符串（没有 to_str 方法）

class NotStringConvertible; end
# Raises TypeError (no implicit conversion of NotStringConvertible into String)
String.new(NotStringConvertible.new)

这个类不可转换为字符串（方法 to_str 接受参数）

class NotStringConvertible
  def to_str(x)
    'foo'
  end
end
# Raises ArgumentError (wrong number of arguments (given 0, expected 1))
String.new(NotStringConvertible.new)

这个类不可转换为字符串（方法 to_str 返回非字符串）

class NotStringConvertible
  def to_str
    :foo
  end
end
# Raises TypeError (can't convert NotStringConvertible to String (NotStringConvertible#to_str gives Symbol))
String.new(NotStringConvertible.new)