代码大脑“预告片” ——但并非如此

Question

我只是很好奇你们对此有何看法。我听到办公室里流传着一堆答案，我想看看你们是否能有更好的答案。

问题：

您有下面概述的两个函数：

function one()
{
    A();
    B();
    C();
}

function two()
{
    A();
    D();
    C();
}

您将如何重写它（任何重要的东西，您可以创建类、变量、其他方法，任何东西），以减少代码重复？

每个调用的方法都会更改其他函数需要使用的变量。方法 A() B() 和 C() 已经定义。

Answer 1

并非所有语言都支持这种方法，并且传递函数的语法可能会有所不同，但概念是：

function one()
{
    refactored(B);
}

function two()
{
    refactored(D);
}

function refactored(middleMan)
{
    A();
    middleMan();
    C();
}

Answer 2

这里没有重复的代码。看起来不错。

Answer 3

调用的每个方法都会更改其他函数需要使用的变量。

我将首先重构整个类以使用正确的 OOP。

Answer 4

有多种方法可以重构该代码；我将使用哪个取决于特定的应用程序，因为这可能意味着我需要在更高的级别重新考虑事物，例如重新定义类，或者最坏的情况是审查整个应用程序设计，因为重复意味着我错过了一些关键关系。

Answer 5

如果您的函数 one() 和 Two() 实际上是三行函数，如示例中所示，我不会重写任何内容。你会失去可读性，并使代码更难被下一个人理解。

如果对 A() 和 C() 的调用实际上是更大的代码块......
- 使用抽象方法 X() 和具体方法定义基类
函数任意()
{
一个（）;
X();
C();
定义

• 一个类 One，其中 X() 由 B() 实现
• 定义一个类 Two，其中 X() 由 D() 实现

Answer 6

这是一种选择。

function (triggerA, triggerB, triggerC, triggerD)
{
     A(triggerA);
     B(triggerB);
     C(triggerC);
     D(triggerD);
}

这样，您只需调用一个函数即可完成所有操作，并跳过您不需要/想要执行的任何操作。

Answer 7

如果你有闭包、lambda 等可用，你可以写

function one()
{
    three(B)
}

function two()
{
    three(D);
}

function three(middle) 
{
    A();
    middle();
    C();
}

Answer 8

您可以（但可能不应该）创建一个类，其中A()是构造函数，C() 是析构函数，并且 one() 和 two() 是调用 B() 和 D( ） 分别。

我说你可能不应该这样做，因为 OOP 应该用于编写有意义的代码，而不是出于晦涩的优化原因。

Answer 9

在 C++ 中，如果上下文有意义，通常使用 RAII 来完成...这种模式通常是 A() = 某个 init 函数，C() = 某个 de-init 函数。通常还有一个关联的上下文正在被初始化或销毁。

   class bar
    {
        bar() {
            A();
        }

        ~bar() {
            C();
        }
    };

    void one() 
    {
        bar barvar;
        B();
    }

    void two()
    {
        bar barvar;
        D();
    }