Question

我是一个新颖的开发者，我想知道你的建筑类方法有什么更好的方法，如果没有更好的方法，你的决定如何平衡：

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

对于即将发展的代码有什么好处？你认为合理数量的论点是什么？

Answer 1

如果set pf参数中的共性允许，我强烈支持传递一个对象。

为什么？

因为X％的努力用于维护现有代码，并且添加新参数更加困难 - 尤其是在相互链接调用并传递这些新参数的方法中 - 而不是向对象添加属性。

请注意，从方法的角度来看，这不一定是CLASS本身。仅仅是一个存储容器（异构地图/字典，或类型安全，支持它的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行。 YIKES。因此，对于10级嵌套调用，添加1个参数会更改所有TEN函数和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结构作为参数，其中调用代码实例化并填充结构，然后将引用传递给它作为参数。

有多少参数是合理的数字，大对象与原子参数。 OOP

2 个答案: