usar - Estándar/mejores prácticas de Java Coding: convención de nomenclatura para las etiquetas break/continue

while break java

Question

A veces, un corte etiquetado o continuar puede hacer que el código sea mucho más legible.

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

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

Me preguntaba cuál era la convención común para las etiquetas. Todas las tapas? primer cap?

Answer 1

Lo sé, no debería usar etiquetas.

Pero asuma que tengo algún código que podría ganar mucho en legibilidad a partir de los descansos etiquetados, cómo los formateo.

Mo, tu premisa es incorrecta. La pregunta no debería ser ''¿cómo los formateo?''

Su pregunta debería ser ''Tengo un código que tiene una gran cantidad de lógica dentro de los bucles, ¿cómo puedo hacerlo más legible?''

La respuesta a esa pregunta es mover el código a funciones individuales y bien nombradas. Entonces no necesita etiquetar los descansos en absoluto.

Answer 2

La convección / mejor práctica seguiría siendo no usarlas en absoluto y refactorizar el código para que sea más legible usando extraer como método.

Answer 3

La convención que más he visto es simplemente camel case, como un nombre de método ...

myLabel:

pero también he visto etiquetas con un guion bajo

_myLabel:

o con laboratorio ...

labSomething:

Sin embargo, probablemente pueda sentir, a partir de las otras respuestas, que será difícil encontrar un estándar de codificación que diga algo diferente a "No usar etiquetas". La respuesta entonces es que debes usar cualquier estilo que tenga sentido para ti, siempre y cuando sea consistente.

Answer 4

No entiendo de dónde viene esta regla de "no usar etiquetas". Al realizar una lógica de bucle no trivial, la prueba para interrumpir o continuar no siempre es clara al final del bloque circundante.

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

Sí, casos como este ocurren todo el tiempo. ¿Qué es lo que la gente sugiere que use en su lugar? Una condición booleana como esta?

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

¡Yuck! Refaccionarlo como un método tampoco alivia eso:

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

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

Claro que es un poco más bonito, pero todavía está pasando por un booleano superfluo. Y si el bucle interno modificó las variables locales, la refactorización en un método no siempre es la solución correcta.

Entonces, ¿por qué están todos en contra de las etiquetas? Dame algunas razones sólidas y alternativas prácticas para el caso anterior.

Answer 5

Si tiene que usarlos, use mayúsculas, esto llama la atención sobre ellos y los separa de ser interpretados erróneamente como nombres de "Clase". Llamar la atención sobre ellos tiene el beneficio adicional de captar la atención de alguien que vendrá y refactorizar su código y eliminarlos. ;)

Answer 6

Son una especie de goto de Java, no estoy seguro si C # los tiene. Nunca los he usado en la práctica, no puedo pensar en un caso donde evitarlos no resultaría en un código mucho más legible.

Pero si tienes que hacerlo, creo que todas las tapas están bien. La mayoría de las personas no usarán roturas marcadas, por lo tanto, cuando vean el código, las mayúsculas se saltarán y les obligará a darse cuenta de lo que está sucediendo.

Answer 7

Como las etiquetas rara vez son útiles, parece que no hay una convención clara. La especificación del lenguaje Java tiene un ejemplo con etiquetas y están en non_cap.

Pero como son tan raros, en mi opinión lo mejor es pensar dos veces si realmente son la herramienta adecuada.

Y si son la herramienta adecuada, conviértelos en mayúsculas para que otros desarrolladores (o usted mismo más adelante) los reconozcan como algo inusual de inmediato. (como Craig ya señaló)

Answer 8

El estilo de código Java de Sun parece preferir etiquetas de nombres de la misma manera que las variables, es decir, caso de camello con la primera letra en minúscula.

Answer 9

La convención es evitar las etiquetas por completo.

Hay muy, muy pocos motivos válidos para usar una etiqueta para salir de un bucle. El estallido está bien, pero puede eliminar la necesidad de romperlo modificando un poco su diseño. En el ejemplo que proporcionó, extraería las secciones de "Lotes de código" y las colocaría en métodos individuales con nombres significativos.

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

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

Editar: habiendo visto el código real en cuestión ( aquí ), creo que el uso de etiquetas es probablemente la mejor manera de hacer que el código sea legible. En la mayoría de los casos el uso de etiquetas es el enfoque equivocado, en este caso, creo que está bien.

Answer 10

ejemplo del código de wrt sadie :

Diste

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

Como ejemplo. Haces un buen punto. Mi mejor conjetura sería:

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

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

Pero habría ejemplos en los que ese tipo de refactorización no se sienta correctamente con la lógica que estés haciendo.