Per quanto riguarda la manutenzione, `else while` senza interventi ortodontici è considerato sicuro?

È else whilesenza intervenire bretelle considerati manutenzione "sicuro" saggio?

Scrivere if-elsecodice senza parentesi graffe come di seguito ...

if (blah)
    foo();
else
    bar();

... comporta un rischio perché la mancanza di parentesi graffe rende molto semplice modificare inavvertitamente il significato del codice.

Tuttavia, sotto è anche rischioso?

if (blah)
{
    ...
}
else while (!bloop())
{
    bar();
}

O else whilesenza le parentesi graffe senza intervento è considerato "sicuro"?

Questo mi ricorda questo codice:

if ( ... ) try {
..
} catch (Exception e) {
..
} else {
...
}

Ogni volta che si combinano due tipi di blocchi, dimenticando le parentesi graffe e non aumentando il rientro, si sta creando un codice molto difficile da capire e mantenere.

Forse è perché ho imparato il mio mestiere (molto tempo fa) usando il metodo Jackson Entity Structure Diagram , ma sottoscrivo l'opinione secondo cui l'unico termine corretto senza limiti dopo un ifo un elseè un successivo if(ovvero consentire una else ifscala)

Qualsiasi altra cosa (nessun gioco di parole intenzionale) lascia il potenziale per incomprensioni e / o problemi di manutenzione. Questo è l'aspetto centrale dell'idea che i PO siano "non sicuri".

Sarei anche molto cauto nell'includere while()la stessa linea del else- se rinforzato o no. Non mi sembra giusto ... la mancanza di maschere di rientro extra che è la elseclausola. E la mancanza di chiarezza crea incomprensioni (vedi sopra).

Quindi nell'esempio consiglierei / raccomanderei fortemente (e insisto, nel mio team) su:

if ( blah )
{
    ...
}
else
{
    while ( !bloop() )
    {
        bar();
    }
}

Certo, mi aspetterei anche di vedere anche i commenti adatti.

-- Modificare --

Recentemente Apple ha sofferto di una vulnerabilità SSL, causata da una scarsa correzione della manutenzione, che ha aggiunto una seconda linea a una singola linea non rinforzata. Quindi mettiamo a letto l'idea che le linee singole non incrociate siano OK?

