Líneas de código

Actualizado el 15 de noviembre de 2026

Sigla LOC
Aspecto «Tamaño»
Se mide en método, clase, interfaz
Tipo de valor recuento (entero, mínimo 0)
Dirección más alto es peor
Stau Metro LinesOfCodeMethod, LinesOfCodeClass, LinesOfCodeInterface

La misma sigla, LOC, designa en Stau Metro el recuento de «paquetes, módulos, proyectos y tipos de fichero».

En pocas palabras

Cuenta las líneas que tiene el texto de un método, una clase o una interfaz, sin contar las que están en blanco. Los comentarios y el Javadoc sí cuentan. Es la forma más directa de saber cuánto hay que leer.

Qué mide

El volumen de texto de un elemento. No mide cuánto hace el código ni lo difícil que es: dos métodos con las mismas instrucciones pueden dar valores muy distintos según cómo se formateen o cuánto se comenten.

Ojo. En la literatura, «líneas de código» suele significar líneas físicas sin comentarios (ver «Para profundizar»). Este LOC incluye los comentarios. La variante que los excluye es las «líneas de código sin comentarios» (NCLOC), que es la que lleva umbrales.

Cómo se calcula

Se toma el texto fuente del elemento y se cuenta cada línea que tenga algún carácter distinto de espacio y tabulación. Las líneas vacías o con solo blancos no suman. Se tratan igual los finales de línea \n y \r\n.

El texto del elemento incluye todo lo que va con él: el comentario Javadoc que lo precede, las anotaciones, la firma y las llaves.

Ejemplo

/** Outer. */                      // 1
public class Outer {               // 1
    // a comment                   // 1
    int x;                         // 1

    static class Inner {           // clase anidada: 4 líneas, no cuentan en Outer
        /* inner */
        int y;
    }

    void m() {                     // 1
        class Local {              // 1
            int z;                 // 1
        }                          // 1
    }                              // 1
}                                  // 1

Outer tiene 14 líneas no vacías. Inner ocupa 4, que se restan: LOC(Outer) = 10 y LOC(Inner) = 4. El método m vale 5. La clase local Local no tiene valor propio: sus líneas están en m y en Outer. El valor de m y los de Outer e Inner son los que fija un test del proyecto con este mismo código.

Cómo interpretarla

Un valor alto significa que hay mucho que leer. En un método suele indicar que hace demasiado y conviene extraer partes; en una clase, que tiene demasiadas responsabilidades o demasiado código de apoyo.

Como los comentarios suman, documentar un método eleva su LOC. Para juzgar si un método es largo, usa mejor las «líneas de código sin comentarios», que son las que tienen umbrales de referencia. Esta métrica no tiene umbrales propios.

Un valor alto es aceptable en código plano y sin lógica: una tabla de constantes, un método de mapeo, un builder. Para saber si el tamaño oculta complejidad, léela junto a la «complejidad ciclomática».

Para profundizar

La definición más repetida de SLOC (source lines of code) es «el número de líneas del texto del código fuente, excluidas las líneas de comentario»; la variante lógica cuenta sentencias en lugar de líneas físicas (Wikipedia, «Source lines of code»). Robert E. Park y otros publicaron en 1992 en el Software Engineering Institute un marco para declarar con exactitud qué se cuenta (comentarios, líneas vacías, código reutilizado, generado…), precisamente porque las cifras de distintas fuentes no eran comparables. Por eso, al citar un LOC, hay que decir qué incluye.

Críticas habituales: depende del lenguaje y del formato, no mide funcionalidad, y si se premia, invita a escribir de más. El código refactorizado suele bajar el valor sin perder funcionalidad.

Relación con otras métricas

En las herramientas

Stau Metro (LinesOfCodeMethod, LinesOfCodeClass, LinesOfCodeInterface).

  • Método. Entran métodos, constructores y métodos abstractos o de interfaz (un método abstracto con Javadoc de una línea vale 2). Las lambdas y las clases anónimas o locales declaradas dentro del cuerpo cuentan dentro del método; los métodos de esas clases no tienen valor propio. Sí lo tienen los métodos de una clase anónima declarada fuera de un método: en el inicializador de un campo o en el cuerpo de una constante de un enumerado.
  • Clase. Entran las clases con nombre, también enumerados, records y clases abstractas. No entran las clases anónimas ni las locales (sus líneas están en la clase o el método que las contiene) ni las interfaces. De cada clase se restan las líneas de sus clases e interfaces anidadas (miembro), que tienen su propio valor; por eso la suma de los LOC de las clases de un fichero no da el total del fichero. Se resta el texto entero de la anidada, Javadoc incluido: si ese Javadoc empieza en una línea que también tiene código de la clase exterior, esa línea se resta igualmente y la exterior pierde una línea.
  • Interfaz. Las interfaces propiamente dichas; los tipos de anotación no entran en ninguna de las dos. Se restan igual las interfaces y clases anidadas.

No se distingue código de test de código de producción.

Checkstyle (comprobación MethodLength, sobre métodos, constructores y constructores compactos de records) cuenta por defecto las líneas vacías y los comentarios (countEmpty vale true) y su máximo por defecto es 150 líneas; con countEmpty a false los excluye.

SonarQube distingue lines, el número de líneas físicas, de ncloc, que descarta blancos y comentarios (ver «NCLOC»). El LOC de Stau Metro queda entre los dos: no cuenta las líneas vacías, pero sí las de comentario.

Referencias