Métricas de McCabe

Actualizado el 15 de noviembre de 2026

Las métricas de McCabe miden la lógica de decisión de un método a partir de su grafo de flujo de control: por dónde puede ir la ejecución y cuántos caminos distintos hay que recorrer para probarla. La primera es la complejidad ciclomática v(G). Las otras dos, la complejidad esencial ev(G) y la de diseño iv(G), son reducciones del mismo grafo que contestan preguntas más finas: cuánta de esa lógica rompe la programación estructurada y cuánta decide qué otros métodos se llaman.

Alrededor de ellas hay un grupo de métricas que McCabe no definió como tales y que se construyen sumando, promediando o tomando el máximo de su complejidad por método: por clase, por paquete, por módulo o por proyecto.

Para quien empieza. No hace falta dibujar ningún grafo. La complejidad ciclomática se calcula contando: empieza en 1 y suma 1 por cada if, bucle, case, && o ||. La página de la «complejidad ciclomática» lo explica con un ejemplo.

Quién, cuándo y para qué

Thomas J. McCabe publicó «A Complexity Measure» en 1976, en IEEE Transactions on Software Engineering. El objetivo era práctico: una medida de la complejidad de un módulo que sirviera para limitarla y, sobre todo, para probarlo. El número ciclomático del grafo de control es el tamaño de un conjunto base de caminos, y de ahí sale el método de prueba estructurada (basis path testing): un test por cada camino de ese conjunto. El mismo artículo propuso 10 como límite superior razonable, «aunque no mágico».

La sección VI de ese artículo trata ya de cómo son los grafos de los programas no estructurados, y define con ese fin la complejidad esencial. Era la época del debate sobre el goto, y McCabe buscaba una medida continua de lo estructurado que es un programa en lugar de un «todo o nada».

En 1989, McCabe y Charles W. Butler extendieron la prueba estructurada al diseño en Communications of the ACM: la complejidad de diseño de cada módulo y, a partir de su suma sobre el programa, la complejidad de integración, que da el número de tests de integración independientes.

El informe NIST 500-235 de Watson y McCabe (1996) reúne el conjunto en una metodología, Structured Testing, y describe con detalle las reducciones esencial y de diseño. Mantiene el límite de 10 y admite hasta 15 en equipos con experiencia, diseño formal y un plan de tests completo.

Las tres medidas

Medida Sigla Pregunta que contesta Valores Stau Metro
«Complejidad ciclomática» v(G) ¿cuántos caminos independientes tiene el método? 1 o más la calcula (CyclomaticComplexity)
«Complejidad ciclomática esencial» ev(G) ¿cuánta de su lógica no se deja estructurar? entre 1 y v(G); nunca 2 en la definición de McCabe la calcula (EssentialCyclomaticComplexity)
«Complejidad de diseño» iv(G) ¿cuántas de sus decisiones gobiernan llamadas a otros métodos? entre 1 y v(G) la calcula (DesignComplexity)

Las tres se definen sobre el mismo grafo y las tres son, al final, la complejidad ciclomática de un grafo:

  • v(G) es la del grafo completo, E−N+2PE - N + 2P, que en código estructurado equivale al número de decisiones binarias más 1.
  • ev(G) es la del grafo que queda al eliminar, de dentro afuera, las primitivas de la programación estructurada (secuencia, selección, iteración). Un método estructurado vale 1.
  • iv(G) es la del grafo que queda al aplicar la reducción de diseño: se eliminan las partes que no contienen llamadas a otros módulos. Un método cuyas decisiones son todas locales vale 1.

Aunque las dos reducciones se parezcan, el informe NIST señala que no hay relación matemática entre ev(G) e iv(G): la esencial elimina primitivas haya o no llamadas en ellas, y solo primitivas completas.

Cómo se leen juntas

Las dos reducciones se interpretan respecto a v(G), que es su cota superior:

  • v(G) alta con ev(G) = 1: mucha lógica, pero bien estructurada. Se puede repartir extrayendo métodos sin pelearse con los saltos.
  • ev(G) cerca de v(G): casi toda la lógica depende de salidas anticipadas, break, continue o throw. Ojo: las cláusulas de guarda suben ev(G) y suelen hacer el método más legible; mira la «complejidad cognitiva» antes de «estructurar».
  • iv(G) cerca de v(G): el método es un coordinador; cada camino es un escenario de integración distinto. La proporción iv(G) / v(G) dice qué parte de su complejidad es de diseño.

Para probar, v(G) es el número de tests del conjunto base de caminos del método, e iv(G), el de los caminos que importan al integrarlo con los demás.

Las métricas que la agregan

v(G) se mide por método. Para hablar de una clase o de un paquete hay que agregarla, y la forma de agregar cambia lo que se ve. Las agregadas que tienen página en esta referencia son:

Métrica Sigla Nivel Agregación Familia Recuento en Stau Metro
«Complejidad ciclomática total» v(G)tot paquete, módulo, proyecto suma McCabe el de v(G)
«Complejidad ciclomática promedio» v(G)avg paquete, módulo, proyecto media McCabe el de v(G)
«Complejidad ponderada de los métodos» WMC clase suma «Chidamber y Kemerer» sin &&, || ni catch
«Complejidad promedio de las operaciones» OCavg clase media ninguna sin &&, || ni catch
«Complejidad máxima de las operaciones» OCmax clase máximo ninguna sin &&, || ni catch

