Profundidad de anidamiento de bloques
| Sigla | NBD |
| Aspecto | «Complejidad» |
| Se mide en | método |
| Tipo de valor | máximo (entero, mínimo 0): el nivel más profundo que alcanza el método |
| Dirección | más alto es peor |
| Umbrales de referencia | aviso por encima de 3, error por encima de 5 (Stau Metro) |
| Stau Metro | NestingDepth |
En pocas palabras
Dice cuántos bloques hay, como mucho, uno dentro de otro en un método. Un método sin bloques (ni if, ni bucles, ni
try, ni lambdas) vale 0; un if dentro de un for vale 2. No importa cuántos bloques haya, sino hasta dónde baja
el más profundo. Es la «sangría máxima» del método.
Qué mide
Mide la profundidad del código: cuántos contextos tiene que mantener abiertos quien lee la línea más interior. Para entender una sentencia a cuatro niveles hay que recordar las cuatro condiciones, bucles o manejadores que la rodean. Por eso las guías de estilo y los analizadores estáticos suelen limitarlo.
A diferencia de las métricas de recuento, no crece con el tamaño: un método de trescientas líneas planas vale 0 o 1. Eso la hace complementaria de la «complejidad ciclomática», que no distingue entre decisiones en fila y decisiones anidadas.
Cómo se calcula
Se recorre el método y cada vez que se entra en un bloque anidado se suma un nivel; al salir, se resta. El valor es el nivel máximo alcanzado. El cuerpo del propio método es el nivel 0.
Qué cuenta como bloque es lo que cambia de una herramienta a otra. Las opciones habituales son:
- solo los bloques entre llaves (
{ … }), sea cual sea la sentencia que los abre; - solo las sentencias de control (
if, bucles,switch,try), con o sin llaves; - cualquier cuerpo, incluidos los de lambdas y clases anónimas.
Casi todas las herramientas coinciden en una cosa: un else if no es un nivel más, porque se lee como una
alternativa del mismo if y no como algo metido dentro de él.
Ejemplo
void importAll(List<Path> files, Consumer<String> sink) {
for (Path file : files) { // cuerpo del for: nivel 1
try { // bloque try: nivel 2
List<String> lines = Files.readAllLines(file);
if (!lines.isEmpty()) { // cuerpo del if: nivel 3
lines.forEach(line -> sink.accept(line)); // cuerpo de la lambda: nivel 4
}
} catch (IOException e) { // bloque catch: nivel 2
sink.accept("error: " + file);
}
}
}
Con las reglas de Stau Metro (ver «En las herramientas») el método vale 4: la lambda está dentro del if, que
está dentro del try, que está dentro del for. Supera el umbral de aviso de 3. Una herramienta que solo cuente
sentencias de control vería tres niveles (for, try, if) y no avisaría.
La salida más sencilla es extraer el cuerpo del bucle a un método importOne(file, sink): el original queda en 1 y el
nuevo en 3.
Cómo interpretarla
| Valor | Lectura habitual |
|---|---|
| 0-2 | Plano, fácil de seguir |
| 3 | El límite de lo cómodo |
| 4-5 | Difícil: hay que llevar muchas condiciones en la cabeza |
| Más de 5 | Candidato claro a refactorización |
Stau Metro usa aviso por encima de 3 y error por encima de 5. El 3 coincide con el máximo por defecto de la
regla S134 del analizador de Java de SonarQube, que cuenta sentencias de control anidadas (ver «En las
herramientas»: no cuenta exactamente lo mismo). El 5 es una convención de Stau Metro, no un valor publicado.
Qué hacer con un valor alto:
- Retornos anticipados y cláusulas de guarda. Invertir una condición y salir (
if (lista.isEmpty()) return;) saca de un nivel todo lo que viene después. - Extrae métodos. El cuerpo de un bucle o de un
trysuele ser una unidad con nombre propio. - Sustituye bucles anidados por operaciones sobre colecciones cuando aclaren la intención; ten en cuenta que, con las reglas de Stau Metro, el cuerpo de una lambda también es un nivel.
- Une condiciones. Dos
ifanidados sin nada entre ellos son unifcon&&.
Cuándo un valor alto es aceptable. Código que recorre estructuras anidadas por naturaleza (matrices, árboles,
formatos jerárquicos) o un try obligatorio alrededor de un bucle pueden justificar un nivel más. Lo que no es
aceptable es que el nivel crezca por acumulación de casos especiales.
Ojo. Esta métrica es un máximo, no una suma: un método con un único punto profundo y el resto plano vale lo mismo que uno profundo en toda su extensión. Para ver el coste acumulado, mira la «complejidad cognitiva».
Relación con otras métricas
- «Profundidad de anidamiento condicional» (
IF_NEST): el mismo máximo contando solo losif; nunca es mayor que esta. - «Profundidad de anidamiento de bucles» (
LOOP_NEST): el mismo máximo contando solo los bucles; nunca es mayor que esta. - «Complejidad cognitiva» (
CogC): convierte el anidamiento en un coste que se suma en cada estructura; es la forma de ver si la profundidad es puntual o general. - «Complejidad ciclomática» (
v(G)): cuenta decisiones sin mirar si están anidadas.v(G)alta conNBDbaja es lógica en fila; las dos altas, lógica enmarañada. - «Perfil de criterios de calidad (mantenibilidad)» (
QCP_MAINT): suma una profundidad de anidamiento máxima como uno de sus ingredientes, con un recuento propio que no coincide exactamente conNBD.
En las herramientas
Stau Metro (NestingDepth, a nivel de método). Cuenta como un nivel cada uno de estos cuerpos, se escriba o no
entre llaves:
- el de un
ify el de suelse(unelse ifno es un nivel, pero el cuerpo de eseelse ifsí lo es, al mismo nivel que el del primerif); - el de cada bucle (
for,formejorado,while,do … while); - el de un
switch, de sentencia o de expresión (el bloque de una reglacase ->y un grupocase:escrito entre llaves no añaden nivel); - los bloques
try,catchyfinally, y el desynchronized; - el cuerpo de una lambda, aunque sea una sola expresión:
x -> f(x)es un nivel; - una clase anónima o local declarada en el método;
- un bloque suelto
{ … }.
Un método sin ningún cuerpo de esos vale 0. No se calcula para métodos sin cuerpo (abstractos o native). Los
constructores cuentan como métodos. Los métodos de clases anónimas o locales declaradas dentro de un método no tienen
valor propio: sus bloques cuentan en la profundidad del método que las contiene, con un nivel más por la clase (el
cuerpo de esos métodos no añade otro).
SonarQube (analizador de Java, regla S134). Avisa cuando se anidan más de 3 (max, por defecto) sentencias
if, for, while, do, switch (de sentencia o de expresión) y try; un else if no suma nivel, y en el try
solo el bloque principal está anidado, no los catch ni el finally. No cuenta las lambdas, las clases anónimas, los
synchronized ni los bloques sueltos. Por eso, en el mismo método, su profundidad puede ser menor que la de Stau
Metro.
MetricsReloaded (plugin de IntelliJ, también con la sigla NBD). Cuenta los bloques escritos entre llaves,
incluido el cuerpo de los métodos de una clase anónima o local, más la propia clase, y descuenta el cuerpo del método
medido. Un if sin llaves o una lambda de una sola expresión no añaden nivel, y un grupo case: entre llaves o el
bloque de una regla case -> sí.
PMD (regla AvoidDeeplyNestedIfStmts) y Checkstyle (NestedIfDepth, NestedForDepth, NestedTryDepth) no
miden el anidamiento general, sino el de una sola clase de sentencia: ver
«profundidad de anidamiento condicional» y
«de bucles».
Referencias
- SonarSource, analizador de Java, regla
S134(NestedIfStatementsCheck): https://github.com/SonarSource/sonar-java - MetricsReloaded,
NestingDepthCalculator: https://github.com/BasLeijdekkers/MetricsReloaded - Checkstyle,
NestedIfDepth: https://checkstyle.sourceforge.io/checks/coding/nestedifdepth.html;NestedForDepth: https://checkstyle.sourceforge.io/checks/coding/nestedfordepth.html;NestedTryDepth: https://checkstyle.sourceforge.io/checks/coding/nestedtrydepth.html - PMD, reglas de diseño para Java: https://docs.pmd-code.org/latest/pmd_rules_java_design.html