有多少参数是一个合理的数字，大对象与原子参数。面向对象编程

Question

我是一名新开发人员，我想知道根据您的经验，构建类方法时更好的方法是什么，如果没有更好的方法，如何平衡您的决策：

• 将一个大对象作为参数传递包含该方法所需的大部分变量。
• 传递更多可能的原子个体变量，结果是生成具有大签名的方法。

对于即将发展的代码来说，什么更好？您认为合理的论点数量是多少？

Answer 1

如果参数集合中的共性允许的话，我强烈主张传递一个对象。

为什么？

因为 X% 的精力花在维护现有代码上，并且添加新参数比向对象添加属性要困难得多，尤其是在相互链式调用并传递这些新参数的方法中。

请注意，从具有方法的意义上来说，这本身不一定是一个类。只是一个存储容器（要么是异构映射/字典，要么是为了类型安全，是支持它的 C 类型语言中的结构）。

示例（我将使用伪代码，随意它基于哪种语言）：

---

首先，让我们使用参数列表查看旧代码和新代码

旧代码：

function f1(arg1, arg2, arg3, arg4, arg5) {
    res = f2(arg1, arg2, arg3, arg4);
}
function f2(arg1, arg2, arg3, arg4) {
    res = f3(arg1, arg2, arg4);
}
function f3(arg1, arg2, arg4) {
    res = f4(arg1, arg4);
}
function f4(arg1, arg4) {
    return arg1 + arg4;
}

新代码（需要在 f4() 中添加 arg6）：

function f1(arg1, arg2, arg3, arg4, arg5, arg6) {       // changed line
    res = f2(arg1, arg2, arg3, arg4, arg6);             // changed line
}
function f2(arg1, arg2, arg3, arg4, arg6) {             // changed line
    res = f3(arg1, arg2, arg4, arg6);                   // changed line
}
function f3(arg1, arg2, arg4, arg6) {                   // changed line
    res = f4(arg1, arg4, arg6);                         // changed line
}
function f4(arg1, arg4, arg6) {                         // changed line
    return arg1 + arg4 + arg6;                          // changed line
}

正如你可以的看，对于 4 级嵌套调用，我们更改了所有 4 个函数，每个函数至少有 2 行。哎呀。因此，对于 10 级嵌套调用，添加 1 个参数会更改所有 10 个函数和 20 行。

---

现在，有一个相同更改的示例，除了 arg 列表现在是一个对象（或者，对于动态语言，异构映射即可：）

class args_class {
    public: 
        int arg1, arg2, arg3, arg4, arg5;
    }
}
args_class arg_object;

function f1(arg_object) {       
    res = f2(arg_object);             
}
function f2(arg_object) {       
    res = f3(arg_object);                   
}
function f3(arg_object) {                   
    res = f4(arg_object);                         
}
function f4(arg_object) {                         
    return arg_object.arg1 + arg_object.arg4;                          
}

我们需要更改什么来添加 arg6？

class args_class {
    public: 
        int arg1, arg2, arg3, arg4, arg5, arg6;                 // line changed
    }
}
// f1..f3 are unchanged
function f4(arg_object) {                         
    return arg_object.arg1 + arg_object.arg4 + arg_object.arg6; // line changed
}

就是这样。对于 4 级嵌套方法或 10 级嵌套方法，您只需要更改 2 行。

哪一个维护工作量较少？

Answer 2

我认为这完全取决于函数参数本身的上下文。如果您依赖于某事的元素，那么我会将该某事的引用作为参数传递（无论它是指向以下接口的引用/指针）该对象或对象定义本身的引用/指针是实现细节）。

如果参数不是直接从对象派生的，并且参数数量很少（也许五个或更少？取决于你），那么我会传递原子参数。

如果可能存在大量参数，那么我将创建某种 init 结构作为参数，其中调用代码实例化并填充该结构，然后将对其的引用作为参数传递。