Complejidad ciclomática esencial

Actualizado el 15 de noviembre de 2026

Sigla ev(G)
Aspecto «Complejidad»
Se mide en método
Tipo de valor recuento (entero, mínimo 1)
Dirección más alto es peor
Origen Thomas J. McCabe, 1976
Familia «Métricas de McCabe»
Stau Metro EssentialCyclomaticComplexity

En pocas palabras

Dice cuánta de la lógica de un método está escrita «fuera de las reglas» de la programación estructurada: con salidas anticipadas, saltos fuera de un bucle o continue. Un método en el que cada bloque se recorre de arriba abajo y sale por su final vale 1. Cada decisión que esconde un salto de ese tipo suma.

Qué mide

La «complejidad ciclomática» cuenta cuánta lógica de decisión tiene un método. La esencial mide su calidad estructural: qué parte de esa lógica no se puede descomponer en piezas con una sola entrada y una sola salida.

La programación estructurada construye todo con tres primitivas: secuencia, selección (if, switch) e iteración (bucles). Cada una tiene una entrada y una salida, así que un método escrito solo con ellas se puede entender por partes: cada bloque es una caja que se lee sin mirar el resto. Un return en mitad de un bucle, un break que sale de dos niveles o un continue rompen esa propiedad: el bloque tiene una segunda salida, y para entenderlo hay que seguirle la pista hasta donde salta.

Le importa a quien mantiene el código, porque el código poco estructurado hay que entenderlo de una vez, entero, y a quien lo prueba, porque las conexiones entre los datos de entrada y los caminos se vuelven menos evidentes.

Cómo se calcula

McCabe la definió en el mismo artículo de 1976 que la complejidad ciclomática, sobre el grafo de flujo de control. El informe NIST 500-235 (Watson y McCabe, 1996) la describe así: se eliminan del grafo las primitivas de la programación estructurada, empezando por las más anidadas y hacia fuera, hasta que no se puede reducir más; la complejidad esencial es la complejidad ciclomática del grafo que queda.

ev(G)=v(Greducido)ev(G) = v(G_{\text{reducido}})

De la definición salen tres propiedades:

  • 1≤ev(G)≤v(G)1 \le ev(G) \le v(G);
  • un método escrito solo con construcciones estructuradas vale exactamente 1;
  • ev(G)ev(G) nunca vale 2: un grafo con complejidad 2 que ya no tiene nodos en secuencia es una primitiva estructurada, y se elimina.

La reducción se hace sobre el grafo, no sobre el texto: un goto solo aumenta la complejidad esencial si de verdad crea una estructura que no es primitiva. En Java no hay goto, pero sí sus parientes: return anticipado, break y continue (con o sin etiqueta) y throw.

Las herramientas para Java no suelen construir el grafo; aproximan la reducción sobre el árbol sintáctico. Las reglas de Stau Metro están en «En las herramientas».

Ejemplo

Con las reglas de Stau Metro, una decisión suma si alguna de sus ramas contiene un salto que la abandona:

static int indexOfFirstNegative(int[] values) {     // 1
    for (int i = 0; i < values.length; i++) {        // +1: su cuerpo contiene un return
        if (values[i] < 0) {                         // +1: su rama hace return
            return i;
        }
    }
    return -1;
}

Total: 1 + 1 + 1 = 3, igual que su v(G). Toda la lógica es «esencial». La misma búsqueda, sin salidas anticipadas:

static int indexOfFirstNegative(int[] values) {     // 1
    int found = -1;
    for (int i = 0; i < values.length && found < 0; i++) {   // no suma: el cuerpo no salta
        if (values[i] < 0) {                         // no suma: la rama solo asigna
            found = i;
        }
    }
    return found;
}

Total: 1. Su v(G), en cambio, ha subido a 4 (el for, el && y el if). Las dos versiones muestran lo que la métrica premia y lo que cuesta: menos saltos a cambio de una variable de control más.

Cómo interpretarla

  • 1: el método es estructurado. No hay nada que mirar en esta métrica, aunque su v(G) sea alta.
  • Cerca de v(G): casi toda la lógica del método depende de saltos. Es el perfil del código «espagueti» que la métrica quiere señalar.
  • La diferencia v(G) - ev(G) es la complejidad que se puede repartir extrayendo métodos sin pelearse con los saltos.

Stau Metro no le da umbral de referencia, y no hay un umbral publicado comparable con su variante (ver «En las herramientas»).

