Вы считали это на сглаживающемся коде стрелки от Кодирования Ужаса?

Можно заменить бросок возвратом или goto при использовании языка без исключений.

Вы думали о Google "Чистые Переговоры по Коду - Наследование, Полиморфизм, и Тестировали" видео? Это обсуждает подходы к использованию Объектно-ориентированных методов, чтобы удалить если/переключатель условные выражения.

Я на самом деле записал о том, как решить, это выходит в моем блоге в апреле 2008. Смотрите здесь и сообщите мне то, что Вы думаете.

Я рекомендую Вам:

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

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

3. Вы сделаны. Разве это не было легко?:)

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

P.S. Это не дешевая попытка сам продвижение; я был ТАК пользователь в течение долгого времени теперь, и это - первый раз, когда я связался со своим блогом - и я только сделал поэтому, потому что я думаю, что это релевантно.

Вы могли бы хотеть посмотреть на Стратегическую модель, где вместо того, чтобы поместить длинную цепочку IFS со связанными условиями, Вы абстрагируете каждое условие к различному объекту, каждое определение что его определенное поведение.

Класс, который определяет те объекты, реализует Интерфейс, который назовет родительский объект.

Вы не говорите, какой язык Вы используете, но если Вы используете язык OO, такой как C++, C# или Java, можно часто использовать виртуальные функции для решения той же проблемы, как Вы в настоящее время решаете с a switch оператор, и более расширяемым способом. В случае C++ сравните:

class X {
public:
    int get_type();     /* Or an enum return type or similar */
    ...
};

void eat(X& x) {
    switch (x.get_type()) {
    TYPE_A: eat_A(x); break;
    TYPE_B: eat_B(x); break;
    TYPE_C: eat_C(x); break;
    }
}

void drink(X& x) {
    switch (x.get_type()) {
    TYPE_A: drink_A(x); break;
    TYPE_B: drink_B(x); break;
    TYPE_C: drink_C(x); break;
    }
}

void be_merry(X& x) {
    switch (x.get_type()) {
    TYPE_A: be_merry_A(x); break;
    TYPE_B: be_merry_B(x); break;
    TYPE_C: be_merry_C(x); break;
    }
}

с

class Base {
    virtual void eat() = 0;
    virtual void drink() = 0;
    virtual void be_merry() = 0;
    ...
};

class A : public Base {
public:
    virtual void eat() { /* Eat A-specific stuff */ }
    virtual void drink() { /* Drink A-specific stuff */ }
    virtual void be_merry() { /* Be merry in an A-specific way */ }
};

class B : public Base {
public:
    virtual void eat() { /* Eat B-specific stuff */ }
    virtual void drink() { /* Drink B-specific stuff */ }
    virtual void be_merry() { /* Be merry in an B-specific way */ }
};

class C : public Base {
public:
    virtual void eat() { /* Eat C-specific stuff */ }
    virtual void drink() { /* Drink C-specific stuff */ }
    virtual void be_merry() { /* Be merry in a C-specific way */ }
};

Преимущество состоит в том, что можно добавить новый Base- производные классы D, E, F и так далее не имея необходимость касаться любого кода, который только имеет дело с указателями или ссылками на Base, таким образом, нет ничего, что может стать устаревшим путь который a switch оператор может в исходном решении. (Преобразование выглядит очень похожим в Java, где методы являются виртуальными по умолчанию, и я уверен, что это выглядит подобным в C# также.) На крупном проекте это - огромная победа пригодности для обслуживания.

Как насчет:

/* Code Block 1... */

if(/* result of some condition or function call */)
{
   /* Code Block 2... */

   if(/* result of some condition or function call */)
   {
      /* Code Block 3... */

      if(/* result of some condition or function call */)
      {
         /* Code Block 4... */
      }
   }
}

Становится этим:

/* Code Block 1... */
IsOk = /* result of some condition or function call */

if(IsOK)
{
   /* Code Block 2... */
   IsOk = /* result of some condition or function call */
}

if(IsOK)
{
   /* Code Block 3...*/
   IsOk = /* result of some condition or function call */
}

if(IsOK)
{
   /* Code Block 4...*/
   IsOk = /* result of some condition or function call */
}

/* And so on... */

Можно, конечно, возвратиться, если когда-нибудь IsOk становится ложью, при необходимости.