java - para - programacion android pdf 2018
¿Volver de un método con "else" implícito o explícito o con una sola declaración "return"? (14)
Algunas personas consideran las declaraciones de devolución múltiples como un mal estilo de programación. Si bien esto es cierto para los métodos más grandes, no estoy seguro de que sea aceptable para los métodos cortos. Pero hay otra pregunta: ¿debería escribirse explícitamente, si hay una declaración de devolución en la anterior if ?
else implícita:
private String resolveViewName(Viewable viewable) {
if(viewable.isTemplateNameAbsolute())
return viewable.getTemplateName();
return uriInfo.getMatchedResources().get(0).getClass().toString();
}
Explícito else :
private String resolveViewName(Viewable viewable) {
if(viewable.isTemplateNameAbsolute())
return viewable.getTemplateName();
else
return uriInfo.getMatchedResources().get(0).getClass().toString();
}
Técnicamente, aquí no es necesario, pero hace que el sentido sea más obvio.
Y quizás el enfoque más limpio con un solo retorno:
private String resolveViewName(Viewable viewable) {
String templateName;
if(viewable.isTemplateNameAbsolute())
templateName = viewable.getTemplateName();
else
templateName = uriInfo.getMatchedResources().get(0).getClass().toString();
return templateName;
}
¿Cuál preferirías? ¿Otras sugerencias?
Claro, la gente tiene mucho que decir sobre el estilo de programación, pero no se preocupe por algo relativamente trivial para el propósito de su programa.
Personalmente, me gusta ir sin el otro. Si alguien está revisando tu código, hay muchas posibilidades de que no se confunda demasiado sin la otra cosa.
Como pidió otras sugerencias, ¿qué tal
Utilice aserciones o RuntimeExceptions
private String resolveViewName(Viewable viewable) {
if(viewable.isTemplateNameAbsolute())
return viewable.getTemplateName();
else
return uriInfo.getMatchedResources().get(0).getClass().toString();
throw new RuntimeException ( "Unreachable Code" ) ;
}
Utilice la palabra clave final
private String resolveViewName(Viewable viewable) {
final String templateName;
if(viewable.isTemplateNameAbsolute())
templateName = viewable.getTemplateName();
else
templateName = uriInfo.getMatchedResources().get(0).getClass().toString();
return templateName;
}
Depende de la intención. Si la primera devolución es un rescate rápido, entonces me iría sin la else ; Si OTOH es más como un escenario de "retorno, esto o aquello", entonces usaría else . Además, prefiero una declaración de devolución anticipada a una anidada interminable if declaraciones o variables que existen con el único propósito de recordar un valor de devolución. Si su lógica fuera un poco compleja, o incluso tal como es ahora, consideraría poner las dos formas de generar el valor de retorno en funciones dedicadas, y utilizar una if / else para llamar a cualquiera.
El dogma del "punto de salida único" proviene de los días de la Programación Estructurada.
En su día, la programación estructurada era una BUENA COSA, especialmente como una alternativa al código de espagueti cargado con GOTO que prevalecía en los códigos antiguos Fortran y Cobol de los años 60 y 70. Pero con la popularidad de lenguajes como Pascal, C, etc., con su gama más rica de estructuras de control, la Programación estructurada se ha asimilado en la programación general, y ciertos aspectos dogmáticos han caído en desuso. En particular, la mayoría de los desarrolladores están felices de tener múltiples salidas de un bucle o método ... siempre que haga que el código sea más fácil de entender.
Mi opinión personal es que en este caso particular, la simetría de la segunda alternativa hace que sea más fácil de entender, pero la primera alternativa es casi tan legible. La última alternativa me parece innecesariamente verbosa y la menos legible.
Pero @Jon Skeet señaló que hay un problema estilístico mucho más importante con su código; es decir, la ausencia de bloques {} alrededor de las declaraciones ''then'' y ''else''. Para mí, el código debería escribirse así:
private String resolveViewName(Viewable viewable) {
if (viewable.isTemplateNameAbsolute()) {
return viewable.getTemplateName();
} else {
return uriInfo.getMatchedResources().get(0).getClass().toString();
}
}
Esto no es solo una cuestión de código bonito. En realidad hay un punto serio para usar bloques siempre. Considera esto:
String result = "Hello"
if (i < 10)
result = "Goodbye";
if (j > 10)
result = "Hello again";
A primera vista, parece que el resultado será "Hola de nuevo" si i es menor que 10 y j es mayor que 10. De hecho, eso es una mala lectura: hemos sido engañados por una sangría incorrecta. Pero si el código se hubiera escrito con { } ''s alrededor de las partes de ese entonces, sería claro que la sangría estaba mal; p.ej
String result = "Hello"
if (i < 10) {
result = "Goodbye";
}
if (j > 10) {
result = "Hello again";
}
Como ve, el primero se destaca como un pulgar dolorido y nos dice que no confiemos en la sangría como una indicación visual de lo que significa el código.
Es una cuestión de preferencia personal: literalmente, he pasado por las fases de las 4 opciones (incluida la que publicó Jon Skeet). Ninguno de ellos está equivocado, y nunca he experimentado ningún inconveniente como resultado del uso de cualquiera de ellos.
Las cosas sobre una sola declaración de retorno datan de la década de 1970 cuando Dijkstra y Wirth clasificaban la programación estructurada. Lo aplicaron con gran éxito a las estructuras de control, que ahora se han establecido de acuerdo con su prescripción de una entrada y una salida. Fortran solía tener múltiples entradas a una subrutina (o posiblemente una función, lo siento, aproximadamente 35 años desde que escribí alguna), y esta es una característica que nunca me había perdido, de hecho, no creo que la haya usado nunca.
Nunca me he encontrado con esta "regla" aplicada a métodos fuera de la academia, y realmente no puedo ver el punto. Básicamente, tiene que ofuscar su código considerablemente para obedecer la regla, con variables adicionales, etc., y no hay forma de convencerme de que sea una buena idea. Curiosamente, si lo escribes de forma natural según tu primera opción, el compilador generalmente genera el código de acuerdo con la regla de todos modos ... para que puedas argumentar que la regla está siendo obedecida: simplemente no es tuya ;-)
Mantenga la jerga consistente y legible para el programador denominado común más bajo que podría tener que revisar el código en el futuro.
Son solo unas pocas letras adicionales para escribir el otro, y no hace ninguna diferencia en nada más que legibilidad.
Normalmente prefiero la primera opción ya que es la más corta.
Y creo que cualquier programador decente debería darse cuenta de cómo funciona sin tener que escribir el otro usuario o usar una sola declaración al final.
Además, hay casos en los métodos largos en los que podría necesitar hacer algo como
if(!isValid(input)) { return null; }// or 0, or false, or whatever
// a lot of code here working with input
Me parece más claro hacerlo así para este tipo de métodos.
Otra sugerencia obvia: utilizar el operador condicional.
private String resolveViewName(Viewable viewable) {
return viewable.isTemplateNameAbsolute()
? viewable.getTemplateName()
: uriInfo.getMatchedResources().get(0).getClass().toString();
}
Para los casos en que esto no es viable, casi con certeza soy inconsistente. Para ser honesto, no me preocuparía demasiado, no es el tipo de cosas en las que la legibilidad se vea afectada significativamente de cualquier manera, y es poco probable que se introduzcan errores.
(Por otro lado, sugeriría usar llaves para todos los bloques if , incluso los de una sola frase).
Prefiero el enfoque más limpio con retorno único. Para mí, el código es legible, fácil de mantener y no confuso. Mañana, si necesita agregar algunas líneas al bloque If, si no, es fácil.
1.) El código nunca debe ser inteligente.
Prefiero la primera.
O ... puede utilizar if return else return para bifurcaciones igualmente importantes, y if return return para casos especiales.
Cuando tiene aserciones ( if p==null return null ), la primera es la más clara con diferencia. Si tiene opciones igualmente ponderadas ... me parece bien usar el otro explícito.
Prefiero la segunda opción porque para mí es la más rápida de leer.
Evitaría la tercera opción porque no agrega claridad ni eficiencia.
La primera opción también está bien, pero al menos pondría una línea en blanco entre el primer bit (el if y su retorno sangrado) y la segunda declaración de retorno.
Al final, todo se reduce a las preferencias personales (como tantas cosas en el estilo de programación).
Prefiero los rendimientos múltiples en una estructura if-else cuando el tamaño de ambas declaraciones es aproximadamente igual, el código se ve más equilibrado de esa manera. Para expresiones cortas uso el operador ternario. Si el código para una prueba es mucho más corto o es un caso excepcional, podría usar una sola si el resto del código permanece en el cuerpo del método.
Intento evitar modificar las variables tanto como sea posible, porque creo que eso hace que el código sea mucho más difícil de seguir que las múltiples salidas de un método.
Teniendo en cuenta múltiples declaraciones de retorno, el "mal estilo" es una falacia larga y desacreditada. Pueden hacer que el código sea mucho más claro y más fácil de mantener que las variables de valor de retorno explícitas. Especialmente en métodos más grandes.
En su ejemplo, consideraría que la segunda opción es la más limpia porque la estructura simétrica del código refleja su semántica, y es más corta y evita la variable innecesaria.