WMC merece una nota aparte: es de Chidamber y Kemerer (1994), que dejaron sin definir a propósito la complejidad de cada método. La ponderación ciclomática es la más extendida, pero no la única; con ponderación unitaria, WMC es el número de métodos.

Las tres formas de agregar responden a preguntas distintas:

  • La suma (v(G)tot, WMC) mide el volumen de lógica. Crece con el tamaño, y una clase de cincuenta métodos de complejidad 1 vale lo mismo que una de cinco métodos de complejidad 10.
  • La media (v(G)avg, OCavg) describe el estilo del código y permite comparar partes de tamaño muy distinto. Los accesores y los constructores triviales valen 1 y la bajan.
  • El máximo (OCmax) saca a la luz el método que concentra la complejidad. La distribución de v(G) es muy asimétrica: unos pocos métodos acumulan casi todas las decisiones, y la media los diluye.

Lee siempre el máximo junto a la media. Una clase con diez métodos triviales y uno de complejidad 25 tiene una media por debajo de 4.

Ojo. En Stau Metro, v(G)tot y v(G)avg usan exactamente el recuento de v(G), pero WMC, OCavg y OCmax usan otro, que no incluye &&, || ni catch. El WMC de una clase puede ser menor que la suma de la v(G) de sus métodos.

Validación y críticas

v(G) es la métrica de McCabe más estudiada y la más criticada. Las críticas principales, desarrolladas en su página, son:

  • Se correlaciona mucho con el tamaño. Shepperd (1988) revisó la evidencia y concluyó que, en muchos conjuntos de datos, aporta poco más que las líneas de código.
  • No cumple varias propiedades de Weyuker (1988) para una medida de complejidad; por ejemplo, no cambia al reordenar las sentencias.
  • Ignora el anidamiento. Tres if seguidos y tres anidados valen lo mismo. Es la motivación directa de la complejidad cognitiva de Campbell.
  • Ignora los datos. No ve la complejidad de las expresiones ni de las estructuras de datos, que es justo lo que miran las «medidas de Halstead».
  • Castiga construcciones inofensivas. Un switch plano de veinte casos vale 21 y se lee de un vistazo.

Las dos reducciones tienen críticas propias. ev(G) es hija del problema del goto; en Java lo que la sube son salidas anticipadas y excepciones, y no hay acuerdo en que sean un defecto. iv(G) depende de qué se considere una llamada en un lenguaje orientado a objetos (un new, una referencia a método, una llamada a la propia clase), y cada herramienta lo decide a su manera.

Además, las herramientas para Java no construyen el grafo: aproximan las reducciones sobre el árbol sintáctico. En la aproximación de Stau Metro, una sola cláusula de guarda da ev(G) = 2, un valor que la definición de McCabe no puede producir; el informe NIST propone precisamente esa propiedad para evaluar herramientas.

Variantes y sucesoras. Myers (1977) propuso contar las condiciones compuestas de forma explícita, y de ahí sale la variante «extendida» que suma cada && y ||, la más usada hoy. La «complejidad NPath» de Nejmeh (1988) cuenta caminos completos en lugar de independientes. La «complejidad cognitiva» de Campbell (2018) cuenta casi las mismas construcciones, pero penaliza el anidamiento. La «profundidad de anidamiento» mide la dimensión que v(G) no ve.

Dónde reaparece. El «índice de mantenibilidad» usa v(G) como uno de sus tres ingredientes, junto al volumen de Halstead y las líneas de código.

En las herramientas

Qué calcula cada herramienta, según su documentación o su código fuente (ver «Referencias»):

Herramienta v(G) ev(G) iv(G) Agregadas
Stau Metro sí sí (aproximación sintáctica) sí (aproximación sintáctica) WMC, OCavg, OCmax, v(G)tot, v(G)avg
Checkstyle sí no figura no figura no figura
PMD sí (CYCLO) no figura no figura WMC (suma de CYCLO); la regla CyclomaticComplexity avisa también de las clases cuya suma llega a 80
SonarQube (Java) sí no figura no figura la del conjunto del código es «básicamente la suma» de las funciones
JaCoCo sí, sobre el bytecode no figura no figura la resume por clase, paquete y grupo
MetricsReloaded sí sí (aproximación sintáctica) sí (aproximación sintáctica) WMC, OCavg, OCmax, v(G)tot, v(G)avg

«No figura» quiere decir que no se ha encontrado en la documentación consultada, no que se haya comprobado que no existe.

Ni siquiera v(G) da el mismo número en todas: unas cuentan catch y otras no, unas cuentan cada case y otras cada grupo de etiquetas, y JaCoCo cuenta las ramas que genera el compilador. Las tablas de detalle están en la página de la «complejidad ciclomática»; las diferencias de ev(G) e iv(G) entre Stau Metro y MetricsReloaded, en las páginas de cada una.

Stau Metro calcula las tres medidas por método y las cinco agregadas, sobre código Java. Solo v(G) tiene umbral de referencia por método: aviso por encima de 10 y error por encima de 20. Las agregadas de clase WMC (31 y 47) y OCavg (3,1 y 4,7) tienen los suyos, que Stau Metro presenta como los valores «alto» y «muy alto» de Lanza y Marinescu (2006) para Java.

Referencias