Qué es mejor ? Múltiples declaraciones if, o una si con múltiples condiciones

Para mi trabajo, tengo que desarrollar una pequeña aplicación Java que analiza archivos XML muy grandes (~ 300k líneas) para seleccionar datos muy específicos (usando Pattern ), así que estoy tratando de optimizarlo un poco. Me preguntaba qué era mejor entre estos 2 fragmentos:

 if(boolean_condition && matcher.find(string)) { ... } 

O

 if(boolean_condition) { if(matcher.find(string)) { ... } } 

Más precisiones:

  • Estas sentencias if se ejecutan en cada iteración dentro de un bucle (~ 20k iteraciones)
  • boolean_condition es un boolean calculado en cada iteración usando una función externa
  • Si el valor boolean se establece en false , no es necesario que pruebe la expresión regular para las coincidencias

Gracias por tu ayuda

Una regla de oro que sigo es Evitar anidar todo lo que pueda. Pero si es a costa de hacer que mi única condición sea demasiado compleja, no me importa anidarla.

Además estás usando el operador de cortocircuito && . Entonces, si boolean es falso, ¡ni siquiera intentará hacer coincidir!

Asi que,

 if(boolean_condition && matcher.find(string)) { ... } 

es el camino a seguir!

Los siguientes dos métodos:

 public void oneIf(boolean a, boolean b) { if (a && b) { } } public void twoIfs(boolean a, boolean b) { if (a) { if (b) { } } } 

produce exactamente el mismo código de bytes para el cuerpo del método, por lo que no habrá ninguna diferencia de rendimiento, lo que significa que es puramente una cuestión de estilo que utiliza (personalmente prefiero el primer estilo).

Ambas formas son correctas, y la segunda condición no se probará si la primera es falsa.

Use el que hace que el código sea más legible y comprensible. Solo por dos condiciones, la primera es más lógica y legible. Puede que ya no sea el caso con 5 o 6 condiciones vinculadas con && , || y ! .

Java usa un cortocircuito para esos operadores booleanos, por lo que ambas variaciones son funcionalmente idénticas. Por lo tanto, si boolean_condition es falso, no continuará en la coincidencia

En definitiva, es más fácil de leer y depurar, pero la anidación profunda puede ser difícil de manejar si terminas con una enorme cantidad de llaves al final

Una forma en que puede mejorar la legibilidad, si la condición se vuelve más larga es simplemente dividirla en múltiples líneas:

 if(boolean_condition && matcher.find(string)) { ... } 

La única opción en ese punto es si colocar el && y || al final de la línea anterior o al comienzo de la stream.

El primero. Intento evitar el anidamiento así, creo que es un código pobre / feo y el && se cortocircuitará y solo se probará con matcher.find () si el booleano es verdadero.

En términos de rendimiento, son lo mismo.

  • Pero incluso si no fueran

lo que es casi seguro que dominará el tiempo en este código es matcher.find(string) porque es una llamada a función.

Si le gusta cumplir con la regla de Sonar: 1. S1066 , debe colapsar las instrucciones para evitar advertencias, ya que dice:

Las declaraciones “si” colapsibles deben fusionarse

Tiendo a ver demasiados && y || encadenados en una sopa lógica y son a menudo la fuente de errores sutiles.

Es muy fácil agregar otro && o || a lo que crees que es el lugar correcto y romper la lógica existente.

Debido a esto, como regla general, trato de no utilizar ninguno de ellos para evitar la tentación de agregar más a medida que cambian los requisitos.