Обработка более 2 возможных возвращенных значений?

Question

Когда функция возвращает логическое значение вы можете легко

if (task()){ 
    // it worked! 
}else{ 
    // it failed. 
} 

Но когда она возвращает несколько различных значений становится хаотичным

var status = task(); 
if (status == 1){ 
    // hmm 
}else if (status == 2){ 
    // hmmmmm 
}else if (status == 3){ 
    // hmmmmmmmm! 
} 

..is там аккуратнее способ обращения с ним?

Редактировать: В ответ на ответы, которые рекомендуют инструкции переключателей, да, я знаю об этом. Я просил о чем-то более аккуратном, чем об этом?

Answer 1

В зависимости от возможностей языка,, но я хотел бы сделать что-то вроде этого в JavaScript:

var handle_task_1 = function() { 
    // handle task 1 
}; 

var handle_task_2 = function() { 
    // handle task 2 
}; 

var tasks = { 
    1: handle_task_1, 
    2: handle_task_2, 

    "default": function() {}, 
}; 

tasks[task()](); 

// Or, with a default action. But it may be too much for some people :) 
(tasks[task()] || tasks["default"])(); 

Answer 2

Большинство языков имеют switch statement, что-то вроде:

switch (task()) { 
    case 1: // do stuff 
     break; 
    case 2: // other stuff 
     break; 
    /// etc. 
    default: // what?! 
     Error("Unhandleable status code"); 
} 

Answer 3

Я не могу сказать, какой язык вы используете (? JavaScript), но я обычно пишу такой код:

var result = task(); 

switch (result) 
{ 
    case 1: 
     handleStatus1(); 
     break; 
    case 2: 
     handleStatus2(); 
     break; 
    default: 
     handleEverythingElse(); 
     break; 
} 

Answer 4

Если вы говорите о целочисленном или другом примитивном возвращаемом типе, лучший подход, который я знаю, - это оператор switch.

switch (status) 
{ 
case 1: 
    // hmm 
    break; 
case 2: 
    // hmmm 
    break; 
} 

Однако, если вы возвращаете объект, который определяет поведение, следуя методу вызова, вещи становятся намного опрятными.

Скажем, у вас есть интерфейс ISomething и два (или более) объекта, реализующих этот интерфейс (ASomething и BSomething). Если метод в возвращаемом типе ISomething, код становится:

ISomething result = task(); 
result.DoSomething(); 

Answer 5

Если вы много прикованы если команды каждый из которых выполняет уникальный блок кода, вы можете использовать карту простых классов-функторов. В идеале, при запуске приложения будет заполнить эту карту, и вы можете просто вызвать действия от экземпляра этой карты

код будет выглядеть следующим образом

Action action = (Action) contextMap.get(task()); 
action.do(); 

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

Есть некоторые другие приятные вещи об этом подходе

1. Таска() и taskB() могут разделить ту же contextMap и даже некоторые из тех же действий, так что у вас меньше кода дублирования
2. Действия могут быть блок испытания более легко (обычно)
3. Совместное использование кода между действиями будет легко, не разрывая с кодом спагетти или сложным, если (состояние> 2 & & статус! = 7) заявления

И, конечно же, здесь помогают интерфейсы, варгары и другие синтаксические сахара.

Answer 6

Возможно, вы ищете exceptions?

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