Javascript 如果不是筑巢。如何最好地实施？

我有一个函数，它接受一系列状态

Example:
State 1, [stage-is-empty, stage-is-green-done, stage-no-date];
State 2, [stage-is-done, stage-no-date, stage-is-yellow];
State 3, [stage-is-green, stage-is-red];
Etc.

必须返回找到的最差元素。 “阶段无日期”是最糟糕的， “舞台是绿色的”更好

我的职能：

const setTotalIndForStage = (arrayInd) => {
    let restul = {};
    arrayInd = arrayInd.filter((item, i) => arrayInd.indexOf(item) === i);
    restul.TOTAL_IND = 'stage-is-empty';
    restul.TOTAL_TEXT = '';

    if (arrayInd.length > 0) {
        restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-no-date');

        if (restul.TOTAL_IND === -1) {
            restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-is-red');

            if (restul.TOTAL_IND === -1) {
                restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-is-yellow');

                if (restul.TOTAL_IND === -1) {
                    restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-is-green');

                    if (restul.TOTAL_IND === -1) {
                        restul.TOTAL_TEXT = 'Done';
                        restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-is-red-done');

                        if (restul.TOTAL_IND === -1) {
                            restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-is-yellow-done');

                            if (restul.TOTAL_IND === -1) {
                                restul.TOTAL_IND = 'stage-is-green-done';
                            } else {
                                restul.TOTAL_IND = 'stage-is-yellow-done';
                            }
                        } else {
                            restul.TOTAL_IND = 'stage-is-red-done';
                        }
                    } else {
                        restul.TOTAL_IND = 'stage-is-green';
                        restul.TOTAL_TEXT = 'Deviation is ok';
                    }
                } else {
                    restul.TOTAL_IND = 'stage-is-yellow'
                    restul.TOTAL_TEXT = 'Deviation is normal';
                }
            } else {
                restul.TOTAL_IND = 'stage-is-red'
                restul.TOTAL_TEXT = 'Deviation is bad';
            }
        } else {
            restul.TOTAL_IND = 'stage-no-date'
            restul.TOTAL_TEXT = 'No deadlines';
        }
    }

    return restul;
}

---

我认为这是错误的代码。请与我分享如何正确操作的经验。

您可以将查找对象与

Array.prototype.reduce（）一起使用，如下所示：


const stages={
“阶段无日期”：0，
“舞台是红色的”：1，
“舞台是黄色的”：2，
“舞台是绿色的”：3，
“舞台是红色的”：4，
“舞台是黄色的”：5，
“舞台是绿色的”：6
};
常量findWorst=（数组）=>array.reduce(
（a，v）=>阶段[v]<阶段[a]？v:a，
“舞台是绿色的”
);
log（findWorst（['stage-is-empty'，'stage-is-green-done'，'stage-no-date']）；
log（findWorst（['stage-is-done'，'stage-no-date'，'stage-is-yellow']）；
log（findWorst（['stage-is-green'，'stage-is-red']）只需从有序的状态数组开始，从最差到最佳：

const orderedStates=[“阶段无日期”、“阶段为红色”、“阶段为黄色”、“阶段为绿色完成”]

然后，对于每个值，检查数组是否包含它。如果有，请停止搜索并返回它。它将自动成为更糟糕的状态。以下是完整的代码：


const orderedStates=[“阶段无日期”、“阶段为红色”、“阶段为黄色”、“阶段为绿色完成”]；
const setTotalIndForStage=（arrayInd）=>{
对于（let state of orderedStates）{//从较差开始，然后递增到最佳
if（arrayInd.includes（state））返回状态；
}
返回“无状态返回”；
}
log（setTotalIndForStage（[“阶段为空”、“阶段为绿色完成”、“阶段无日期”]））
log（setTotalIndForStage（[“阶段已完成”、“阶段无日期”、“阶段为黄色”]））
log（setTotalIndForStage（[“stage为绿色”，“stage为红色”]）
您正在尝试查找数组中出现的第一个匹配项，并从中创建对象。一种简洁的方法是创建一个对象，其键是stage字符串（例如
stage为空
），其值是返回对象中的
TOTAL_TEXT
属性的关联值。然后迭代对象的条目，并找到其stage字符串出现在数组中的第一个条目。从该条目中，构造要返回的对象：

const textByStageStr = {
  'stage-is-empty': '',
  'stage-no-date': 'No deadlines',
  'stage-is-red': 'Deviation is bad',
  'stage-is-yellow': 'Deviation is normal',
  'stage-is-green': 'Deviation is ok',
  'stage-is-red-done': 'Done',
  'stage-is-yellow-done': 'Done',
  'stage-is-green-done': 'Done'
};
const setTotalIndForStage = (arrayInd) => {
  arrayInd = arrayInd.filter((item, i) => arrayInd.indexOf(item) === i);
  const entry = Object.entries(textByStageStr)
    .find(([stageStr]) => arrayInd.includes(stageStr));
  return {
    TOTAL_IND: entry[0],
    TOTAL_TEXT: entry[1]
  };
}

因为如果在其他条件中没有匹配，那么最后一个嵌套的
else
将有一个
TOTAL IND
“stage-is-green-done”
，我假设在这种情况下它将存在于数组中（并且您不必费心做
findIndex
检查，因为您已经用尽了所有其他可能性）

请注意，如果您只使用
findIndex
，以便将结果与-1进行比较，那么使用
includes
会更容易。例如，在您的原始代码中，如果您从

restul.TOTAL_IND = arrayInd.findIndex(e => e === 'stage-no-date');
if (restul.TOTAL_IND === -1) {

如果不再使用
findIndex
的结果，只需使用
.includes
：

if (!arrayInd.includes('stage-no-date')) {

您可以将所有阶段移动到具有所需结果的数组中并执行搜索

const
    stages = [
        { TOTAL_IND: 'stage-is-empty', TOTAL_TEXT: '' },
        { TOTAL_IND: 'stage-no-date', TOTAL_TEXT: 'No deadlines' },
        { TOTAL_IND: 'stage-is-red', TOTAL_TEXT: 'Deviation is bad' },
        { TOTAL_IND: 'stage-is-yellow', TOTAL_TEXT: '' },
        { TOTAL_IND: 'stage-is-green', TOTAL_TEXT: '' },
        { TOTAL_IND: 'stage-is-red-done', TOTAL_TEXT: '' },
        { TOTAL_IND: 'stage-is-yellow-done', TOTAL_TEXT: '' },
    ],
    setTotalIndForStage = arrayInd =>
        stages.find(({ TOTAL_IND }) => arrayInd.some(v => TOTAL_IND === v)) ||
        stages[0];

你所有的
if
都有相同的检查
restul.TOTAL_IND===-1
-这正常吗？@Weedoze它有点正常-每个嵌套的
if
都会覆盖值。@VLAZ我明白，但是如果6
if
总是进入最后的
if
，那么它的目标是什么呢？有一个包含每个状态的字典有一个数值。例如，值越低，情况越糟。循环遍历已传递的状态，并在dict？@Weedoze中找到最小值。如果你应该检查它，那么它本质上是6
，并且在某个时候放弃并进入一个
，否则
。此外，正如你所猜测的那样，这不是写这篇文章的最佳方式。