Profundidad de anidamiento condicional
| Sigla | IF_NEST |
| Aspecto | «Complejidad» |
| Se mide en | método |
| Tipo de valor | máximo (entero, mínimo 0): el nivel más profundo de if del método |
| Dirección | más alto es peor |
| Stau Metro | ConditionalNestingDepth |
En pocas palabras
Dice cuántos if hay, como mucho, uno dentro de otro. Un método sin if vale 0; con un if suelto, 1; con un if
dentro de otro, 2. Las cadenas if … else if … else cuentan como un solo nivel.
Qué mide
Mide hasta qué punto se amontonan las condiciones. Para llegar a la línea más interior de tres if anidados el
lector tiene que tener presentes las tres condiciones a la vez y saber qué pasa cuando cada una falla. Ese patrón,
a veces llamado «código en flecha» por la forma que dibuja la sangría, es una fuente típica de casos olvidados.
Es una versión especializada de la «profundidad de anidamiento de bloques»: ignora los bucles, los
try y las lambdas, y deja ver si la profundidad de un método viene de las condiciones.
Cómo se calcula
Se recorre el método llevando la cuenta de cuántos if rodean al punto actual. Cada if suma 1 al entrar y resta 1
al salir; el valor es el máximo alcanzado. Un if que es directamente la rama else de otro (un else if) no suma,
porque continúa la misma cadena de alternativas.
Solo cuentan las sentencias if. El operador ? :, el switch y los bucles no suman ni cortan la cuenta: un if
dentro de un for que está dentro de otro if está en el nivel 2.
Ejemplo
String describe(int n, boolean verbose) {
if (n < 0) { // nivel 1
return "negativo";
} else if (n == 0) { // else if: sigue en el nivel 1
return "cero";
} else {
if (verbose) { // dentro del else: nivel 2
if (n > 1_000) { // nivel 3
return "muy grande";
}
}
}
return n > 10 ? "grande" : "pequeño"; // el ? : no cuenta
}
El método vale 3. Fíjate en la diferencia entre else if (…) y else { if (…) }: la primera forma continúa la
cadena; la segunda abre un bloque y mete en él un if nuevo, un nivel más abajo. Las dos son equivalentes en
comportamiento, pero no en lectura, y la métrica lo refleja. Uniendo las dos condiciones interiores
(else if (verbose && n > 1_000)) el método bajaría a 1.
Cómo interpretarla
Stau Metro no le asigna umbrales de referencia. Como orientación, las herramientas que vigilan los if anidados
ponen el límite bajo:
- Checkstyle (
NestedIfDepth) admite por defecto unifdentro de otro y avisa a partir del tercero, lo que suele equivaler a un valor de 3 en esta métrica (ver la excepción en «En las herramientas»); - PMD (
AvoidDeeplyNestedIfStmts) avisa cuando el anidamiento deifllega a 3 (problemDepth).
Un valor de 1 o 2 es corriente. A partir de 3 merece la pena preguntarse si las condiciones interiores se pueden
invertir y convertir en retornos anticipados, unir con &&, o sacar a un método con nombre. Un valor alto es más
aceptable en un método corto cuyas condiciones son de verdad dependientes (solo tiene sentido preguntar la segunda si
la primera es cierta) que en uno largo donde se acumulan casos especiales.
Relación con otras métricas
- «Profundidad de anidamiento de bloques» (
NBD): la medida general;IF_NESTnunca es mayor queNBD. Si las dos coinciden, la profundidad del método viene de sus condiciones. - «Profundidad de anidamiento de bucles» (
LOOP_NEST): la misma idea aplicada a los bucles. - «Complejidad cognitiva» (
CogC): castiga cadaifsegún su nivel de anidamiento; unIF_NESTalto suele ir acompañado de unaCogCalta. - «Complejidad ciclomática» (
v(G)): cuenta losifsin mirar su anidamiento. - «Número de sentencias de control» (
CONTROL): cuántosif(y otras sentencias de control) hay, frente a lo profundo que están.
En las herramientas
Stau Metro (ConditionalNestingDepth, a nivel de método). Cuenta solo sentencias if; un if que es
directamente la rama else de otro no suma, pero uno dentro de un bloque else { … } sí. Los if de las lambdas y
de los métodos de clases anónimas o locales declaradas dentro del método cuentan para el método que las contiene,
sumando a la profundidad de los if que las rodean; esos métodos no tienen valor propio. No se calcula para métodos
abstractos; los constructores cuentan como métodos. Un método sin if vale 0.
Checkstyle (NestedIfDepth). Limita el anidamiento de bloques if-else. Cuenta la profundidad desde 0: el if
exterior está en el nivel 0, el que está dentro en el 1. Con el máximo por defecto, 1, avisa a partir del tercer if
anidado. Su profundidad suele ser la de esta métrica menos 1, con una excepción: en su código fuente, un if que es
la única sentencia de un bloque else { … } se trata como un else if y no suma. En el ejemplo de arriba,
Checkstyle no avisaría.
PMD (AvoidDeeplyNestedIfStmts). Avisa del if cuya profundidad llega a problemDepth, 3 por defecto. En su
código fuente, un else if no suma y un if dentro de un bloque else { … } sí, como en Stau Metro.
MetricsReloaded (plugin de IntelliJ). Calcula IF_NEST como la profundidad máxima de anidamiento de las
sentencias if de cada método.
Referencias
- Checkstyle,
NestedIfDepth: https://checkstyle.sourceforge.io/checks/coding/nestedifdepth.html, y su código fuente (NestedIfDepthCheck): https://github.com/checkstyle/checkstyle - PMD, reglas de diseño para Java: https://docs.pmd-code.org/latest/pmd_rules_java_design.html, y su código fuente
(
AvoidDeeplyNestedIfStmtsRule): https://github.com/pmd/pmd - MetricsReloaded: https://github.com/BasLeijdekkers/MetricsReloaded