language-agnostic - ternario - que es if else en programacion

La mejor forma de formatear la declaración if con múltiples condiciones

Question

Si desea que se ejecute algún código basado en dos o más condiciones, ¿cuál es la mejor forma de formatear ese enunciado if?

primer ejemplo: -

if(ConditionOne && ConditionTwo && ConditionThree)
{
Code to execute
}

Segundo ejemplo:

if(ConditionOne)
{
if(ConditionTwo )
{
if(ConditionThree)
{
Code to execute
}
}
}

que es más fácil de entender y leer teniendo en cuenta que cada condición puede ser un nombre de función larga o algo así.

Answer 1

En Perl puedes hacer esto:

{
( VeryLongCondition_1 ) or last;
( VeryLongCondition_2 ) or last;
( VeryLongCondition_3 ) or last;
( VeryLongCondition_4 ) or last;
( VeryLongCondition_5 ) or last;
( VeryLongCondition_6 ) or last;
# Guarded code goes here
}

Si alguna de las condiciones falla, continuará, después del bloqueo. Si está definiendo las variables que desea mantener después del bloque, deberá definirlas antes del bloque.

Answer 2

Creo que switch...case declaración del switch...case es la mejor manera de escribir código ordenado bajo esta circunstancia, si el lenguaje de programación lo admite.

switch (//variable or Boolean) {
case //Condition A:
case //Condition B:
case //Condition C:
//Code to execute;
}

Answer 3

Cuando la condición es realmente compleja, uso el siguiente estilo (ejemplo de la vida real de PHP):

if( $format_bool &&
(
( isset( $column_info[''native_type''] )
&& stripos( $column_info[''native_type''], ''bool'' ) !== false
)
|| ( isset( $column_info[''driver:decl_type''] )
&& stripos( $column_info[''driver:decl_type''], ''bool'' ) !== false
)
|| ( isset( $column_info[''pdo_type''] )
&& $column_info[''pdo_type''] == PDO::PARAM_BOOL
)
)
)

Creo que es más agradable y legible que anidar múltiples niveles de if() . Y en algunos casos como este, simplemente no puedes dividir la condición compleja en pedazos porque de lo contrario tendrías que repetir las mismas declaraciones en bloque if() {...} muchas veces.

También creo que agregar algo de "aire" al código siempre es una buena idea. Mejora la legibilidad en gran medida.

Answer 4

El primer ejemplo es más "fácil de leer".

En realidad, en mi opinión, solo debes usar el segundo cuando tengas que agregar alguna "lógica de lo demás", pero para un Condicional simple, usa el primer sabor. Si está preocupado por el largo de la condición, siempre puede usar la siguiente sintaxis:

if(ConditionOneThatIsTooLongAndProbablyWillUseAlmostOneLine
&& ConditionTwoThatIsLongAsWell
&& ConditionThreeThatAlsoIsLong) {
//Code to execute
}

¡Buena suerte!

Answer 5

El primero es más fácil porque, si lo lees de izquierda a derecha, obtienes: "Si algo Y algo, Y luego algo, luego", que es una oración fácil de entender. El segundo ejemplo dice "Si algo ENTONCES si algo falla ENTONCES si algo más ENTONCES", que es torpe.

Además, considere si desea usar algunas RUP en su cláusula. ¿Cómo lo haría en el segundo estilo?

Answer 6

El segundo es un ejemplo clásico de Arrow Anti-pattern Así que lo evitaría ...

Si sus condiciones son demasiado largas, extráigalas en métodos / propiedades.

Answer 7

Otras respuestas explican por qué la primera opción es normalmente la mejor. Pero si tiene varias condiciones, considere crear una función (o propiedad) por separado haciendo las verificaciones de condición en la opción 1. Esto hace que el código sea mucho más fácil de leer, al menos cuando usa buenos nombres de métodos.

if(MyChecksAreOk()) { Code to execute }
...
private bool MyChecksAreOk()
{
return ConditionOne && ConditionTwo && ConditionThree;
}

Las condiciones solo dependen de variables de alcance local, puede hacer que la nueva función sea estática y pasar todo lo que necesite. Si hay una mezcla, pase el material local.

Answer 8

Prefiero la Opción A

bool a, b, c;
if( a && b && c )
{
//This is neat & readable
}

Si tiene condiciones de variables / método particularmente largas, puede simplemente romperlas

if( VeryLongConditionMethod(a) &&
VeryLongConditionMethod(b) &&
VeryLongConditionMethod(c))
{
//This is still readable
}

Si son aún más complicados, entonces consideraría hacer los métodos de condición por separado fuera de la declaración if

bool aa = FirstVeryLongConditionMethod(a) && SecondVeryLongConditionMethod(a);
bool bb = FirstVeryLongConditionMethod(b) && SecondVeryLongConditionMethod(b);
bool cc = FirstVeryLongConditionMethod(c) && SecondVeryLongConditionMethod(c);
if( aa && bb && cc)
{
//This is again neat & readable
//although you probably need to sanity check your method names ;)
}

En mi humilde opinión, la única razón para la opción ''B'' sería si tiene else funciones separadas para ejecutar para cada condición.

p.ej

if( a )
{
if( b )
{
}
else
{
//Do Something Else B
}
}
else
{
//Do Something Else A
}

Answer 9

Se formuló la pregunta y, hasta ahora, se ha respondido como si la decisión se tomara únicamente por motivos "sintácticos".

Yo diría que la respuesta correcta de cómo se presentan una serie de condiciones dentro de un if, también debe depender de la "semántica". Por lo tanto, las condiciones se deben dividir y agrupar según lo que vaya de la mano "conceptualmente".

Si dos pruebas son realmente dos caras de la misma moneda, por ej. if (x> 0) && (x <= 100) luego colócalos juntos en la misma línea. Si otra condición es conceptualmente mucho más distante, por ejemplo. user.hasPermission (Admin ()) luego póngalo en su propia línea

P.ej.

if user.hasPermission(Admin()) {
if (x >= 0) && (x < 100) {
// do something
}
}

Answer 10

Supongo que en C no puedes simplemente escribir:

if ( variable = (1 || 2 || 3) ) {
do stuff;
}

¿O tal vez sea mejor usar una declaración de switch ?

Answer 11

 if ( ( single conditional expression A )
&& ( single conditional expression B )
&& ( single conditional expression C )
)
{
opAllABC();
}
else
{
opNoneABC();
}
Formatting a multiple conditional expressions in an if-else statement this way:
1) allows for enhanced readability:
a) all binary logical operations {&&, ||} in the expression shown
first
b) both conditional operands of each binary operation are obvious
because they align vertically
c) nested logical expressions operations are made obvious using
indentation, just like nesting statements inside clause
2) requires explicit parenthesis (not rely on operator precedence rules)
a) this avoids a common static analysis errors
3) allows for easier debugging
a) disable individual single conditional tests with just a //
b) set a break point just before or after any individual test
c) e.g. ...
// disable any single conditional test with just a pre-pended ''//''
// set a break point before any individual test
// syntax ''(1 &&'' and ''(0 ||'' usually never creates any real code
if ( 1
&& ( single conditional expression A )
&& ( single conditional expression B )
&& ( 0
|| ( single conditional expression C )
|| ( single conditional expression D )
)
)
{
... ;
}
else
{
... ;
}