Perché dovresti usare un compito in una condizione?

Question

In molte lingue gli incarichi sono legali nelle condizioni. Non ho mai capito il motivo dietro questo. Perché dovresti scrivere:

if (var1 = var2) {
  ...
}

anziché:

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

Answer 1

È più utile per i loop che per le istruzioni if.

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

Che altrimenti dovrebbe essere scritto

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

Answer 2

È più utile se si chiama una funzione:

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

Certo, puoi semplicemente mettere n = foo (); su una dichiarazione separata quindi if (n), ma penso che quanto sopra sia un linguaggio abbastanza leggibile.

Answer 3

Lo trovo più utile in catene di azioni che spesso implicano il rilevamento di errori, ecc.

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
}

L'alternativa (che non utilizza l'assegnazione nella condizione) è:

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 il controllo dell'errore prolungato, l'alternativa può eseguire l'RHS della pagina mentre la versione assegnata in condizionale non lo fa.

I controlli degli errori potrebbero anche essere "azioni" & # 8212; first_action () , second_action () , third_action () & # 8212; ovviamente, piuttosto che solo controlli. Cioè, potrebbero essere controllati i passaggi nel processo che la funzione sta gestendo. (Molto spesso nel codice con cui lavoro, le funzioni sono sulla falsariga di controlli preliminari o allocazioni di memoria necessarie per il funzionamento della funzione, o su linee simili).

Answer 4

Può essere utile se stai chiamando una funzione che restituisce i dati su cui lavorare o un flag per indicare un errore (o che hai finito).

Qualcosa del tipo:

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

// end of file reached...

Personalmente è un idioma di cui non sono molto affezionato, ma a volte l'alternativa è più brutta.

Answer 5

GCC può aiutarti a rilevare (con -Wall) se tenti involontariamente di utilizzare un compito come valore di verità, nel caso in cui ti consiglia di scrivere

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

vale a dire. usa una parentesi extra per indicare che questo è davvero quello che vuoi.

Answer 6

Il linguaggio è più utile quando scrivi un ciclo while invece di un'istruzione if . Per un'istruzione if , puoi suddividerla come descritto. Ma senza questo costrutto, dovresti ripetere te stesso:

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

o usa una struttura ad anello e mezzo:

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

Preferirei di solito la forma ad anello e mezzo.

Answer 7

La risposta breve è che orientato all'espressione i linguaggi di programmazione consentono un codice più conciso. Non ti costringono a separare i comandi dalle query .

Answer 8

In PHP, ad esempio, è utile per scorrere ciclicamente i risultati del database SQL:

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

Sembra molto meglio di:

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

Answer 9

L'altro vantaggio deriva dall'uso di gdb. Nel codice seguente il codice di errore non è noto se dovessimo eseguire un solo passaggio.

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

Piuttosto

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

Ora durante il singolo passaggio possiamo sapere qual era il codice di errore di ritorno da checkstatus ().

Answer 10

Il motivo è:

1. Miglioramento delle prestazioni (a volte)

2. Codice minore (sempre)

Prendi un esempio: esiste un metodo someMethod () e in una condizione if vuoi verificare se il valore di ritorno del metodo è null . In caso contrario, utilizzerai nuovamente il valore restituito.

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

Ciò ostacolerà le prestazioni poiché si chiama lo stesso metodo due volte. Invece usa:

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