Longitud de Halstead

Actualizado el 15 de noviembre de 2026

Sigla N
Aspecto «Complejidad»
Se mide en método, clase
Tipo de valor puntuación (entero, mínimo 0)
Dirección informativa: ni alto ni bajo es mejor
Origen Maurice H. Halstead, 1977
Familia «Medidas de Halstead»
Stau Metro HalsteadLengthMethod, HalsteadLengthClass

En pocas palabras

Mide el tamaño de un método o de una clase contando sus piezas: cada operador (=, +, if, return, una llamada a un método…) y cada operando (una variable, un campo, un literal). Cada aparición cuenta, aunque se repita. Es como contar las palabras de un texto en lugar de sus líneas: no le afecta cómo esté formateado el código.

Qué mide

El tamaño léxico del código. Las líneas de código dependen del estilo: la misma expresión puede ocupar una línea o cinco. La longitud de Halstead no ve saltos de línea ni comentarios; solo ve los elementos con los que se escribe el cálculo.

Halstead dividía cualquier programa en dos clases de tokens:

  • Operadores: lo que actúa. Símbolos aritméticos, lógicos y de asignación, palabras clave del lenguaje y llamadas a funciones.
  • Operandos: aquello sobre lo que se actúa. Variables, constantes y literales.

Con esas dos clases se definen cuatro recuentos básicos, de los que salen todas las demás medidas de la familia:

Símbolo Significado
n1 operadores distintos
n2 operandos distintos
N1 apariciones de operadores, con repeticiones
N2 apariciones de operandos, con repeticiones

La longitud usa los dos recuentos con repeticiones. Su pareja, el «vocabulario», usa los dos de elementos distintos.

Cómo se calcula

N=N1+N2N = N_1 + N_2

La fórmula es trivial. Lo difícil es decidir qué es un operador y qué es un operando, y ahí Halstead no dejó unas reglas cerradas para cada lenguaje: cada herramienta fija las suyas. Las dudas habituales son los signos de puntuación (paréntesis, llaves, punto y coma), las declaraciones (tipos, modificadores, nombres de parámetros) y los nombres de métodos. El ejemplo de la página de Wikipedia, por ejemplo, cuenta (), {}, la coma y el punto y coma como operadores; Stau Metro no los cuenta (ver «En las herramientas»). Por eso dos herramientas casi nunca dan la misma longitud para el mismo código.

Ejemplo

Con las reglas de Stau Metro:

class Prices {
    static final int TAX = 21;

    double withTax(double price, boolean exempt) {   // operadores: double, double, boolean
        if (exempt) {                                // operador: if        operando: exempt
            return price;                            // operador: return    operando: price
        }
        double factor = 1 + TAX / 100.0;             // operadores: double, =
                                                     // operandos: factor, «1 + TAX / 100.0»
        return Math.round(price * factor * 100)      // operadores: return, *, *, round
                / 100.0;                             // operador: /
                                                     // operandos: price, factor, 100, 100.0
    }
}

Para el método withTax:

  • Operadores: 3 + 1 + 1 + 2 + 5 = 12 apariciones (N1).
  • Operandos: 1 + 1 + 2 + 4 = 8 apariciones (N2).
  • N=12+8=20N = 12 + 8 = 20.

Tres detalles del recuento. Los nombres withTax, price y exempt de la cabecera no cuentan: son declaraciones sin inicializador. 1 + TAX / 100.0 es una expresión constante, que el compilador resuelve, y cuenta como un solo operando, sin su + ni su /. Y factor, al declararse con valor inicial, aporta el = y su propio nombre, igual que si se hubiera escrito double factor; factor = ….

Para la clase Prices se suma todo lo que hay en ella: lo del método más class, static, final, int, el = de TAX (5 operadores) y los operandos TAX y 21 (2). La longitud de la clase es 20+5+2=2720 + 5 + 2 = 27.

Este mismo ejemplo se sigue en las páginas de «vocabulario», «volumen», «dificultad», «esfuerzo» y «errores estimados».

Cómo interpretarla

Es una medida de tamaño, y como tal no tiene un valor bueno ni malo; Stau Metro no le asigna umbrales. Sirve:

  • como alternativa a las líneas de código, cuando el formato del código varía mucho entre ficheros o equipos;
  • comparada con el vocabulario: una longitud muy superior al vocabulario indica que se repiten mucho los mismos elementos (el mismo campo, el mismo literal);
  • como ingrediente del «volumen», que es la medida de tamaño que Halstead usaba en el resto de sus fórmulas.

Un método con una longitud alta es, sin más, un método largo en tokens. Si además su «dificultad» es alta, merece la misma atención que cualquier método largo y enrevesado: extraer partes con nombre suele bajar las dos.