Mi è sempre stato insegnato a tenere tutto tra parentesi graffe, rientrato e commentato. Credo che sia molto più facile leggere e individuare errori. Personalmente ritengo che la modularità sia la chiave, quindi scrivo sempre il codice in questo modo:

    if(blah)
    {
     ....
    }
    else
    {
       while(!bloop()
       {
        bar;
       }
    }

Vorrei estrarre il metodo e farlo

if ( blah )
{
    ...
}
else
{
   newMethod();
}

Vedi l'approccio "Estrai metodo" spiegato nel sito del Catalogo Refactoring :

Hai un frammento di codice che può essere raggruppato insieme.

Trasforma il frammento in un metodo il cui nome spiega lo scopo del metodo.

void printOwing() {
    printBanner();

    //print details
    System.out.println ("name:    " + _name);
    System.out.println ("amount    " + getOutstanding());
}

                                                                                                        

void printOwing() {
    printBanner();
    printDetails(getOutstanding());
}

void printDetails (double outstanding) {
    System.out.println ("name:    " + _name);
    System.out.println ("amount    " + outstanding);
}

Lo considererei una cattiva abitudine di programmazione. A volte funziona perfettamente e non avrai problemi a compilare ed eseguire il codice. Altre volte può causare gravi bug e finirai per passare ore a risolvere quel bug.

Si consiglia sempre di modulare il codice. Se devi inserire un ciclo while nella parte altrimenti inseriscilo in un blocco in modo che gli altri, quando lavori sul tuo codice, possano facilmente comprendere la logica.

if ( blah )
{
    ...
}
else
{
    while ( !bloop() )
    {
        bar();
    }
}

È buona norma inserire il codice in blocchi. Rende anche più semplice e facile la comprensione e il debug.

Potrebbe andare bene se rimane così, anche se personalmente non mi piace e la mia preferenza è quella di usare le parentesi graffe anche per i blocchi di codice if / else più semplici. È solo più ordinato per me.

Tuttavia, dove questo diventa disordinato è quando hai annidato se / else ne esegue alcuni con parentesi graffe, altre senza. Un ciclo While in mezzo a tutti quegli spaghetti! Ho lavorato così tanto con il codice ed è un incubo il debug e la comprensione. Questo segue dal primo punto che va bene quando rimane semplice e tu ne sei contento, ma poi arrivano altri programmatori che aggiungono cose, probabilmente un if nel ciclo while. Se in primo luogo è scritto pulito, allora ci sono meno possibilità che ciò accada.

Il punto è chiarire le cose in modo che altri programmatori possano vedere a colpo d'occhio ciò che è giusto e ciò che è sbagliato. Scrivi il codice in modo tale che il modello appaia corretto e non si barchi.

Il rovescio della medaglia di questo è che forse potrei vedere alcune persone affermare che in alcuni casi questo legge bene. Se ho la risorsa di cui ho bisogno, eseguo questa elaborazione altrimenti sto aspettando qualcosa. Anche allora per me non c'è ancora alcuna differenza nel nidificare il ciclo while all'interno del blocco else.

Bene, nonostante tutti discutano sull'uso delle parentesi graffe e sembrano amarle, in realtà preferisco il contrario. Uso le parentesi graffe solo quando devo perché lo trovo più leggibile e conciso senza.

if (...)
   foo();
else while(...)
   bar();

... Trovo davvero questo " else while(...)" leggibile in modo notevole! Sembra persino un inglese semplice! Ma immagino che la gente lo troverà strano perché è inusuale a dir poco.

Alla fine, tendiamo tutti a renderlo a prova di idiota con le parentesi graffe però ... perché, beh, lo sai.

Metto sempre le parentesi graffe, solo perché potresti aggiungere un'altra riga quando sei di fretta, rientrare, dimenticare le parentesi graffe e grattarti la testa cosa sta succedendo. Tengo la staffa di apertura sulla stessa linea, ma non importa. In entrambi i casi è meglio averli.

if(blah) {
    foo();
}
else {
    bar();
}

Cosa c'è di così sbagliato nelle parentesi graffe che così tante persone stanno cercando di evitare di scriverle?

Quale problema else whilerisolve esattamente ?

Le parentesi graffe sono economiche e buone e rendono evidente e chiara l'intenzione del codice al contrario di intelligente e arguta.

Citando la filosofia Unix:

Regola di chiarezza: la chiarezza è meglio dell'intelligenza.

Poiché la manutenzione è così importante e così costosa, scrivi i programmi come se la comunicazione più importante che fanno non fosse al computer che li esegue ma agli esseri umani che leggeranno e manterranno il codice sorgente in futuro (incluso te stesso).

Non c'è niente di sbagliato in

if (blah)
    foo();
else
    bar();

proprio come non c'è niente di sbagliato in

if (blah) foo(); else bar();

nelle giuste circostanze (le tue circostanze possono variare, ma quello stile particolare è meglio usato quando hai un sacco di codice ripetitivo - quindi la vista di ogni riga è più importante del rientro stilistico)

Ma se scegli un modo, seguilo: la coerenza è il re. Quindi il tuo secondo esempio è pessimo, poiché l'espressione if aveva parentesi per la sua istruzione, l'istruzione while dovrebbe trovarsi tra parentesi per la clausola else, non al di fuori di essa.

inoltre, ho visto questo codice prima:

if (x) foo()
{
  bar();
}

ed è stato scritto dallo standard di codifica nazista stesso (che ha insistito sulle parentesi per tutto).

Gli IDE moderni possono essere facilmente configurati per riformattare (inclusa la rimozione o l'aggiunta di parentesi graffe non necessarie) e / o reindirizzare il codice al salvataggio di un file. Quindi il tuo esempio sembrerebbe automaticamente per esempio

if (blah) {
  blub();
} else
  while (!bloop()) {
    bar();
  }

Il rientro rende sempre facilmente visibile l'annidamento, anche senza parentesi graffe non necessarie. Quindi, se riesci ad applicare tali impostazioni IDE, non vedo alcun rischio.

Personalmente, trovo il codice che omette le parentesi graffe e le interruzioni di riga molto più leggibile poiché evita il disordine:

if (blah) blub();
else while (!bloop()) bar();

Ma, naturalmente, molti sviluppatori sono molto felici di discutere di queste cose per sempre e un giorno.