Question

我不确定如何搜索，所以如果已经回答，请指出我。

我再次遇到一个相当普遍的情况，我不确定最佳做法。考虑一种函数具有三个可能值之一的情况;我们会说他们是'a'，'b'和'c'。

如果我收到'a'或'b'，我会做一些大量的重叠处理，在某些特定情况下。但是，如果我收到'c'，我需要做一些完全不同的事情。这样做是微不足道的，但是我有一些非常重要的例子。

示例（Python）：

def doStuff(self, val):
    if   val == 'a':
        self.counter += 1
        print val, "is very good"
        self.passing = True
        self.doMoreStuff()
    elif val == 'b':
        self.counter += 2
        print val, "is not too bad"
        self.passing = True
        self.doMoreStuff()
    elif val == 'c':
        self.counter -= 1
        self.passing = False
        print val, "is unacceptable"
        self.weAreDoneHere()

所以这个想法是对于'a'或'b'，有一些特定于案例的指令和一些重复的东西，但对于'c'，它们都是不同的。在某些情况下，仅仅离开三个独立的案件并不是太糟糕，尽管它让我的DRY眼睛抽搐看着它。在其他情况下，如果有很多重复的代码，它可能是一个更大的问题。

一种解决方案如下：

def doStuff(self, val):
    if   val == 'a' or val == 'b':
        if val == 'a':
            self.counter += 1
            print val, "is very good"
        elif val == 'b':
            self.counter += 2
            print val, "is not too bad"
        self.passing = True
        self.doMoreStuff()
    elif val == 'c':
        self.counter -= 1
        self.passing = False
        print val, "is unacceptable"
        self.weAreDoneHere()

这种双重检查价值方法可以吗？它也使我的DRY眼睛抽搐了一点，但没有重复大量代码那么多。

我认为，我真正的问题是，是否曾在某处讨论这个问题，还是有一种标准的“最佳实践”方法？

Answer 1

我不知道python，但在大多数情况下，你会重构A和B之间的所有常见内容并将它们放在私有函数中，然后从A和B调用它。

javascript中的一个例子：

var someFunction = function (someArg) {
    var stuffCommonToAandB = function () {
        // stuff for both A and B
    };

    switch (true) {
        case someArg === 'A':
            stuffCommonToAandB();
            // stuff for A only
            break;
        case someArg === 'B':
            stuffCommonToAandB();
            // stuff for B only
            break;
        case someArg === 'C':
            // stuff for C only
            break;
    }
};

值得一提的是，将此类标记传递给切换不同行为的函数有时可能表明您的函数违反了single responsibility principle，在这种情况下，您可能需要退后一步并重新思考你的设计更进一步。

将DRY与几个部分重叠的逻辑流一起使用是否有最佳实践？

1 个答案: