Complejidad ciclomática esencial
| 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.
De la definición salen tres propiedades:
- ;
- un método escrito solo con construcciones estructuradas vale exactamente 1;
- 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
- «Complejidad ciclomática» (
v(G)): la cota superior de esta métrica.ev(G)es la parte dev(G)que no se deja estructurar. - «Complejidad de diseño» (
iv(G)): la otra reducción de McCabe; se parece en el cálculo, pero mide otra cosa (las decisiones que gobiernan llamadas). - «Número de puntos de retorno» (
RETURN) y «número de sentencias de ramificación» (BRANCH): cuentan directamente los saltos que, dentro de una decisión, hacen subirev(G). - «Complejidad cognitiva» (
CogC): mide lo difícil que es leer el método; se lee junto a esta para decidir si estructurar un método mejora o empeora su lectura. - «Profundidad de anidamiento» (
NBD): suele subir cuando se eliminan salidas anticipadas para bajarev(G).
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, unthrowo uncontinue; - un
breakcon etiqueta, o unbreaksin etiqueta que salga de algo que no sea unswitch(un bucle).
Un break que solo cierra un case no cuenta. Las reglas concretas:
- un
ifsuma si su ramatheno su ramaelseno son reducibles; un bucle, si su cuerpo no lo es; - un
catchsuma si su bloque no es reducible; - en un
switchcon 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 reglacase 1 -> throw …suma). El grupo o la regladefaultno suman nunca; - un salto dentro de un
try, unsynchronized, una sentencia etiquetada o un bloque anidado se ve desde fuera: hace no reducibles todas las decisiones que lo contienen. Unifcuya rama contiene unwhilecon unreturnsuma 1, y elwhile, 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
returnde una lambda, de un método de una clase anónima o elthrowde una regla de una expresiónswitchno hacen no reducible elifque 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
- McCabe, T. J. (1976). «A Complexity Measure». IEEE Transactions on Software Engineering, SE-2(4), 308-320. https://ieeexplore.ieee.org/document/1702388
- Watson, A. H. y McCabe, T. J. (1996). Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric. NIST Special Publication 500-235, sección 10. https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication500-235.pdf
- MetricsReloaded, código fuente: https://github.com/BasLeijdekkers/MetricsReloaded