Javascript 多个嵌套开关语句的最佳选择？_Javascript_Switch Statement

Javascript 多个嵌套开关语句的最佳选择？

javascript

Javascript 多个嵌套开关语句的最佳选择？,javascript,switch-statement,Javascript,Switch Statement,我有一个JavaScript函数，它有多个嵌套的开关大小写，这完全是一团糟。在过去的几个月里，这个函数已经被扩展，现在我想重新构造代码。在任何情况下，都应该将不同的值推送到已经存在的var 下面是我的代码示例： switch(var1){ case 1: switch(var2){ case 0: switch(var3){ case 'test':

我有一个JavaScript函数，它有多个嵌套的开关大小写，这完全是一团糟。在过去的几个月里，这个函数已经被扩展，现在我想重新构造代码。在任何情况下，都应该将不同的值推送到已经存在的var

下面是我的代码示例：

switch(var1){
    case 1:
        switch(var2){
            case 0:
                switch(var3){
                    case 'test':
                        switch(i){
                            case 0: endresult.push({id: i, content: '123'}); break;
                            case 2: endresult.push({id: i, content: '124'}); break;
                        }
                        break;
                    default:
                        endresult.push({id: i, content: '125'}); break;
                }
                break;
            case 1:
                endresult.push({id: i, content: '126'}); break;
        }
        break;
    case 2:
        switch(var2){
            case 0:
                switch(i){
                    case 0: endresult.push({id: i, content: '127'}); break;
                    case 2: endresult.push({id: i, content: '128'}); break;
                }
                break;
            case 1:
                switch(i){
                    case 0: endresult.push({id: i, content: '128'}); break;
                    case 2: endresult.push({id: i, content: '129'}); break;
                }
                break;
        }
        break;
}

重写此内容的最佳方法是什么？

有一张所有可能变化及其值的地图：

// Key is composite of `"" + var1 + "_" + var2 + "_" + i` and trimmed `_` from back

let tree = {
    '1_0_test_0': '123',
    '1_0_test_2': '124',
    '1_0_test': '125',
    '1_0_1': '126',
    ...
}

let key = ("" + var1 + var2 + i).replace(/_{2,}|_+$/, '');

if (typeof tree[key] !== 'undefined') {
    endresult.push({id: i, content: tree[key]});
}

拥有所有可能变化及其值的地图：

// Key is composite of `"" + var1 + "_" + var2 + "_" + i` and trimmed `_` from back

let tree = {
    '1_0_test_0': '123',
    '1_0_test_2': '124',
    '1_0_test': '125',
    '1_0_1': '126',
    ...
}

let key = ("" + var1 + var2 + i).replace(/_{2,}|_+$/, '');

if (typeof tree[key] !== 'undefined') {
    endresult.push({id: i, content: tree[key]});
}

你关心的是可读性，对吗？您可能需要稍微拆分代码。并使用变量名，而不是0和1。你还需要提供更多的细节。比如它可以超越0和1到2和3等等。我不知道你如何调用你的代码

但是，您可以尝试混合对象，否则：

const decideFn = ({ var1, var2, var3, i }) = {
    const decision = {
        1: {
            0: {
                cond(i) {
                    if (var3 === 'test') {
                        if (i === 0) 
                            endresult.push({id: i, content: '123'})
                        else if (i === 2) 
                            endresult.push({id: i, content: '124'})
                        else 
                            endresult.push({id: i, content: '125'})
                    }
                    else endresult.push({id: i, content: '125'})
                }
            },
            1: {
                cond(i) { 
                   endresult.push({id: i, content: '126'}) 
                }
            }
        }
        2: {
            0: {
                cond(i) {            
                    if (i === 0) 
                        endresult.push({id: i, content: '127'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '128'})}
                },
            1: {
                cond(i) {
                    if (i === 0) 
                        endresult.push({id: i, content: '128'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '129'}) 
                }
            }
        }
    }

    // usage
    // does i go in a loop ?
    // your qn needs more details. but i hope you get the idea
    decision[var1][var2].cond(i)

}

最终，它真的归结为您如何感觉您最了解代码，以及其他开发人员如何阅读您的代码，但我个人认为您的switch语句很好

对象可能会提供更多的灵活性。

您关心的是可读性，对吗？您可能需要稍微拆分代码。并使用变量名，而不是0和1。你还需要提供更多的细节。比如它可以超越0和1到2和3等等。我不知道你如何调用你的代码

但是，您可以尝试混合对象，否则：

const decideFn = ({ var1, var2, var3, i }) = {
    const decision = {
        1: {
            0: {
                cond(i) {
                    if (var3 === 'test') {
                        if (i === 0) 
                            endresult.push({id: i, content: '123'})
                        else if (i === 2) 
                            endresult.push({id: i, content: '124'})
                        else 
                            endresult.push({id: i, content: '125'})
                    }
                    else endresult.push({id: i, content: '125'})
                }
            },
            1: {
                cond(i) { 
                   endresult.push({id: i, content: '126'}) 
                }
            }
        }
        2: {
            0: {
                cond(i) {            
                    if (i === 0) 
                        endresult.push({id: i, content: '127'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '128'})}
                },
            1: {
                cond(i) {
                    if (i === 0) 
                        endresult.push({id: i, content: '128'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '129'}) 
                }
            }
        }
    }

    // usage
    // does i go in a loop ?
    // your qn needs more details. but i hope you get the idea
    decision[var1][var2].cond(i)

}

最终，它真的归结为您如何感觉您最了解代码，以及其他开发人员如何阅读您的代码，但我个人认为您的switch语句很好

对象可以提供更多的灵活性。

< P>如果在所有情况下，你都在推同一个变量，我会考虑创建一个函数，其唯一的任务是基于变量确定正确的值。这可能是这样的：

const getContentValue(var1, var2, var3, i) {
 if (var1 === 1) {
   if (var2 === 0) {
     if (var3 === 'test') {
       if (i === 0) return '123'
       if (i === 2) return '124'
       return '125'
   }
   if (var2 === 1) {
     return '126'
   }
 }
 if (var1 === 2) {
   if (var2 === 0) {
     if (i === 0) return '127'
     if (i === 2) return '128'
   }
   if (var2 === 1) {
     if (i === 0) return '128'
     if (i === 2) return '129'
   }
 }
}

endResult.push({ id: i, content: getContentValue(var1, var2, var3, i) })

代码未经测试

需要注意的几件事和需要注意的几条原则：

基本决策结构是相同的，但通过使用if语句简化了。在我看来，在案例之间切换是当你有很多案例时，而不是在两件事情之间切换时所做的事情。在两个选项之间切换时，if语句非常有效。如果你真的在处理大量的案例，比如说你的var1实际上可能是10+个不同的数字，使用开关可能更简单。如果您查看代码中的switch语句，那么对于每种情况都有很多相同的语句。一个诀窍是看每种情况下答案的变化。我也是。只有数字变了。这是简化事情的好方法。我不认为这是故意的，但你有两个案子，结果是128。你可以做一些额外的简化。很难确切知道，因为我知道您拥有的样本数据与您正在使用的实际数据不完全相同。我之所以这样评论，是因为这实际上是一个很好的教学时刻——如果你有相同的结束案例，那就值得好好研究一下。请注意switch语句和if语句的概念之间的相似性。在函数中，如果您有一个return语句，它的行为将类似于switch语句的中断。如果在每个If case之后返回，那么当您有足够的信息知道返回什么时，您将拥有与默认case相同的结果。例如，请参见表示return'125'的行。我们知道，如果我们达到这一点，125应该返回。

如果你在推同一个变量，我会考虑创建一个函数，它的唯一任务是基于变量确定正确的值。这可能是这样的：

const getContentValue(var1, var2, var3, i) {
 if (var1 === 1) {
   if (var2 === 0) {
     if (var3 === 'test') {
       if (i === 0) return '123'
       if (i === 2) return '124'
       return '125'
   }
   if (var2 === 1) {
     return '126'
   }
 }
 if (var1 === 2) {
   if (var2 === 0) {
     if (i === 0) return '127'
     if (i === 2) return '128'
   }
   if (var2 === 1) {
     if (i === 0) return '128'
     if (i === 2) return '129'
   }
 }
}

endResult.push({ id: i, content: getContentValue(var1, var2, var3, i) })

代码未经测试

需要注意的几件事和需要注意的几条原则：

你能告诉我你是怎么称呼这个的吗？我会考虑使用这个对象。虽然计算默认选项可能有点挑剔，但如果结构中没有未知值，您什么也不想做？这本质上是一系列条件，例如，可以将其重新编写为var1==1&&var2==0&var3=='test'&&i==0。如此多看似完全不同的旗帜的出现使设计受到质疑。它可能不需要重写，而需要重新设计来简化逻辑。但是，如果没有更全面的描述，很难说如何重新设计。另外，这可能是一个很好的问题。你能告诉我你是怎么调用这个的吗？我会考虑使用这个对象。虽然计算默认选项可能有点挑剔，但如果结构中没有未知值，您什么也不想做？这本质上是一系列条件，例如，可以将其重新编写为var1==1&&var2==0&var3=='test'&&i==0。如此多看似完全不同的旗帜的出现使设计受到质疑。它可能不需要重写，而需要重新设计来简化逻辑。但是，如果没有更全面的描述，很难说如何重新设计。另外，这可能是一个很好的问题。但Var3在哪里？@ACD没有回答，但我认为概念是明确的。也应该添加它。如果它转到案例2并且var3有值，那么它将不起作用。如果在var1==2 var3=时添加条件，则会失去作用；但Var3在哪里？@ACD没有回答，但我认为这个概念很清楚。也应该添加它。如果它转到案例2并且var3有值，那么它将不起作用。如果在var1==2 var3=时添加条件，则会失去作用；