在ruby中是否有将第三方对象呈现为字符串的模式？

想象一下，我有一个类是由第三方gem提供的，就像下面的那个

class ThirdPartyThing
  def initialize(name)
    @name = name
  end

  def to_s
    @name.to_s
  end
end

假设我想要实现我自己的方式来将对象渲染为字符串。我知道这里有三种选择：

重新打开

ThirdPartyThing

类并重写to_s函数

重新打开

ThirdPartyThing

类并定义新函数

定义一个单独的函数，将第三方作为参数，例如

def third_party_thing_to_s(third_party_thing)
  third_party_thing.to_s.capitalize
end

也许还有其他我没有考虑的选择

---

我的问题是“在ruby中是否有将第三方对象呈现为字符串的模式？”

我会选择3<代码>定义一个单独的函数，该函数包含第三部分。为什么不呢。还是2

重新打开第三方类并重写to_s函数：

如果其他代码使用

to_s

功能，则可能会在该代码中产生不期望的结果。其他代码可能期望

以原始方式运行，甚至可能
ThirdPartyThing
本身

重新打开第三方类并定义新函数：
直到新版本的
ThirdPartyThing
引入了一个与你的monkey patched同名的方法（然后你重写了它，坏事情就发生了）。不太可能，但仍然可能发生，即使使用非常奇怪的方法名！（你知道摩尔定律…）

通常，我会尽量不修改第三方库

您也可以编写一个通用方法：

def my_special_to_s(object)
  if object.is_a?(ThirdPartyThing)
      object.to_s.capitalize
  elif object.is_a?(SomeOtherThingYouWantSpecialToS)
      object.do_fancy_to_s
  else
      # use the default to_s
      object.to_s
  end
end

我会选3个<代码>定义一个单独的函数，该函数包含第三部分

。为什么不呢。还是2

重新打开第三方类并重写to_s函数：

如果其他代码使用

to_s

功能，则可能会在该代码中产生不期望的结果。其他代码可能期望

以原始方式运行，甚至可能
ThirdPartyThing
本身

重新打开第三方类并定义新函数：
直到新版本的
ThirdPartyThing
引入了一个与你的monkey patched同名的方法（然后你重写了它，坏事情就发生了）。不太可能，但仍然可能发生，即使使用非常奇怪的方法名！（你知道摩尔定律…）

通常，我会尽量不修改第三方库

您也可以编写一个通用方法：

def my_special_to_s(object)
  if object.is_a?(ThirdPartyThing)
      object.to_s.capitalize
  elif object.is_a?(SomeOtherThingYouWantSpecialToS)
      object.do_fancy_to_s
  else
      # use the default to_s
      object.to_s
  end
end

我会选3个<代码>定义一个单独的函数，该函数包含第三部分

。为什么不呢。还是2

重新打开第三方类并重写to_s函数：

如果其他代码使用

to_s

功能，则可能会在该代码中产生不期望的结果。其他代码可能期望

以原始方式运行，甚至可能
ThirdPartyThing
本身

重新打开第三方类并定义新函数：
直到新版本的
ThirdPartyThing
引入了一个与你的monkey patched同名的方法（然后你重写了它，坏事情就发生了）。不太可能，但仍然可能发生，即使使用非常奇怪的方法名！（你知道摩尔定律…）

通常，我会尽量不修改第三方库

您也可以编写一个通用方法：

def my_special_to_s(object)
  if object.is_a?(ThirdPartyThing)
      object.to_s.capitalize
  elif object.is_a?(SomeOtherThingYouWantSpecialToS)
      object.do_fancy_to_s
  else
      # use the default to_s
      object.to_s
  end
end

我会选3个<代码>定义一个单独的函数，该函数包含第三部分

。为什么不呢。还是2

重新打开第三方类并重写to_s函数：

如果其他代码使用

to_s

功能，则可能会在该代码中产生不期望的结果。其他代码可能期望

以原始方式运行，甚至可能
ThirdPartyThing
本身

重新打开第三方类并定义新函数：
直到新版本的
ThirdPartyThing
引入了一个与你的monkey patched同名的方法（然后你重写了它，坏事情就发生了）。不太可能，但仍然可能发生，即使使用非常奇怪的方法名！（你知道摩尔定律…）

通常，我会尽量不修改第三方库

您也可以编写一个通用方法：

def my_special_to_s(object)
  if object.is_a?(ThirdPartyThing)
      object.to_s.capitalize
  elif object.is_a?(SomeOtherThingYouWantSpecialToS)
      object.do_fancy_to_s
  else
      # use the default to_s
      object.to_s
  end
end

还有4个，编写一个decorator来包装第三方并提供所需的功能。这基本上是选项3，但是在一个更加面向对象的包装器中

class ThirdPartyThingDecorator
  def initialize(thing)
    @thing = thing
  end

  def to_s
    # Something that renders @thing as a string here
  end    
end

ThirdPartyThingDecorator.new(my_thing).to_s

对于to_s这样的单一方法来说，这是一种过分的技巧，但是如果你最终需要大量的表现行为，这是一个很好的选择，因为你可以将所有与第三方相关的行为封装在同一个地方。
还有4种方法，编写一个装饰器来包装第三方并提供所需的功能。这基本上是选项3，但是在一个更加面向对象的包装器中

class ThirdPartyThingDecorator
  def initialize(thing)
    @thing = thing
  end

  def to_s
    # Something that renders @thing as a string here
  end    
end

ThirdPartyThingDecorator.new(my_thing).to_s

对于to_s这样的单一方法来说，这是一种过分的技巧，但是如果你最终需要大量的表现行为，这是一个很好的选择，因为你可以将所有与第三方相关的行为封装在同一个地方。
还有4种方法，编写一个装饰器来包装第三方并提供所需的功能。这基本上是选项3，但是在一个更加面向对象的包装器中

class ThirdPartyThingDecorator
  def initialize(thing)
    @thing = thing
  end

  def to_s
    # Something that renders @thing as a string here
  end    
end

ThirdPartyThingDecorator.new(my_thing).to_s

对于to_s这样的单一方法来说，这是一种过分的技巧，但是如果你最终需要大量的表现行为，这是一个很好的选择，因为你可以将所有与第三方相关的行为封装在同一个地方。
还有4种方法，编写一个装饰器来包装第三方并提供所需的功能。这基本上是选项3，但是在一个更加面向对象的包装器中

class ThirdPartyThingDecorator
  def initialize(thing)
    @thing = thing
  end

  def to_s
    # Something that renders @thing as a string here
  end    
end

ThirdPartyThingDecorator.new(my_thing).to_s

对于to_s这样的单一方法来说，这是一种过分的技巧，但是如果您最终需要大量的表现行为，这是一个很好的选择，因为您可以将所有与第三方相关的行为封装在同一个位置