Java Coding standard/mejores prácticas: convención de nomenclatura para etiquetas break/continue

Question

A veces, un break etiquetado o continue 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

Si tiene que usar mayúsculas y minúsculas, esto llama la atención sobre ellos y los diferencia 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 2

La convención es evitar etiquetas por completo.

Existen 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 ha proporcionado, 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: haber visto el código real de que se trate (over here), creo que el uso de etiquetas es probablemente la mejor manera de hacer que el código legible. En la mayoría de los casos el uso de etiquetas es el enfoque equivocado, en este caso, creo que está bien.

Answer 3

La convención/mejores prácticas seguiría siendo no utilizarlas en absoluto y refactorizar el código para que sea más legible utilizando el método de extracción.

Answer 4

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 tiene 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 5

Lo sé, no debería usar etiquetas.

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

Mo, su premisa es incorrecta. La pregunta no debería ser '¿cómo puedo formatearlas?'

Tu pregunta debería ser 'Tengo un código que tiene una gran cantidad de bucles dentro de la lógica, ¿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 6

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

myLabel: 

pero también he visto etiquetas prefijadas con un guión

_myLabel: 

o con laboratorio...

labSomething: 

Es probable que pueda sentir, aunque de las otras respuestas que va a ser difícil empujado a encontrar un estándar de codificación que dice que no sea 'No utilice etiquetas' nada. La respuesta entonces es que debes usar cualquier estilo que tenga sentido para ti, siempre y cuando sea consistente.

Answer 7

No entiendo de dónde viene esta regla "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 suceden 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! Refactorizando como un método no alivia que:

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 sigue pasando alrededor de un valor lógico superfluo. Y si el bucle interno modificó las variables locales, la refactorización en un método no siempre es la solución correcta.

¿Por qué todos ustedes están contra las etiquetas? Dame algunas razones sólidas y alternativas prácticas para el caso anterior.

Answer 8

WRT sadie's code example:

Se dio

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

A modo de 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 no sería ejemplos en los que ese tipo de refactorización no sentarse correctamente con lo que la lógica que está haciendo.

Answer 9

Como las etiquetas rara vez son útiles, parece que no existe 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 10

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