τTau SolutionsPara empezar

Qué son las métricas de código

Actualizado el 15 de noviembre de 2026

Una métrica de código es un número que se obtiene del código fuente aplicando una regla fija. «Número de parámetros del método» es una métrica: la regla dice qué se cuenta, y cualquiera que la aplique al mismo método obtiene el mismo valor. Esa es su ventaja frente a una opinión («este método es demasiado largo»): se puede repetir, comparar entre dos versiones del código y calcular sobre miles de ficheros sin leerlos.

La regla es también su límite. Una métrica mide exactamente lo que dice su regla y nada más. «Líneas de código» no mide lo difícil que es un método, solo cuántas líneas ocupa. Cuando se olvida eso, el número empieza a decir cosas que no dice.

Para qué sirven

  • Encontrar dónde mirar. En un proyecto de cientos de clases nadie lo lee todo. Las métricas señalan los métodos más enrevesados, las clases que dependen de medio sistema o los paquetes metidos en un ciclo, para que la lectura empiece por ahí.
  • Seguir una tendencia. Un valor aislado dice poco; el mismo valor medido versión tras versión dice si el código mejora o se degrada, y dónde.
  • Hablar con datos. «Este método tiene una complejidad ciclomática de 34» es un punto de partida más concreto para una revisión que «este método es complicado».
  • Ponerse de acuerdo en un límite. Un equipo puede pactar que los métodos nuevos no pasen de cierto tamaño o complejidad, y comprobarlo de forma automática en cada cambio.

Para qué no sirven

  • Para dar una nota única de calidad. Cada métrica mira un aspecto. Un código puede tener métodos cortos y sencillos y, a la vez, un acoplamiento entre clases que impide cambiar nada sin romper otra cosa.
  • Para medir a las personas. Las líneas escritas o los métodos creados por alguien no dicen cuánto aporta. Y en cuanto una métrica se usa para juzgar a quien escribe el código, deja de medir el código: ver «convertir la métrica en objetivo».
  • Para sustituir la lectura. Un valor alto es una pregunta («¿por qué este método tiene 9 niveles de anidamiento?»), no una respuesta. A veces la respuesta es que está bien así.
  • Para predecir defectos por sí solas. Se ha encontrado relación entre algunas métricas y los defectos, pero en varios estudios buena parte de ella se explicaba por el tamaño: ver «olvidar el tamaño» y «qué dice la evidencia empírica».

Métricas de producto y métricas de proceso

Fenton y Bieman clasifican lo que se mide en el software en tres clases de entidades: los procesos (las actividades de desarrollo), los productos (lo que esas actividades producen, código incluido) y los recursos (lo que se necesita para llevarlas a cabo, como las personas o las herramientas). Distinguen además los atributos internos, que se miden mirando solo la entidad, de los externos, que dependen de cómo se comporta en su entorno.

Las métricas de código son, casi todas, métricas de producto que miden atributos internos: se calculan leyendo el código, sin ejecutarlo y sin mirar su historia. La mantenibilidad o la fiabilidad, en cambio, son atributos externos: no se leen en el código, se observan al mantenerlo o al usarlo. Las métricas de código interesan precisamente porque se espera que los atributos internos (tamaño, complejidad, acoplamiento) digan algo de los externos. Esa relación hay que demostrarla, no darla por hecha.

Esta referencia trata sobre todo métricas de producto. Incluye también algunas que salen del historial del código, porque se leen junto a ellas: la «rotación del código», el «acoplamiento de cambio», los «puntos calientes de cambio», la «propiedad del código» y la «densidad de defectos». No trata las métricas de proceso de un equipo (frecuencia de despliegue, velocidad, tiempo de entrega).

Los aspectos de calidad

Las métricas se agrupan por el aspecto del código que miran. Cada aspecto tiene una guía con sus métricas y por dónde empezar.

