更好的方法来编码递归如果语句

Question

我偶然发现自己在这个位置，我相信有一个更好的方式来做到这一点比我目前。

在这个例子中，我试图对一组有冲突项目的时间进行排序。我需要知道什么时候是高优先级的，不能移动的，与低优先级的，可以移动的。 但我很确定这段代码效率很低。

var holdLowPriorities = []; 

for (conflict = 0; conflict < sortedTimes.length - 1; conflict++) { 
    var firstConflictTimeStart = sortedTimes[conflict][0]; 
    var firstConflictTimeEnd = sortedTimes[conflict][1]; 
    var secondConflictTimeStart = sortedTimes[conflict + 1][0]; 
    var secondConflictTimeEnd = sortedTimes[conflict + 1][1]; 

    if (firstConflictTimeStart < secondConflictTimeEnd && 
      firstConflictTimeEnd > secondConflictTimeStart) { 
     // are either of the conflicts a high priority 
     var firstContactPriority = sortedTimes[conflict][2]; 
     var secondContactPriority = ortedTimes[conflict + 1][2] 

     if (firstConflictPriority == 2) { 
      //this is high priority, can't move 
     } 
     if (secondConflictPriority == 2) { 
      // this is also a priority, but has to move 
     } 
     // are either of the conflicts a low priority? 
     if (firstConflictPriority == 0) { 
      // this is a low priority so I can adjust the time 
     } else if (secondConflictPriority == 0) { 
      // this is a low priority so I can adjust the time 
     } 
    } 
} 

不幸的是，我甚至不知道怎么称呼这种类型的问题，因此不知道要寻找什么，但我敢肯定的答案不是太复杂（我希望不是）。

Answer 1

一个switch语句可能会帮助清理你的代码位。

Answer 2

就数据结构而言，if..else块本身没有任何低效率。即使嵌套if..else不是一个问题。在可读性方面，这完全是另一回事。作为一个经验法则，嵌入的if..else块很难嵌套（对于人来说，计算机当然对它们没有问题）。

首先，我会跟米奇的建议，使用中间变量，以减少冗长的代码去。就效率而言，它的内存效率肯定较低（尽管对于JavaScript来说，它可能会根据浏览器加速访问）。但效率不是重点，代码清晰度是。

其次，使用数组文本的语法，而不是new Array()：holdLowPriorities.push([...])。再次，屏幕上的噪音越小，越容易看到发生了什么。

第三，有几个地方你正在做的是检查某事的优先级。使用助手函数或方法来简化代码：checkProirity(sortedTimes,conflict,2)或sortedTimes.checkProirity(conflict,2)。同样，函数/方法调用本质上效率较低，但重点是为了提高可读性而改进代码清晰度。

Answer 3

编辑：已经更改了问题，所以这个最变得无关紧要。

下面是对它的简单说明。

var holdLowPriorities = []; 

for(conflict=0; conflict<sortedTimes.length-1; conflict++){ 
    var conflictTime = sortedTimes[conflict], 
     nextConflictTime = sortedTimes[conflict + 1]; 
    if (conflictTime[0] >= nextConflictTime[1] || conflictTime[1] <= nextConflictTime[0]) { 
    continue; 
    } 

    // are either of the conflicts a high priority 
    if (data[conflictTime[2]].stepsArr[conflictTime[3]].priority==2) { 
    alert(data[conflictTime[2]].stepsArr[conflictTime[3]]. 
    } 
    if (data[nextConflictTime[2]].stepsArr[nextConflictTime[3]].priority == 2) { 
    alert(data[nextConflictTime[2]].stepsArr[nextConflictTime[3]]. 
    } 

    // are either of the conflicts a low priority? 
    if (data[conflictTime[2]].stepsArr[conflictTime[3]].priority==0) { 
    holdLowPriorities.push([conflictTime[2], conflictTime[3], conflict]); 
    } else if (data[nextConflictTime[2]].stepsArr[nextConflictTime[3]].priority == 0) { 
    holdLowPriorities.push([nextConflictTime[2], nextConflictTime[3], conflict+1]) 
    } 

    //alert(data[nextConflictTime[2]].stepsArr[nextConflictTime[3]].prerequisite+' '+conflictTime[0]+' '+conflictTime[1]+' '+nextConflictTime[0]+' '+nextConflictTime[1]+' '+data[nextConflictTime[2]].stepsArr[nextConflictTime[3]].taskid+'/'+data[conflictTime[2]].stepsArr[conflictTime[3]].taskid); 
} 

然后，通过使用辅助方法和更多变量，可以使这更明显。

function conflictData(conflict) { 
    return data[conflict[2]].stepsArr[conflict[3]; 
} 

var holdLowPriorities = []; 

for(conflict=0; conflict<sortedTimes.length-1; conflict++){ 
    var conflictTime = sortedTimes[conflict], 
     nextConflictTime = sortedTimes[conflict + 1]; 
    if (conflictTime[0] >= nextConflictTime[1] || conflictTime[1] <= nextConflictTime[0]) { 
    continue; 
    } 

    var thisConflictData = conflictData(conflictTime), 
     nextConflictData = conflictData(nextConflictTime); 

    // are either of the conflicts a high priority 
    if (thisConflictData.priority == 2) { 
    alert(thisConflictData); 
    } 
    if (nextConflictData.priority == 2) { 
    alert(nextConflictData); 
    } 

    // are either of the conflicts a low priority? 
    if (thisConflictData.priority == 0) { 
    holdLowPriorities.push([conflictTime[2], conflictTime[3], conflict]); 
    } else if (nextConflictData.priority == 0) { 
    holdLowPriorities.push([nextConflictTime[2], nextConflictTime[3], conflict+1]) 
    } 

    //alert(nextConflictData.prerequisite + ' ' + conflictTime[0] + ' ' + conflictTime[1] + ' ' + nextConflictTime[0] + ' ' + nextConflictTime[1] + ' ' + nextConflictData.taskid + '/' + thisConflictData.taskid); 
} 

当我这样表达时，我认为你可以开始看到可能的错误;如果高优先级具有conflictTime和nextConflictTime检查，如果低优先级具有if，否则如果。这是需要的吗？然后，您可能可以将此/下一个冲突优先级放入交换机中，或者重新组织代码。但我认为它现在处于可以更容易理解的阶段。