Número de sentencias ejecutables
| Sigla | EXEC |
| Aspecto | «Tamaño» |
| Se mide en | método |
| Tipo de valor | recuento (entero, mínimo 0) |
| Dirección | más alto es peor |
| Stau Metro | NumExecutableStatements |
En pocas palabras
Cuenta las sentencias de un método que hacen algo por sí mismas: asignar, llamar a otro método, declarar una
variable, devolver un valor o lanzar una excepción. No cuenta los if, los bucles, los switch ni los try, que
solo organizan el orden en que se ejecuta lo demás.
Qué mide
Mide el trabajo directo de un método, quitando el esqueleto de control. Es una vista más fina del tamaño que el
«número de sentencias»: un método lleno de if anidados puede tener muchas sentencias y pocas
ejecutables, y uno que solo asigna campos uno tras otro tendrá las dos cifras casi iguales.
Cómo se calcula
Se suman las sentencias de estos tipos y solo estas:
- declaración de variables locales (
int x = 0;); - sentencia de expresión (
x = 1;,x++;,f();); assert;return;throw.
No cuentan los if, los bucles (for, while, do), switch y sus etiquetas case, try, synchronized, las
sentencias con etiqueta, break, continue ni yield; tampoco las llaves de bloque ni la sentencia vacía.
Ejemplo
static int sumPositives(int[] values) {
int total = 0; // declaración: 1
for (int i = 0; i < values.length; i++) { // for: no cuenta; declaración int i = 0: 1; i++: 1
if (values[i] > 0) { // if: no cuenta
total += values[i]; // expresión: 1
}
}
return total; // return: 1
}
Total: 1 + 2 + 1 + 1 = 5. El mismo método tiene 7 sentencias en total
(«STAT»): la diferencia, 2, son el for y el if.
Cómo interpretarla
Más alto es peor, con la misma lectura que STAT: un método con muchas sentencias ejecutables hace mucho trabajo
directo y suele convenir dividirlo. Stau Metro no trae umbral de referencia para esta métrica.
Compárala con STAT. Si EXEC es muy inferior, el método es sobre todo estructura de control: mira entonces su
«complejidad ciclomática». Si son casi iguales, el método es una secuencia
de pasos y tiene poca lógica de decisión.
Relación con otras métricas
- «Número de sentencias» (
STAT): cuenta además las sentencias de control;STAT − EXECmide el esqueleto del método (másbreak,continue, etc.). - «Número de expresiones» (
EXP): el cálculo que hay dentro de cada sentencia. - «Líneas de código sin comentarios» (
NCLOC): el tamaño en líneas físicas. - «Complejidad ciclomática» (
v(G)): cuenta las decisiones que aquí se descartan.
En las herramientas
Stau Metro (NumExecutableStatements, método). Cuenta las declaraciones, las sentencias de expresión, los
assert, los return y los throw. Por tanto, break, continue, yield, las sentencias con etiqueta y
synchronized no suman, y tampoco lo hacen los if, los bucles, switch, sus etiquetas case y try. La
inicialización y la actualización de un for clásico sí suman, porque son una declaración y una sentencia de
expresión (una actualización con comas, i++, j--, suma 1). El cuerpo de una regla case 1 -> f(); cuenta como
sentencia de expresión. Una clase local declarada dentro del método cuenta como una declaración, y una llamada
this(…) o super(…) al principio de un constructor, como sentencia de expresión. Las sentencias de lambdas y de
clases anónimas o locales se suman al método que las contiene. No se calcula para métodos abstractos ni de interfaz
sin cuerpo; los constructores cuentan como métodos. No existe versión de clase.
Checkstyle (ExecutableStatementCount) tiene un nombre parecido, pero cuenta otra cosa: suma las sentencias que
hay directamente en cada bloque entre llaves del miembro, incluidas las de control (if, for, try…), por
separado en constructores, métodos, bloques de inicialización y lambdas. Su recuento se parece más al de
«STAT». Informa cuando supera 30, su máximo por defecto.
Referencias
- Checkstyle, comprobación
ExecutableStatementCount: https://checkstyle.org/checks/sizes/executablestatementcount.html y su código fuente: https://github.com/checkstyle/checkstyle/blob/master/src/main/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheck.java