Cuándo un valor alto es aceptable. Muchas guías de estilo actuales recomiendan las cláusulas de guarda: un if (x == null) return; al principio del método, que evita anidar el resto. Esas guardas suben ev(G) y, sin embargo, suelen hacer el método más fácil de leer. Lo mismo pasa con un bucle de búsqueda que sale con return en cuanto encuentra lo que busca. Antes de «estructurar» un método para bajar esta métrica, compara el resultado con la «complejidad cognitiva» y con la «profundidad de anidamiento»: si suben, el cambio ha empeorado la lectura.

Qué hacer con un valor alto cuando de verdad molesta: extrae el cuerpo de un bucle con salidas múltiples a un método propio que devuelva el resultado; sustituye los break y continue con etiqueta, que saltan varios niveles, por métodos o por condiciones explícitas.

Para profundizar

De dónde viene. La métrica nace del debate sobre la programación estructurada de los años setenta. McCabe quería una medida continua de lo estructurado que es un programa, en lugar del «todo o nada» de usar o no goto. El informe NIST 500-235 la presenta así, y subraya que la reducción se hace sobre el grafo para que la medida no dependa de la sintaxis de cada lenguaje.

Por qué nunca vale 2. Si después de eliminar los nodos en secuencia queda un grafo con complejidad 2, ese grafo tiene una sola decisión, y una sola decisión es siempre un if o un bucle: una primitiva, que se elimina. El informe sugiere usar esta propiedad para evaluar herramientas: una que da 2 no reduce el grafo como McCabe.

Relación con la complejidad de diseño. El cálculo se parece al de la «complejidad de diseño» iv(G), que de hecho se desarrolló después, pero el informe NIST señala dos diferencias: la esencial elimina primitivas haya o no llamadas en ellas, y solo elimina primitivas completas. Por eso, según el mismo informe, no hay relación matemática entre las dos.

Críticas. La métrica es hija de una época en que el problema era el goto. En Java, donde el flujo ya está limitado por el lenguaje, lo que sube ev(G) son sobre todo salidas anticipadas y excepciones, y no hay acuerdo en que sean un defecto: sustituir condicionales anidados por cláusulas de guarda es una refactorización muy difundida. Leída sin contexto, la métrica puede empujar a escribir código más anidado.

Relación con otras métricas

En las herramientas

Stau Metro (EssentialCyclomaticComplexity, a nivel de método). Aproxima la reducción de McCabe sobre el árbol sintáctico. Empieza en 1 y recorre las mismas decisiones que su v(G) (if, bucles, case, guardas when, catch), pero solo suma una decisión si alguna de sus ramas no es reducible. Una rama no es reducible si contiene, a cualquier profundidad dentro de sus sentencias:

  • un return, un throw o un continue;
  • un break con etiqueta, o un break sin etiqueta que salga de algo que no sea un switch (un bucle).

Un break que solo cierra un case no cuenta. Las reglas concretas:

  • un if suma si su rama then o su rama else no son reducibles; un bucle, si su cuerpo no lo es;
  • un catch suma si su bloque no es reducible;
  • en un switch con dos puntos, un grupo de etiquetas suma si alguna de sus sentencias no es reducible; en uno con flechas, una regla suma si su cuerpo no lo es (una regla case 1 -> throw … suma). El grupo o la regla default no suman nunca;
  • un salto dentro de un try, un synchronized, una sentencia etiquetada o un bloque anidado se ve desde fuera: hace no reducibles todas las decisiones que lo contienen. Un if cuya rama contiene un while con un return suma 1, y el while, otro;
  • los operadores && y || y el operador ? : no suman nunca, porque no contienen sentencias;
  • un salto que está dentro de una expresión no se ve desde fuera: el return de una lambda, de un método de una clase anónima o el throw de una regla de una expresión switch no hacen no reducible el if que los rodea.

Las decisiones de las lambdas y de las clases anónimas o locales declaradas dentro del método se suman al método, con las mismas reglas aplicadas a sus propias ramas. No se calcula para métodos abstractos; un método native vale 1. Los métodos de las clases anónimas de un inicializador de campo y de los cuerpos de las constantes de un enumerado tienen valor propio.

Como consecuencia de la aproximación, una sola cláusula de guarda da ev(G) = 2, un valor que la definición de McCabe no puede producir. Los valores de Stau Metro no son comparables con los de una herramienta que reduzca el grafo.

MetricsReloaded (complemento para IntelliJ IDEA). Su código fuente aproxima ev(G) sobre el árbol sintáctico con los mismos saltos no reducibles (return, throw, continue y break con etiqueta o que no sale de un switch), pero con otras reglas de detalle: un catch no suma nunca, no mira dentro de las sentencias etiquetadas ni de las reglas con flecha de un switch anidado, y en un switch con dos puntos un grupo solo suma si todas sus sentencias son no reducibles (case 1: log(); return 1; no suma). Sus valores pueden ser más bajos que los de Stau Metro.

Referencias