隐式转换¶ ↑

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

• 给定类的对象，因此按原样接受。

• 可以隐式转换为该类的对象，在这种情况下，所调用的方法会转换该对象。

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

• 数组：to_ary

• 哈希：to_hash

• 整数：to_int

• 字符串：to_str

可转换为数组的对象¶ ↑

可转换为数组的对象是

• 具有实例方法 to_ary 的对象。

• 该方法不接受任何参数。

• 该方法返回一个对象 obj，其中 obj.kind_of?(Array) 返回 true。

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

• Array

本节中的示例使用接受可转换为数组的参数的方法 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)