Question

在Javascript中，当你有一组数组来执行数据集上的任务时，处理场景的最佳方法是什么？有时你不想包含所有数组而是包含组合。

我的数组在这个小片段L，C，H，V，B，A，S中被标记，并且为了解决这个问题，代码大约是2500行。（我已从此帖中删除了代码注释）

if(C[0].length>0){
    L=L[1].concat(+(MIN.apply(this,L[0])).toFixed(7));
    C=C[1].concat(C[0][0]);
    H=H[1].concat(+(MAX.apply(this,H[0])).toFixed(7));
    V=V[1].concat((V[0].reduce(function(a,b){return a+b}))/(V[0].length));
    B=B[1].concat((MAX.apply(this,B[0])-MIN.apply(this,B[0]))/2);
    A=A[1].concat((MAX.apply(this,A[0])-MIN.apply(this,A[0]))/2);
    D=D[1].concat((D[0].reduce(function(a,b){return a+b}))/(D[0].length));
    S=S[1].concat((S[0].reduce(function(a,b){return a+b}))/(S[0].length));
    }

在这种情况下，如果一个数组被包含在任务中，那么在每个循环或代码段询问每个循环或代码部分的bool条件的代码乱丢代码似乎会产生反作用，并且在每个循环迭代中询问内联更加愚蠢条件，因为这些也会减慢处理速度，并使代码看起来像一个迷宫或兔子洞。

是否存在忽略指令的逻辑方法/库，或者如果选项设置为false则跳过

到目前为止，我所提出的只是一种毫无意义的内联事物

var op=[0,1,1,0,0,0,0,0]; //options

var L=[],C=[],H=[],V=[],B=[],A=[],D=[],S=[];

op[0]&&[L[0]=1];
op[1]&&[C[0]=1,console.log('test, do more than one thing')];
op[2]&&[H[0]=1];
op[3]&&[V[0]=1];
op[4]&&[B[0]=1];
op[5]&&[A[0]=1];
op[6]&&[A[0]=1];

它的工作原理是它只在选项需要时将C[0]和H[0]设置为1，但它失败了，因为它需要在循环的每次迭代中提出七个问题，因为它可能在一个循环中完成环。而不是制作循环或代码部分的七个版本，而不是在每个循环中提出问题是否有另一种样式/方法？

我还注意到，如果我创建一个数组，那么在某些时候使它等于NaN而不是undefined或null控制台不会抱怨

var L=[],C=[],H=[],V=[],B=[],A=[],D=[],S=[];

L=NaN;
L[0]=1;
//1
console.log(L); //NaN

L=undefined;
L[0]=1
//TypeError: Cannot set property '0' of undefined

L=null
L[0]=1
//TypeError: Cannot set property '0' of null

我变暖了吗？我会假设，如果我在L[0]进行了一些数学计算，isNaN(L)===true表示数学正在进行但没有存储，那么这条线就不会被忽略..

Answer 1

如果我明白你想要什么，我会做这样的事情。

var op = [...],
    opchoice = {
        //these can return nothing, no operation, or a new value.
        'true': function(val){ /*operation do if true*/ },
        'false': function(val){ /*operation do if false*/ },
        //add more operations here.
        //keys must be strings, or transformed into strings with operation method.
        operation: function(val){
            //make the boolean a string key.
            return this[''+(val == 'something')](val);
        }
    };

var endop = [];//need this to prevent infinite recursion(loop).
var val;
while(val = op.shift()){
    //a queue operation.
    endop.push(opchoice.operation(val));
}

我确信这不是你想要的，但它几乎可以满足每个地方都没有大量条件的需求。

你的另一个选择是在每一行都这样做。

A = isNaN(A) ? A.concat(...) : A;

我个人更喜欢其他方法。

Answer 2

看起来你重复了很多操作。这些操作应该是函数，所以至少你不要一遍又一遍地重新定义相同的函数（这也是一个优化）。

function get_min(x)
{
    return +(MIN.apply(this, a[0])).toFixed(7);
}

function get_max(x)
{
    return +(MAX.apply(this, a[0])).toFixed(7);
}

function get_average(x)
{
    return (x[0].reduce(function(a, b) {return a + b})) / (x[0].length);
}

function get_mean(x)
{
    return (MAX.apply(this, x[0]) - MIN.apply(this, x[0])) / 2;
}

if(C[0].length > 0)
{
    L = L[1].concat(get_min(L));
    C = C[1].concat(C[0][0]);
    H = H[1].concat(get_max(H));
    V = V[1].concat(get_average(V));
    B = B[1].concat(get_mean(B));
    A = A[1].concat(get_mean(A);
    D = D[1].concat(get_average(D));
    S = S[1].concat(get_average(S));
}

您还可以使用原型函数定义一个对象，但不清楚它是否有用（在将这些函数放入命名空间之外）。

关于进行测试的想法/概念，你发现的可能是JavaScript的最佳方式。

op[0] && S = S[1].concat(get_average(S));

如果您想在op[0]为真时应用多个运算符，请使用括号和逗号：

op[3] && (V = V[1].concat(get_average(V)),
          B = B[1].concat(get_mean(B)),
          A = A[1].concat(get_mean(A));

op[0] && (D = D[1].concat(get_average(D)),
          S = S[1].concat(get_average(S)));

但是，对于程序员而言，这并不比问题中显示的if（）块更清楚。（实际上，许多程序员在获得它之前可能必须阅读它2到3次。）

然而，还有另一种解决方案是使用另一个功能层。在最后一个例子中，你会做这样的事情：

function VBA()
{
    V = V[1].concat(get_average(V));
    B = B[1].concat(get_mean(B));
    A = A[1].concat(get_mean(A));
}

function DS()
{
    D = D[1].concat(get_average(D));
    S = S[1].concat(get_average(S));
}

op = [DS,null,null,VBA,null,null,...];

for(key in op)
{
    // optional: if(op[key].hasOwnProperty(key)) ... -- verify that we defined that key
    if(op[key])
    {
        op[key](); // call function
    }
}

所以换句话说，你有一个函数数组，可以使用for()循环遍历各个项目，如果已定义，则调用函数。

所有这些在很大程度上取决于您拥有的组合数量。您提到了2,500行代码，但是排列的数量可能是这样的，即以某种方式写入它可能不会减少行的总数，但是它会使维护更容易，因为许多行被移动到更小的代码片段使整个程序更容易理解。

P.S。为了便于以后阅读和调试，我强烈建议您在任何地方放置更多空格，如上所示。如果您想节省空间，请使用压缩器（最小化器），Google或Yahoo!两者都有一个做得很好的。无需编写预压缩的代码。

编程可选的无知

2 个答案: