隐式转换¶ ↑

一些 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)