¿Por qué usarías una tarea en una condición?

Question

En muchos idiomas las asignaciones son legales en las condiciones. Nunca entendí la razón detrás de esto. ¿Por qué escribirías:

if (var1 = var2) { 
    ... 
} 

en lugar de:

var1 = var2; 
if (var1) { 
    ... 
} 

Answer 1

Es más útil para bucles que declaraciones if.

while(var = GetNext()) 
{ 
    ...do something with var 
} 

que de otro modo tienen que ser escritos

var = GetNext(); 
while(var) 
{ 
...do something 
var = GetNext(); 
} 

Answer 2

Puede ser útil si usted está llamando a una función que devuelve o datos para trabajar o una bandera para indicar un error (o que ya terminaste).

Algo así como:

while ((c = getchar()) != EOF) { 
    // process the character 
} 

// end of file reached... 

lo personal es un idioma que no soy aficionado a la enorme, pero a veces la alternativa es más feo.

Answer 3

Es más útil si se llama a una función:

if (n = foo()) 
{ 
    /* foo returned a non-zero value, do something with the return value */ 
} else { 
    /* foo returned zero, do something else */ 
} 

Claro, usted puede simplemente poner el n = foo(); en una declaración separada, entonces si (n), pero creo que lo anterior es una expresión bastante legible.

Answer 4

La expresión idiomática es más útil cuando escribe un bucle while en lugar de una instrucción if. Para una declaración if, puede dividirla según lo describe. Pero sin esta construcción, ya sea que usted tiene que repetir:

c = getchar(); 
while (c != EOF) { 
    // ... 
    c = getchar(); 
} 

o utilizar una estructura de bucle-and-a-media:

while (true) { 
    c = getchar(); 
    if (c == EOF) break; 
    // ... 
} 

Por lo general se prefiere el bucle-y-a- mitad de forma.

Answer 5

GCC puede ayudar a detectar (con -Wall) si involuntariamente intenta utilizar una asignación como un valor de verdad, en caso de que recomienda que escribe

if ((n = foo())) { 
    ... 
} 

es decir, use paréntesis adicionales para indicar que esto es realmente lo que quiere.

Answer 6

En PHP, por ejemplo, es útil para el bucle a través de resultados de base de datos SQL:

while ($row = mysql_fetch_assoc($result)) { 
    // Display row 
} 

Esto se ve mucho mejor que:

$row = mysql_fetch_assoc($result); 
while ($row) { 
    // Display row 
    $row = mysql_fetch_assoc($result); 
} 

Answer 7

Lo encuentro más útil en cadenas de acciones que a menudo implican la detección de errores, etc.

if ((rc = first_check(arg1, arg2)) != 0) 
{ 
    report error based on rc 
} 
else if ((rc = second_check(arg2, arg3)) != 0) 
{ 
    report error based on new rc 
} 
else if ((rc = third_check(arg3, arg4)) != 0) 
{ 
    report error based on new rc 
} 
else 
{ 
    do what you really wanted to do 
} 

La alternativa (no utilizando la asignación en la condición) es:

rc = first_check(arg1, arg2); 
if (rc != 0) 
{ 
    report error based on rc 
} 
else 
{ 
    rc = second_check(arg2, arg3); 
    if (rc != 0) 
    { 
     report error based on new rc 
    } 
    else 
    { 
     rc = third_check(arg3, arg4); 
     if (rc != 0) 
     { 
      report error based on new rc 
     } 
     else 
     { 
      do what you really wanted to do 
     } 
    } 
} 

Con la comprobación de errores prolongada, la alternativa puede funcionar con el RHS de la página mientras que la versión asignación-in-condicional no hace eso.

Answer 8

La respuesta corta es que Expression-oriented lenguajes de programación permiten un código más sucinto. No te fuerces a separate commands from queries.

Answer 9

La otra ventaja viene durante el uso de gdb. En el siguiente código, el código de error no se conoce si tuviéramos un solo paso.

while (checkstatus() != -1) { 
    // process 
} 

En lugar

while (true) { 
    int error = checkstatus(); 
    if (error != -1) 
     // process 
    else 
     //fail 
} 

Ahora, durante un solo paso que se puede saber cuál era el código de error de retorno de la checkStatus().

Answer 10

La razón es:

1. Mejora del rendimiento (A veces)

2. Menor de código (siempre)

Tomemos un ejemplo: Hay un método someMethod() y en un if condición en la que desea verificar si el valor de retorno del método es null. Si no, vas a usar el valor de retorno nuevamente.

If(null != someMethod()){ 
    String s = someMethod(); 
    ...... 
    //Use s 
} 

Se obstaculizará el rendimiento ya que está llamando al mismo método dos veces. En lugar de usar:

String s; 
If(null != (s = someMethod())) { 
    ...... 
    //Use s 
}