擦干这个Ruby代码_Ruby_Refactoring_Dry

擦干这个Ruby代码

ruby

擦干这个Ruby代码,ruby,refactoring,dry,Ruby,Refactoring,Dry,我怎样才能擦干这段代码 module TraverseTree def inorder_traverse root return nil unless root result = [] result.concat inorder_traverse root.left if root.left result.push root.val result.concat inorder_traverse root.right if root.right

我怎样才能擦干这段代码

module TraverseTree
  def inorder_traverse root
    return nil unless root
    result = []
    result.concat inorder_traverse root.left if root.left
    result.push root.val
    result.concat inorder_traverse root.right if root.right
    result
  end

  def preorder_traverse root
    return nil unless root
    result = []
    result.push root.val
    result.concat preorder_traverse root.left if root.left
    result.concat preorder_traverse root.right if root.right
    result
  end

  def postorder_traverse root
    return nil unless root
    result = []
    result.concat postorder_traverse root.left if root.left
    result.concat postorder_traverse root.right if root.right
    result.push root.val
    result
  end
end

是否有一种基于函数名以编程方式对代码排序的好方法

谢谢

正如Chris的回答所指出的，这里当然有消除重复的方法，但正如我在对他们的回答的评论中提到的，我认为您的原始代码非常好，因为它的意图非常明确。即使没有任何评论，我也能马上说出每种方法的作用，我不想看到你失去它

def traverse_recurse(root, options)
  return unless root
  options[:preorder].call(root.val) if options[:preorder]
  traverse_recurse(root.left, options)
  options[:inorder].call(root.val) if options[:inorder]
  traverse_recurse(root.right, options)
  options[:postorder].call(root.val) if options[:postorder]
end

def traverse_collect(root, type)
  result = []
  traverse_recurse(root, type => lambda { |val| result.push(val) })
  result
end

def preorder_traverse(root)
  traverse_collect(root, :preorder)
end

def inorder_traverse(root)
  traverse_collect(root, :inorder)
end

def postorder_traverse(root)
  traverse_collect(root, :postorder)
end

然而，我确实看到了一种方法，可以在不牺牲可读性的情况下去掉一些样板文件

以下是您的第一种方法：

def inorder_traverse root
    return nil unless root
    result = []
    result.concat inorder_traverse root.left if root.left
    result.push root.val
    result.concat inorder_traverse root.right if root.right
    result
  end

我首先想到的是

result=[]。。。（返回）结果

。在Ruby中，这通常是一种代码味道，但如何消除它还不是很明显，所以我将回到这里

跳出的第二件事是，该方法在调用

inorder\u transverse

之前，先检查

root.left

是否为

nil

，然后将

inorder\u transverse

作为参数调用

root.left

，这很好，但是

inorder\u transverse

会立即检查其参数是否为

nil

。我们不需要做两次

如果我们取消这些后条件检查，我们最终会得到以下结果：

def inorder_traverse(root)
  return unless root
  result = []
  result.concat(inorder_traverse(root.left))
  result.push(root.val)
  result.concat(inorder_traverse(root.right))
  result
end

这是不对的，但是，因为

数组#concat

将在

按顺序遍历

nil

时引发类型错误。我们可以通过使用splat（

）的

Array#push

来解决这个问题：当参数是数组时，它的工作方式与concat类似，当参数是

nil

时，它的工作方式与空数组的concat类似：

def inorder_traverse(root)
  return unless root
  result = []
  result.push(*inorder_traverse(root.left))
  result.push(root.val)
  result.push(*inorder_traverse(root.right))
  result
end

但是，您可能已经意识到，如果我们将一个参数splating到

push

，我们可以在一个

push

中splat所有参数，而不是调用

push

三次：

def inorder_traverse(root)
  return unless root
  result = []
  result.push(
    *inorder_traverse(root.left),
    root.val,
    *inorder_traverse(root.right)
  )
  result
end

…但请稍等。如果我们只是初始化一个空数组，将一堆元素推到它上面，然后返回它，为什么我们不在初始化数组时直接将这些元素放到数组上呢

因此：

module TraverseTree
  def inorder_traverse(root)
    return unless root
    [ *inorder_traverse(root.left),
      root.val,
      *inorder_traverse(root.right) ]
  end

  def preorder_traverse(root)
    return unless root
    [ root.val,
      *preorder_traverse(root.left),
      *preorder_traverse(root.right) ]
  end

  def postorder_traverse(root)
    return unless root
    [ *postorder_traverse(root.left),
      *postorder_traverse(root.right),
      root.val ]
  end
end

另外，您可以做的另一件事是将

return除非root

替换为

root&&…

（或

root和…

）。我觉得这很诱人，但也有点臭，所以我把它留给你：

def inorder_traverse(root)
  root && [
    *inorder_traverse(root.left),
    root.val,
    *inorder_traverse(root.right)
  ]
end

奖金我不可避免地开始思考如何真正消除上面的所有重复，并提出了下面的代码，这是仓促编写的、未经测试的、完全不明智的代码。但是写起来很有趣

module TraverseTree
  ORDERS = %i[preorder inorder postorder].each do |order|
    define_method(:"#{order}_traverse", 
      &method(:traverse_by).curry(order))
  end

  private
  def traverse_by(order, root)
    root && [
      traverse_by(order, root.left),
      traverse_by(order, root.right)
    ]
    .insert(ORDERS.index(order), root.val)
    .compact.flatten
  end
end