Ojo. No compares longitudes calculadas por herramientas distintas. Que una cuente los paréntesis y los punto y coma y otra no basta para que los valores no se parezcan.

Para profundizar

Longitud estimada. Halstead propuso estimar la longitud a partir del vocabulario solo, sin contar repeticiones:

N^=n1log⁡2n1+n2log⁡2n2\hat{N} = n_1 \log_2 n_1 + n_2 \log_2 n_2

Su hipótesis era que, en un programa bien escrito, N^\hat{N} y NN se parecen. En el ejemplo, con n1=8n_1 = 8 y n2=6n_2 = 6, N^≈24+15,5=39,5\hat{N} \approx 24 + 15{,}5 = 39{,}5, el doble de la longitud real (20): la estimación no está pensada para fragmentos tan cortos. Stau Metro no calcula N^\hat{N}.

Críticas. La parte teórica de la software science de Halstead (la que justifica fórmulas como N^\hat{N} o el esfuerzo) fue revisada con dureza por Shen, Conte y Dunsmore (1983), que repasaron también los estudios experimentales publicados desde 1977. La longitud en sí no depende de esa teoría: es un recuento, y vale como medida de tamaño siempre que se sepa qué cuenta.

Formas de falsearla. Como cualquier medida de tamaño, baja al comprimir el código (expresiones encadenadas, variables temporales eliminadas) sin que el código sea más fácil de leer.

Relación con otras métricas

En las herramientas

Stau Metro (HalsteadLengthMethod por método, HalsteadLengthClass por clase). Recorre el árbol sintáctico de Java y cuenta:

  • como operador: cada palabra clave, incluidos modificadores (public, static, final), tipos primitivos y void, class, new, this, instanceof; cada signo de una operación aritmética, lógica, relacional o de desplazamiento; cada signo de asignación (=, +=…); cada ++ y --; el operador condicional, como un único operador ?:; y cada llamada a un método que se pueda resolver, identificada por el método llamado (dos llamadas al mismo método son el mismo operador; dos sobrecargas distintas, operadores distintos, salvo si sus parámetros solo difieren en el paquete de un tipo). Una expresión new aporta solo la palabra clave new: la llamada al constructor no cuenta como operador;
  • como operando: cada referencia a una variable, un parámetro o un campo, con el texto tal como está escrito, y cada literal (números, cadenas, caracteres, true, false y null);
  • una declaración con inicializador (int x = a) aporta el = y el nombre declarado como operando.

No cuentan: los signos de puntuación (paréntesis, llaves, corchetes, comas, punto y coma, el punto), la flecha -> de las lambdas y el :: de las referencias a métodos; los nombres de tipos que no son primitivos (String, List); los nombres de métodos en su declaración; los nombres de parámetros y de variables declaradas sin valor inicial; las llamadas y las referencias que no se pueden resolver; y las anotaciones enteras, con sus argumentos. Una constante de enumerado no cuenta como variable inicializada: enum Color { RED, GREEN, BLUE } vale 1 (solo enum).

Una expresión que el compilador evalúa como constante (literales y constantes final combinados con operadores, como MAX + 1) cuenta como un único operando, identificado por su texto. Las referencias cualificadas cuentan por partes: en a.b, con a variable, cuentan a y a.b; this.f y f son operandos distintos, aunque designen el mismo campo.

Qué entra en cada nivel:

  • Método. Todo lo que hay en la declaración, cabecera incluida (modificadores, tipo de retorno si es primitivo o void, tipos primitivos de los parámetros, throws), y todo su cuerpo, incluidas sus lambdas y las clases anónimas o locales declaradas dentro. Los constructores cuentan como métodos; un constructor vacío sin modificadores vale 0. No se calcula para métodos abstractos (tampoco para los métodos abstractos de las interfaces; sí para sus métodos default, static y private). Los métodos de una clase anónima o local declarada dentro de un método no tienen valor propio: ya cuentan en ese método. Los de una clase anónima en el inicializador de un campo sí lo tienen; una lambda en ese mismo sitio no cuenta en ningún método.
  • Clase. Todo lo que hay en la clase: cabecera, campos, inicializadores y todos sus métodos, abstractos incluidos (su cabecera suma, aunque no tengan valor propio), con las clases anónimas y locales que contengan. Las clases con nombre anidadas se miden aparte y no cuentan en la que las contiene. Se calcula para clases, clases abstractas, enumerados y records; no para interfaces ni para clases anónimas o locales.

Entra todo el código Java del ámbito analizado, de producción y de test. Kotlin no se mide.

Radon (Python) calcula las mismas medidas básicas de Halstead a partir de n1n_1, n2n_2, N1N_1 y N2N_2; su documentación no detalla qué cuenta como operador ni como operando.

Referencias