Java standard di Codifica / best practices - convenzione di denominazione per la pausa/continuare etichette

Question

A volte una etichetta pausa o continuare il codice molto più leggibile.

OUTERLOOP: for ( ;/*stuff*/; ) {
    //...lots of code

    if ( isEnough() ) break OUTERLOOP;
    //...more code
}

Mi chiedevo che cosa il comune la convenzione per le etichette è.Tutti i tappi?primo cap?

Answer 1

Se è necessario utilizzare loro di utilizzare capitali, questo attira l'attenzione su di loro e sceglie fuori dall'essere erroneamente interpretato come "Classe" di nomi.Attirare l'attenzione ha l'ulteriore vantaggio di catturare qualcuno che arriverà e il refactoring del codice e rimuoverli.;)

Answer 2

Non ho capito dove questo "non utilizzare etichette" regola viene da.Quando si fa non banale logica di loop, il test per la pausa o continuare non sempre ordinatamente alla fine del circostante blocco.

outer_loop:
for (...) {
  //  some code
  for (...) {
    //  some code
    if (...)
      continue outer_loop;
    //  more code
  }
  //  more code
}

Sì, in casi come questo accadono tutto il tempo.Quali sono le persone suggerendo io uso invece?Una condizione booleana come questo?

for (...) {
  //  some code
  boolean continueOuterLoop = false;
  for (...) {
    //  some code
    if (...) {
      continueOuterLoop = true;
      break;
    }
    //  more code
  }
  if (continueOuterLoop)
    continue;
  //  more code
}

Che schifo! Refactoring come un metodo non allevia che:

boolean innerLoop (...) {
  for (...) {
    //  some code
    if (...) {
      return true;
    }
    //  more code
  }
  return false;
}

for (...) {
  //  some code
  if (innerLoop(...))
    continue;
  //  more code
}

Certo è un po ' più bella, ma è ancora passando per un superfluo booleano.E se il ciclo interno modificato le variabili locali, refactoring in un metodo non è sempre la soluzione corretta.

Allora, perché sono tutti contro di etichette?Mi date qualche solidi motivi, e pratiche alternative per il caso di cui sopra.

Answer 3

La convenzione per evitare le etichette del tutto.

Sono molto, molto pochi motivi validi per usare un'etichetta per la rottura di un ciclo.La rottura è ok, ma è possibile rimuovere la necessità di rompere a tutti, modificando il vostro disegno un po'.Nell'esempio che hai dato, si estrae l' 'un Sacco di codice' sezioni e metterli in singoli metodi con nomi significativi.

for ( ;/*stuff*/; ) 
{
    lotsOfCode();

    if ( !isEnough() )
    {
        moreCode();
    }
}

---

Edit: dopo aver visto il codice in questione (qui), Penso che l'uso di etichette è probabilmente il modo migliore per rendere il codice leggibile.Nella maggior parte dei casi l'utilizzo di etichette è l'approccio sbagliato, in questo caso, penso che sia bene.

Answer 4

Java di Sun codice stile sembrano preferire la nomina di etichette nello stesso modo come le variabili, il che significa cammello caso con la prima lettera in minuscolo.

Answer 5

La convenzione l'ho più visto è semplicemente cammello caso, come il nome di un metodo...

myLabel:

ma ho anche visto etichette preceduto da un carattere di sottolineatura

_myLabel:

o con laboratorio...

labSomething:

Si può probabilmente senso se le altre risposte che ti verrà difficile-spinto a trovare una codifica standard che dice qualcosa di diverso da "non utilizzare etichette'.La risposta, credo, è che si dovrebbe utilizzare qualsiasi stile che ha senso per voi, purché coerenti.

Answer 6

wrt di sadie esempio di codice:

Hai dato

outerloop:
for (...) {
  //  some code
  for (...) {
    //  some code
    if (...)
      continue outerloop;
    //  more code
  }
  //  more code
}

Come esempio.Fate un buon punto.La mia ipotesi migliore sarebbe:

public void lookMumNoLabels() {
  for (...) {
    // some code
    doMoreInnerCodeLogic(...);
  }
}

private void doMoreInnerCodeLogic(...) {
   for (...) {
      // some code
      if (...) return;
   }
}

Ma ci sono esempi in cui questo tipo di refactoring non sedersi correttamente con qualsiasi logica che si sta facendo.

Answer 7

Come etichette sono così raramente utile, sembra che non vi è alcuna convenzione.La specifica del linguaggio Java è un esempio di etichette e sono in non_cap.

Ma dal momento che sono così rari, a mio parere è meglio pensare due volte se sono davvero lo strumento giusto.

E se essi sono lo strumento giusto, li tutti i tappi in modo che altri sviluppatori (o te più tardi) si rendono conto loro come qualcosa di insolito subito.(come Craig già sottolineato)

Answer 8

La convetion/buona pratica sarebbe ancora di non utilizzarli a tutti e a rifattorizzare il codice in modo che sia più leggibile utilizzando estratto come metodo.

Answer 9

Essi sono una specie di goto di Java - non so se C# li ha.Non li ho mai usati, in pratica, non riesco a pensare a un caso di evitare di loro non sarebbe risultato molto più leggibile il codice.

Ma, se - penso che scrivere tutto in maiuscolo è ok.La maggior parte delle persone non utilizza etichettati interruzioni, in modo che quando vanno a vedere il codice, i tappi saltano fuori a loro e li costringerà a rendersi conto di cosa sta succedendo.

Answer 10

Lo so, non dovrei usare etichette.

Ma assumere solo, ho un po ' di codice, che potrebbe guadagnare molto in leggibilità dall'etichetta interruzioni, come faccio a formattare.

Mo, la tua premessa è sbagliata.La questione non dovrebbe essere " come faccio a formattare?'

La tua domanda dovrebbe essere " ho un codice che ha una grande quantità di logica all'interno di cicli - come faccio a renderlo più leggibile?'

La risposta a questa domanda è quello di spostare il codice in singole, anche denominato funzioni.Quindi non c'è bisogno di etichettare le pause a tutti.