Cómo dejar de escribir código de cadena?

Question

por ejemplo ...

if ( /* Condition */ ) {

    if ( /* Condition */ ) {

        if ( /* Condition */ ) {

          // Superb!

        } else {

          // Error 3

        }

    } else {

      // Error 2

    }

} else {

  // Error 1

}

¿Usted sabe cómo evitar esto? Gracias!

Answer 1

Si esta es una función de biblioteca, throw puede ser la acción apropiada.

if (!condition1) {
    throw "Condition 1 failed.";
}

if (!condition2) {
    throw "Condition 2 failed.";
}

if (!condition3) {
    throw "Condition 3 failed.";
}

// Superb!

Otras acciones aceptables pueden ser:

• Volviendo 0, null o undefined.
• Viendo un error al usuario y volver.

tendrá que determinar qué acción de falla es adecuado para su caso de uso.

Answer 2

Parece que usted tiene 3 condiciones para comprobar y 4 acciones (3 errores diferentes de éxito + 1). Por desgracia, en el caso general que va a requerir comprobaciones condicionales 3 y 4 acciones. Creo que el código se puede limpiar un poco con la siguiente estructura, aunque

if (! /* condition 1 */ ) {
  // Error 1
} else if (! /* condition 2 */ ) { 
  // Error 2
} else if (! /* condition 3 */ ) { 
  // Error 3
} else {
  // superb
}

Answer 3

Bien se puede utilizar excepciones, o se rompe dentro de un bloque, o múltiples funciones. A menudo, esto requiere la inversión de sus condiciones para obtener el código ordenado de la manera correcta.

do {
    if (! /* Condition 1 */ ) {
        // Error 1
        break;
    }

    if (! /* Condition 2 */ ) {
        // Error 2
        break;
    }

    if (! /* Condition 3 */ ) {
        // Error 3
        break;
    }

    // Superb!
} while (false);

El do-while (falsa) de bucle es una forma de hacer un bloque que se puede romper en idiomas que no toleran un bloque anónimo. Podría ser simplemente tan fácilmente una función y uso devoluciones o un try-catch con excepciones.

Answer 4

¿Prefiere esto?

if ( /* Condition 1*/ && /* Condition 2*/ && /* Condition 3 */) {
  // Superb!
}
else if (! /* Condition 1*/){
  // Error 1
}
else if (! /* Condition 2*/){
  // Error 2
}
else if (! /* Condition 3*/){
  // Error 3
}

Answer 5

if ( ! /* Condition */ ) {
Error 1
throw someSortOfException
}

if (! condition 2){
Error 2
throw someSortOfOtherException
}

if (! condition 3){
Error 3
throw another Exception
}

// Success!

Dependiendo de la situación, el código puede ser preferido. Es probable que se desea capturar esas excepciones en algún lugar, por ejemplo.

Answer 6

if (!condition1)
    // Error 1 (and exit scope if necessary)

if (!condition2)
    // Error 2 (and exit scope if necessary)

if (!condition3)
    // Error 3 (and exit scope if necessary)

// Superb!

Answer 7

Sí; puede componer juntos sus declaraciones if en una sentencia compuesta solo con el operador, y manejar las condiciones de error en un solo bloque. En función de sus necesidades de tratamiento de error, sin embargo, puede que tenga que volver a tener múltiples ifs para asegurarse de que está adecuadamente el manejo del error (que depende de su manejo de la resolución de errores, en realidad).

A saber:

if (CondA && CondB && CondC)
   {
   // Execute success
   }
else
   {
   if (!CondA)
      // Do error A
   else if (!CondB)
      // Do error B
   else if (!CondC)
     // Do error C
   }
}

Answer 8

Hay algunas maneras, lo más sencillo es simplemente busto de algunas funciones y abstraer las diferentes capas (esto se debe hacer de todos modos si se encuentra pasando profunda.)

if ( /* Condition */ ) {
    value = aFunctionSaysWhat();
} else {
  // value = Error 1
}

....
value aFunctionSaysWhat(){
    if ( /* Condition */ ) {
         return aSecondFunctionHere();
    } else {
      // return Error 2
    }
}

La premisa básica es que una función debe vivir en una capa de abstracción si es posible, y hacer una cosa.

La siguiente posibilidad es aplanar todo hacia fuera, esto es superior a su método anidado inicial, pero básicamente tiene complejidad similar. Podría ser mucho más limpio que el enfoque funcional si sólo tiene unas pocas opciones y no tengo planes de añadir más.

if(ErrorCondition1){
   //Error 1
}else if(ErrorCondition2){
   //Error 2
}else if(ErrorCondition3){
   //Error 3
}else{
   //Superb
}

Por último, se puede almacenar un hash o mapa con las respuestas deseadas y retirar el caso por completo, la capacidad de poner en práctica este se basa en su capacidad de hash de algún resultado:

Results = {'Result1':'Error1', 'Result2':'Error2', 'Result3':'Error3', 'Success':'Superb'}

return Results[ConditionHash(Condition)];