代码重构的可能帮助

Question

Sandi Metz 在 GORUCO 的 SOLID OOPS 概念 中说，Ruby 中存在if..else 块可以被认为是对开闭原则的偏离。可以使用哪些方法来避免不紧急的if..else 条件？我尝试了以下代码：

class Fun
   def park(s=String.new)
      puts s
   end
   def park(i=Fixnum.new)
      i=i+2
   end
end

发现函数重载在 Ruby 中不起作用。还有哪些其他方法可以使代码服从 OCP？

我本来可以直接去的：

class Fun
  def park(i)
      i=i+2 if i.class==1.class 
      puts i if i.class=="asd".class
  end
end

但这违反了OCP。

Answer 1

对于您当前的示例，并且希望避免类型检测，我将使用 Ruby 的功能重新打开类以向 Integer 和 String 添加您需要的功能：

class Integer
  def park
    puts self + 2
  end
end

class String
  def park
    puts self
  end
end

这在更改您自己的类时会更干净。但也许它不适合您的概念模型（这取决于 Fun 代表什么，以及为什么它可以在一个方法中使用这两个不同的类）。

等价但保留您的 Fun 类可能是：

class Fun
  def park_fixnum i
    puts i + 2
  end

  def park_string s
    puts s
  end

  def park param
    send("park_#{param.class.to_s.downcase}", param)
  end
end

作为一种观点，我不确定通过这种方式编写 Ruby 是否会收获很多。您正在学习的原则可能是好的（我不知道），但强行应用它们“违背语言的特点”可能会产生可读性较差的代码，无论它是否符合善意的设计。

所以我可能在实践中会这样做：

class Fun
  def park param
    case param
    when Integer
      puts param + 2
    when String
      puts param
    end
  end
end

这不符合您的原则，但它是惯用的 Ruby，并且比 if 块更易于阅读和维护（其中条件可能要复杂得多，因此人类需要更长的时间来解析）。

Answer 2

你可以像这样为 Fun 创建处理类

class Fun
   def park(obj)
    @parker ||= Object.const_get("#{obj.class}Park").new(obj)
    @parker.park 
    rescue NameError => e
        raise ArgumentError, "expected String or Fixnum but recieved #{obj.class.name}"
   end
end

class Park
    def initialize(p)
        @park = p
    end
    def park
        @park
    end
end

class FixnumPark < Park
    def park
        @park += 2
    end
end

class StringPark < Park
end

这样就可以了

f = Fun.new
f.park("string")
#=> "string"
f.instance_variable_get("@parker")
#=> #<StringPark:0x1e04b48 @park="string">
f = Fun.new
f.park(2)
#=> 4
f.instance_variable_get("@parker")
#=> #<FixnumPark:0x1e04b48 @park=4>
f.park(22)
#=> 6 because the instance is already loaded and 4 + 2 = 6
Fun.new.park(12.3)
#=> ArgumentError: expected String or Fixnum but received Float

Answer 3

你可以这样做：

class Parent
  attr_reader :s

  def initialize(s='')
    @s = s
  end

  def park
    puts s
  end
end

class Child1 < Parent
  attr_reader :x

  def initialize(s, x)
    super(s)
    @x = x
  end

  def park
    puts x 
  end
end

class Child2 < Parent
  attr_reader :y

  def initialize(s, y)
    super(s)
    @y = y
  end

  def park
    puts y
  end
end


objects = [
  Parent.new('hello'),
  Child1.new('goodbye', 1),
  Child2.new('adios', 2),
]

objects.each do |obj|
  obj.park
end

--output:--
hello
1
2

或者，也许我忽略了你的一个曲折：

class Parent
  attr_reader :x

  def initialize(s='')
    @x = s
  end

  def park
    puts x
  end
end

class Child1 < Parent
  def initialize(x)
    super
  end

  def park
    x + 2 
  end
end

class Child2 < Parent
  def initialize(x)
    super
  end

  def park
    x * 2
  end
end


objects = [
  Parent.new('hello'),
  Child1.new(2),
  Child2.new(100),
]

results = objects.map do |obj|
  obj.park
end

p results

--output:--
hello
[nil, 4, 200]

还有一个使用 blocks 的例子，它们就像匿名函数。您可以将所需的行为作为函数传递给 park()：

class Function
  attr_reader :block

  def initialize(&park)
    @block = park 
  end

  def park
    raise "Not implemented"
  end
end


class StringFunction < Function
  def initialize(&park)
    super
  end

  def park
    block.call
  end
end

class AdditionFunction < Function
  def initialize(&park)
    super
  end

  def park
    block.call 1
  end
end

class DogFunction < Function
  class Dog
    def bark
      puts 'woof, woof'
    end
  end

  def initialize(&park)
    super
  end

  def park
    block.call Dog.new
  end
end


objects = [
  StringFunction.new {puts 'hello'},
  AdditionFunction.new {|i| i+2},
  DogFunction.new {|dog| dog.bark},
]

results = objects.map do |obj|
  obj.park
end

p results

--output:--
hello
woof, woof
[nil, 3, nil]

Answer 4

看is_a?方法

def park(i)
  i.is_a?(Fixnum) ? (i + 2) : i
end

但最好不要检查类型，而是使用鸭子类型：

def park(i)
  i.respond_to?(:+) ? (i + 2) : i
end

UPD：读完 cmets。是的，上面的两个例子都没有解决 OCP 问题。我就是这样做的：

class Fun
  # The method doesn't know how to pluck data. But it knows a guy
  # who knows the trick
  def pluck(i)
    return __pluck_string__(i) if i.is_a? String
    __pluck_fixnum__(i) if i.is_a? Fixnum
  end

  private

  # Every method is responsible for plucking data in some special way
  # Only one cause of possible changes for each of them

  def __pluck_string__(i)
    puts i
  end

  def __pluck_fixnum__(i)
    i + 2
  end
end

Answer 5

我理解或等于 ruby​​ 中的操作，但你能解释一下吗 你已经完成了：

Object.const_get("#{obj.class}Park").new(obj)

在 ruby​​ 中，以大写字母开头的东西是一个常数。以下是const_get() 工作原理的更简单示例：

class Dog
  def bark
    puts 'woof'
  end
end

dog_class = Object.const_get("Dog")
dog_class.new.bark

--output:--
woof

当然，你也可以将参数传递给dog_class.new：

class Dog
  attr_reader :name

  def initialize(name)
    @name = name
  end

  def bark
    puts "#{name} says woof!"
  end
end

dog_class = Object.const_get("Dog")
dog_class.new('Ralph').bark

--output:--
Ralph says woof!

下面这行只是上面的一个变体：

Object.const_get("#{obj.class}Park").new(obj)

如果obj = 'hello'，第一部分：

Object.const_get("#{obj.class}Park")

相当于：

Object.const_get("#{String}Park")

而当 String 类对象被插值成字符串时，它只是简单地转换为字符串“String”，给你：

Object.const_get("StringPark")

那行检索 StringPark 类，给你：

Object.const_get("StringPark")
            |
            V
      StringPark

然后，添加原始行的第二部分会得到：

      StringPark.new(obj)

因为obj = 'hello'，所以相当于：

      StringPark.new('hello')

任性？