τTau SolutionsPara empezar

Primeros pasos: las métricas esenciales

Actualizado el 15 de noviembre de 2026

Hay cientos de métricas de código. Para un primer vistazo a un proyecto bastan unas pocas, bien elegidas: una o dos por aspecto, las que mejor responden a la pregunta de ese aspecto y las que más herramientas calculan.

Esta página usa como punto de partida las catorce que el catálogo de Stau Metro marca como esenciales. El plugin las reúne en su perfil «Revisión rápida de salud». La selección es de Stau Metro, no un estándar; otras herramientas eligen otras. Cubre ocho de los nueve aspectos que el plugin mide (la encapsulación no tiene ninguna esencial), y la mayoría son métricas clásicas de la literatura.

Las catorce

Los umbrales son los de referencia de Stau Metro y se superan de forma estricta (ver «cómo leer una métrica»). Cada página explica de dónde sale el suyo.

Métrica Se mide en Pregunta que contesta Umbral de referencia (Stau Metro)
«NCLOC», líneas de código sin comentarios método, clase, interfaz ¿Es demasiado largo? en método: aviso > 30, error > 100
«v(G)», complejidad ciclomática método ¿Cuántos caminos tiene, y cuántos tests pide? aviso > 10, error > 20
«CogC», complejidad cognitiva método ¿Cuánto cuesta seguirlo al leerlo? aviso > 15, error > 25
«NBD», profundidad de anidamiento método ¿Hasta dónde se meten unos bloques dentro de otros? aviso > 3, error > 5
«NP», número de parámetros método ¿Es fácil de llamar bien? aviso > 5, error > 7
«WMC», complejidad ponderada de los métodos clase ¿Cuánta lógica reúne la clase? aviso > 31, error > 47
«CBO», acoplamiento entre objetos clase ¿Con cuántas clases está conectada? aviso > 13, error > 20
«RFC», respuesta para la clase clase ¿Cuánto código puede ponerse en marcha al usarla? aviso > 50, error > 100
«LCOM», falta de cohesión de los métodos clase ¿Es una clase o varias pegadas? aviso > 1
«DIT», profundidad del árbol de herencia clase ¿Cuánto comportamiento heredado hay que conocer? aviso > 5, error > 8
«Cyclic», dependencias cíclicas clase, interfaz, paquete ¿Está metido en un ciclo, y con cuántos más? en paquete: error > 0
«D», distancia a la secuencia principal paquete ¿Van acompasadas su estabilidad y su abstracción? aviso > 0,7
«Jm», cobertura Javadoc de métodos clase, interfaz, paquete, módulo, proyecto ¿Qué parte de los métodos está documentada? ninguno
«TEST_RAT», ratio de test paquete, módulo, proyecto ¿Qué parte del código es de test? ninguno

Jm y TEST_RAT no tienen umbral: más alto es mejor, pero no hay un valor objetivo aceptado de forma general. Se leen por comparación entre módulos y en el tiempo.

En qué orden mirarlas

No hace falta mirarlas todas a la vez. Un orden que funciona es ir de lo pequeño a lo grande, porque los problemas locales son los más baratos de arreglar y los que más se repiten:

  1. Métodos: v(G), CogC, NBD, NCLOC y NP. Ordena los métodos por CogC o por v(G) y lee los diez primeros. Las cinco métricas se solapan, y eso es útil: un método que pasa de varios umbrales a la vez es casi siempre un candidato real; uno que solo pasa de uno merece una lectura antes de tocarlo.
  2. Clases: WMC, CBO, RFC y LCOM. Buscan clases que hacen demasiado. Una clase con WMC alto y LCOM mayor que 1 suele ser varias clases en una; con CBO y RFC altos, una clase que sabe demasiado de las demás.
  3. Paquetes: Cyclic y D. Un ciclo entre paquetes es el único error que el catálogo de Stau Metro marca desde el primer valor distinto de 0: ningún paquete del ciclo se puede entender, probar o extraer sin los demás. D señala los paquetes concretos de los que depende mucho código y los abstractos que casi nadie usa.
  4. Herencia: DIT. Cuando avisa, mira primero si la cadena es tuya o de un framework que extiendes, y si cada nivel añade comportamiento propio o es solo una capa de paso.
  5. Contexto: Jm y TEST_RAT. No señalan un elemento que arreglar, sino zonas: el módulo sin tests, el paquete público sin documentar. Úsalas para decidir dónde no fiarse de un cambio.

Si el proyecto es grande y el tiempo poco, cruza estas métricas con la historia del código: un método complejo que nadie toca desde hace años molesta poco. Los «puntos calientes de cambio» combinan complejidad y frecuencia de cambio para decidir por dónde empezar.

Qué hacer cuando un valor se pasa del umbral

Un aviso es una invitación a leer el código, no una orden de cambiarlo. Antes de decidir:

  1. Lee el elemento. Mira qué hay detrás del número. Un switch plano que traduce veinte códigos vale 21 de v(G) y se lee de un vistazo; una clase de datos con un get y un set por campo da un LCOM alto sin ningún problema de diseño. El apartado «Cómo interpretarla» de cada página dice cuándo un valor «malo» es aceptable.

  2. Mira las métricas vecinas. Casi siempre aclaran de dónde viene el valor y cuál es el remedio:

    Si se pasa… Mira también Porque…
    v(G) CogC, NBD v(G) alta con CogC baja suele ser un switch plano
    CogC o NBD NCLOC un método profundo y corto se arregla con cláusulas de guarda; uno profundo y largo, extrayendo métodos
    WMC «OCavg», «OCmax» separa «muchos métodos sencillos» (dividir la clase) de «uno muy complejo» (dividir el método)
    CBO «Dcy», «Dpt» muchas dependencias y muchos dependientes tienen remedios distintos
    RFC «CSO», CBO separa la clase grande de la que llama a mucho código ajeno
    LCOM WMC una clase compleja y partida en grupos es candidata a dividirse; una de accesores, no
    D «I», «A» la zona en que cae el paquete decide si faltan abstracciones o sobran
  3. Decide una de tres cosas. Corregirlo ahora (si vas a tocar ese código de todos modos), apuntarlo (si es real pero no urgente) o aceptarlo (si el valor tiene una buena razón). Las tres son respuestas válidas; la mala es ignorar el aviso sin mirarlo.

  4. Corrige el diseño, no el número. Extraer un método, dividir una clase o invertir una dependencia son los remedios habituales y cada página los detalla. Partir un método en trozos sin sentido para que cada uno quede por debajo del umbral baja el número y empeora el código: es el error descrito en «convertir la métrica en objetivo».

  5. Mira la tendencia. En un código existente rara vez se arregla todo. Lo útil es que los valores no empeoren: que el código nuevo no añada avisos y que los peores elementos vayan bajando.

Después