Número de sentencias de control

Actualizado el 15 de noviembre de 2026

Sigla CONTROL
Aspecto «Complejidad»
Se mide en método
Tipo de valor recuento (entero, mínimo 0)
Dirección informativa: ni alto ni bajo es mejor
Stau Metro NumControlStatements

En pocas palabras

Cuenta cuántas sentencias de un método sirven para dirigir el flujo en lugar de hacer un trabajo: los if, los bucles, los switch y cada uno de sus case, los try, los synchronized y los saltos. Es la cantidad de «estructura» que tiene el método.

Qué mide

El volumen de control de flujo de un método, en bruto. Se diferencia de la «complejidad ciclomática» en que no cuenta decisiones sino sentencias: un try suma aunque no decida nada, un else no suma, y los operadores && y || no se ven porque no son sentencias. Es sobre todo útil como numerador: dividido entre el número de sentencias da la «densidad de control».

Cómo se calcula

Se suma 1 por cada sentencia de control de flujo del método. El inventario exacto está en «En las herramientas».

Ejemplo

static int grade(int[] scores, int level) {
    int total = 0;
    for (int s : scores) {               // +1 for mejorado
        if (s < 0) {                     // +1 if
            continue;                    // +1 continue
        }
        total += s;
    }
    switch (level) {                     // +1 switch
        case 1:                          // +1 etiqueta case
            total *= 2;
            break;                       // +1 break
        default:                         // +1 etiqueta default
            total += 1;
    }
    try {                                // +1 try
        return total / scores.length;
    } catch (ArithmeticException e) {    // 0: el catch no suma
        return 0;
    }
}

Total: 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 8. Los dos return no cuentan.

Cómo interpretarla

No tiene umbrales. Como es un valor absoluto, crece con el tamaño del método; para saber si el método es denso en control, compáralo con el «número de sentencias» o mira directamente la «densidad de control». Un switch largo hace subir mucho el valor (suma 1 por el switch y 1 por cada case) sin que el método sea difícil de leer.

Relación con otras métricas

En las herramientas

Stau Metro (NumControlStatements, a nivel de método). Suma 1 por cada una de estas construcciones:

  • if, for, for mejorado, while, do … while;
  • switch, sea sentencia o expresión, y además 1 por cada etiqueta case o default de un switch clásico y 1 por cada regla case -> (también la de default) de un switch con flechas; en un switch clásico, case 1: case 2: son dos etiquetas y suman 2, mientras que case 1, 2: es una sola y suma 1;
  • try (no catch ni finally), synchronized;
  • break (todos, incluidos los de los switch), continue y yield.

No suman return, throw, else, catch, los operadores &&, || y ? :, ni las lambdas en sí. Lo que haya dentro de las lambdas y de las clases anónimas o locales declaradas en el método se suma al método que las contiene. No se calcula para los métodos abstractos. Así, un método con un switch de dos reglas y un if dentro de una de ellas vale 4 (el switch, sus dos reglas y el if), y uno que devuelve un switch de expresión con tres reglas y un yield vale 5.