Aspecto Pregunta que contesta
«Tamaño» ¿Cuánto código hay y cómo se reparte?
«Complejidad» ¿Cuánta lógica de decisión hay que seguir para entender un método o una clase?
«Acoplamiento» ¿De cuántas otras piezas depende un elemento, y cuántas dependen de él?
«Cohesión» ¿Las partes de una clase trabajan juntas o son trozos sin relación?
«Herencia y polimorfismo» ¿Cómo de profundas y anchas son las jerarquías, y cuánto se hereda o sobrescribe?
«Encapsulación» ¿Cuánto de cada clase queda oculto al resto?
«Documentación» ¿Cuánto del código está comentado o documentado con Javadoc?
«Tests» ¿Cuánto código de test hay y qué comprueba?
«Diseño de paquetes» ¿Están equilibradas la estabilidad y la abstracción de los paquetes?
«Mantenibilidad» ¿Se puede resumir en un número lo fácil que es mantener el código?
«Duplicación» ¿Qué parte del código está repetida?
«Evolución del código» ¿Qué partes cambian más, juntas o en manos de quién?

Stau Metro organiza sus métricas en los nueve primeros aspectos; los tres últimos los cubren otras herramientas.

Los aspectos no son una clasificación oficial: agrupan atributos internos del código. Las normas describen la calidad desde fuera. La ISO/IEC 25010, por ejemplo, descompone la mantenibilidad en cinco subcaracterísticas: modularidad, reusabilidad, analizabilidad, capacidad de ser modificado y capacidad de ser probado. Ninguna métrica mide directamente una de ellas: varias métricas internas dan indicios de cada una.

Un método medido a mano

Order e Item son clases cualesquiera: total() devuelve un número, items() una lista de Item y onSale() un boolean.

/** Devuelve el descuento, en porcentaje, que corresponde a un pedido. */
static int discount(Order order, boolean member) {
    // los pedidos pequeños no tienen descuento
    if (order.total() < 50) {
        return 0;
    }

    int percent = member ? 10 : 0;
    for (Item item : order.items()) {
        if (item.onSale() && percent < 30) {
            percent += 5;
        }
    }
    return percent;
}

Se miden cinco métricas con las reglas de sus páginas:

Métrica Qué se cuenta Valor Umbral de aviso (Stau Metro)
«NCLOC» Las líneas con código, de la firma a la llave de cierre. No cuentan el Javadoc, la línea de comentario ni la línea en blanco 12 por encima de 30
«NP» Los parámetros de la firma: order y member 2 por encima de 5
«v(G)» 1 por el método, más 1 por cada decisión: primer if, ? :, for, segundo if y && 1 + 5 = 6 por encima de 10
«CogC» Primer if (nivel 0): 1; ? : (nivel 0): 1; for (nivel 0): 1; segundo if, dentro del for (nivel 1): 2; la secuencia &&: 1 6 por encima de 15
«NBD» El cuerpo más profundo: el del segundo if, dentro del cuerpo del for 2 por encima de 3

Ningún valor llega al umbral de aviso. Que v(G) y CogC coincidan aquí es casualidad: la ciclomática parte de 1 y la cognitiva de 0, y el punto que la cognitiva suma por el if anidado compensa la diferencia.

Ahora el mismo comportamiento escrito sin la cláusula de guarda:

static int discount(Order order, boolean member) {
    int percent = 0;
    if (order.total() >= 50) {
        percent = member ? 10 : 0;
        for (Item item : order.items()) {
            if (item.onSale() && percent < 30) {
                percent += 5;
            }
        }
    }
    return percent;
}
  • NCLOC sigue en 12 y NP en 2.
  • v(G) sigue en 6: las decisiones son las mismas.
  • CogC sube a 9: if exterior (nivel 0) 1, ? : (nivel 1) 2, for (nivel 1) 2, if interior (nivel 2) 3, secuencia && 1.
  • NBD sube a 3: cuerpo del if, del for y del if interior. No supera el umbral de aviso, porque los umbrales se superan de forma estricta: 3 no es mayor que 3.

Las dos versiones hacen lo mismo y tienen el mismo tamaño y los mismos caminos. Lo que cambia es cuánto hay que retener en la cabeza para seguirlas, y eso solo lo ven las métricas que miran el anidamiento. Es la razón por la que conviene leer varias métricas juntas: cada una ve una cosa.

Siguiente paso

«Cómo leer una métrica» explica los niveles, los tipos de valor, la dirección y los umbrales que aparecen en la ficha de cada página. «Primeros pasos» presenta las métricas esenciales.

Referencias