Question

我正在尝试通过减少重复次数来改进我的代码。

在这里的代码中，我想避免这个切换步骤，因为除了比较运算符===和!==之外，不同的情况是相同的。

function Test(step, nb_change, name, value, previous_name){
    switch (step) {
        case 1:
            for (var i = 0; i < nb_change; i++) {
                if (name === previous_name[nb_change-1-i][1] && value === 'nd') {
                    To_change(i);
                    return true;
                }
            }
            return false;
        case 2:
            for (var i = 0; i < nb_change; i++) {
                if (name === previous_name[nb_change-1-i][1] && value !== 'nd') {
                    To_change(i);
                    return true;
                }
             }
             return false;
        case 3:
            for (var i = 0; i < nb_change; i++) {
                if (select_name !== previous_name[nb_change-1-i][1] && value !== 'nd') {
                    To_change(i);
                    return true;
                }
            }
            return false;
        default:
            alert('ERROR');
            break;
    }
}

不要犹豫，提出一个可以帮助我的解决方案。

这只是一个案例！如果我认为可以更好地编写代码，我怎样才能找到帮助来改进我的代码呢？

感谢您的帮助。

Answer 1

您可以使用接收描述应如何处理相等性的参数的函数。在这里，我们可以利用按位运算来提供所需的描述。

function Test(step, nb_change, name, value, previous_name) {
    const BOTH_EQ = 3;
    const NAME_EQ = 2;
    const NO_EQ = 0;

    switch (step) {
        case 1:
            return myFunc(BOTH_EQ, nb_change, name, previous_name, value);
        case 2:         
            return myFunc(NAME_EQ, nb_change, name, previous_name, value);
        case 3:          
            return myFunc(NO_EQ, nb_change, name, previous_name, value)
        default:
            alert('ERROR');
            break;
    }
}

function myFunc(compare, nb_change, name, previous_name, value) {
    for (var i = 0; i < nb_change; i++) {
        const first_eq = (name === previous_name[nb_change-1-i][1]) << 1;
        const second_eq = value === 'nd';

        if (compare === (first_eq | second_eq)) {
            To_change(i);
            return true;
        }
    }
    return false;
}

compare参数传递命名常量，用于描述第一次相等比较OR的结果（向左移一位）和第二次相等比较。

这是有效的，因为true将被强制转换为1和false至0。所以我们有四个可能的结果：

true, true   == ((true << 1)  | true)  == ((1 << 1) | 1) == (0010 | 0001) == 3
true, false  == ((true << 1)  | false) == ((1 << 1) | 0) == (0010 | 0000) == 2
false, true  == ((false << 1) | true)  == ((0 << 1) | 1) == (0000 | 0001) == 1
false, false == ((false << 1) | false) == ((0 << 1) | 0) == (0000 | 0000) == 0

Answer 2

也许是这样的。

＆＃13;

function Test(step, nb_change, name, value, previous_name){
  var result = false;    
  for (var i = 0; i < nb_change; i++) {
    var result = false;
    switch (step) {
      case 1:
        result = name === previous_name[nb_change-1-i][1] && value === 'nd';
        break;
      case 2:
        result = name === previous_name[nb_change-1-i][1] && value !== 'nd';
        break;
      case 3:
        result = name !== previous_name[nb_change-1-i][1] && value !== 'nd'
        break;
     default:
        alert('ERROR');
        break;
    }

    if (result) {
        To_change(i);
        return true;
    }
  }
  return false;
}

＆＃13;

Answer 3

function Test(step, nb_change, name, value, previous_name){
    var valueCheck,
        nameCheck;

    switch (step) {
        case 1:
          valueCheck = value === 'nd';
          nameCheck = name === previous_name[nb_change-1-i][1];
        case 2:
          valueCheck = value !== 'nd');
          nameCheck = name === previous_name[nb_change-1-i][1];
        case 3:
          valueCheck = value !== 'nd';
          nameCheck = select_name !== previous_name[nb_change-1-i][1];
        default:
            alert('ERROR');
            break;
    }

    for (var i = 0; i < nb_change; i++) {
        if (nameCheck && valueCheck) {
            To_change(i);
            return true;
        }
    }
    return false;
}

Javascript改进代码切换语句

3 个答案: