Программирование необязательного незнания

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 с просьбой о каждой секции петли или кода, если массив был включен в задаче и даже глупо спрашивать внутри каждой итерации цикла, скажем, встроенное условие, так как это также замедлит обработку, а также сделает код похожим на лабиринт или отверстие кролика.

Есть ли логический метод/библиотека игнорировать инструкции или пропустить, если параметр был установлен в ложном

Все, что я придумал до сих пор является своего рода бессмысленно рядный вещь

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, а не определено или обнулить консоль не жалуется

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))); 

Однако это не более ясным, для программиста, чем если() блока как показано в вашем вопросе. (На самом деле многим программистам, возможно, придется прочитать это 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() цикл, чтобы пройти через различные предметы, и если определено, вызовите функцию.

Все это будет очень зависеть от количества комбинаций, которые у вас есть. Вы упомянули 2500 строк кода, но количество перестановок может быть таким, что запись его так или иначе, возможно, не приведет к сокращению общего количества строк, но это упростит работу, поскольку многие строки перемещаются на гораздо меньший код что делает общую программу более понятной.

P.S. Чтобы упростить чтение и отладку позже, я настоятельно рекомендую вам размещать больше пробелов везде, как показано выше. Если вы хотите сэкономить место, используйте компрессор (минимизатор), Google или Yahoo! у обоих есть такая, которая действительно хорошо работает. Не нужно писать код, предварительно сжатый.