Padrão/práticas recomendadas de codificação Java - convenção de nomenclatura para rótulos de interrupção/continuação

Question

Às vezes, um break ou continue rotulado pode tornar o código muito mais legível.

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

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

Fiquei me perguntando qual era a convenção comum para os rótulos.Tudo em maiúsculas?primeira tampa?

Answer 1

Se você tiver que usá-los, use letras maiúsculas, isso chama a atenção para eles e os impede de serem interpretados erroneamente como nomes de "classes".Chamar a atenção para eles tem o benefício adicional de chamar a atenção de alguém que irá refatorar seu código e removê-lo.;)

Answer 2

Não entendo de onde vem essa regra de "não usar rótulos".Ao fazer uma lógica de loop não trivial, o teste para interromper ou continuar nem sempre ocorre corretamente no final do bloco circundante.

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

Sim, casos como esse acontecem o tempo todo.O que as pessoas estão sugerindo que eu use?Uma condição booleana como esta?

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

Que nojo! Refatorá-lo como um método também não alivia isso:

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

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

Claro que é um pouco mais bonito, mas ainda está passando um booleano supérfluo.E se o loop interno modificou variáveis ​​locais, refatorá-lo em um método nem sempre é a solução correta.

Então, por que vocês são todos contra os rótulos?Dê-me algumas razões sólidas e alternativas práticas para o caso acima.

Answer 3

A convenção é evitar completamente os rótulos.

Existem muito poucos motivos válidos para usar um rótulo para sair de um loop.Quebrar está ok, mas você pode eliminar a necessidade de quebrar modificando um pouco seu design.No exemplo dado, você extrairia as seções 'Muito código' e as colocaria em métodos individuais com nomes significativos.

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

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

---

Editar: tendo visto o código real em questão (por aqui), acho que o uso de rótulos é provavelmente a melhor maneira de tornar o código legível.Na maioria dos casos, usar rótulos é a abordagem errada; neste caso, acho que está tudo bem.

Answer 4

O estilo de código Java da Sun parece preferir nomear rótulos da mesma forma que variáveis, significando caixa de camelo com a primeira letra em minúscula.

Answer 5

A convenção que mais vi é simplesmente camel case, como um nome de método...

myLabel:

mas também vi rótulos prefixados com um sublinhado

_myLabel:

ou com laboratório...

labSomething:

Você provavelmente pode perceber pelas outras respostas que será difícil encontrar um padrão de codificação que diga algo diferente de 'Não use rótulos'.Acho que a resposta é que você deve usar qualquer estilo que faça sentido para você, desde que seja consistente.

Answer 6

errado exemplo de código de Sadie:

Você deu

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

Como um exemplo.Você fez um bom ponto.Meu melhor palpite seria:

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

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

Mas haveria exemplos em que esse tipo de refatoração não se enquadra corretamente em qualquer lógica que você esteja fazendo.

Answer 7

Como os rótulos raramente são úteis, parece que não existe uma convenção clara.A especificação da linguagem Java possui um exemplo com rótulos e eles estão em non_cap.

Mas como são tão raros, na minha opinião é melhor pensar duas vezes se são realmente a ferramenta certa.

E se eles forem a ferramenta certa, coloque-os em letras maiúsculas para que outros desenvolvedores (ou você mesmo mais tarde) os percebam como algo incomum imediatamente.(como Craig já apontou)

Answer 8

A convenção/melhor prática ainda seria não usá-los e refatorar o código para que fique mais legível usando extrato como método.

Answer 9

Eles são uma espécie de goto do Java - não tenho certeza se o C # os possui.Nunca os usei na prática, não consigo pensar em um caso em que evitá-los não resultasse em um código muito mais legível.

Mas se você precisar, acho que usar letras maiúsculas está ok.A maioria das pessoas não usa quebras rotuladas; portanto, quando virem o código, as letras maiúsculas aparecerão e as forçarão a perceber o que está acontecendo.

Answer 10

Eu sei, não deveria usar rótulos.

Mas suponha que eu tenha algum código que possa ganhar muito em legibilidade com quebras rotuladas, como faço para formatá-las.

Mo, sua premissa está errada.A pergunta não deveria ser 'como faço para formatá-los?'

Sua pergunta deveria ser 'Tenho um código que possui uma grande quantidade de lógica dentro de loops - como posso torná-lo mais legível?'

A resposta a essa pergunta é mover o código para funções individuais e bem nomeadas.Então você não precisa rotular os intervalos.