Profundidad de anidamiento de bloques

Actualizado el 15 de noviembre de 2026

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 try suele 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 if anidados sin nada entre ellos son un if con &&.

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

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 if y el de su else (un else if no es un nivel, pero el cuerpo de ese else if sí lo es, al mismo nivel que el del primer if);
  • el de cada bucle (for, for mejorado, while, do … while);
  • el de un switch, de sentencia o de expresión (el bloque de una regla case -> y un grupo case: escrito entre llaves no añaden nivel);
  • los bloques try, catch y finally, y el de synchronized;
  • 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