IntelliJ IDEA: estilo de codificación y formato de código

Un lenguaje de programación es muy similar a un lenguaje hablado. La única diferencia es que es un lenguaje especial cuyo propósito principal es facilitar la comunicación con una computadora para explicarle a la computadora lo que queremos que haga. Pero no puedes tener una conversación personal con una computadora. Cuando comenzaste a aprender un lenguaje de programación, mirabas libros o algún recurso educativo como CodeGym. Y este recurso le mostró el código que la computadora entiende. Pero usted también debe entenderlo a medida que aprende sobre el lenguaje Java. Como con cualquier lenguaje, se han adoptado algunas convenciones de formato en la programación. Por ejemplo, en la sociedad educada, ESCRIBIR ASÍ SE CONSIDERARÍA DE MALOS MODALES. Y en Java, comenzar el nombre de un método con una letra mayúscula es una grave violación de las convenciones de codificación. Las reglas para el código Java se proporcionan en el documento Convenciones de código para el lenguaje de programación Java . Las convenciones de codificación también pueden regular detalles más pequeños, como la sangría. Imagine la pesadilla absoluta en la que se convertiría el control de versiones si la sangría fuera inconsistente, algunas personas usaran tabulaciones y otras personas usaran espacios. ¿Cómo sería para alguien que necesita registrar una solución en un solo método, pero encuentra que todo el archivo ha cambiado debido a las diferencias en los espacios y las pestañas? Por supuesto, al igual que con el lenguaje común, las convenciones pueden cambiar dependiendo de dónde se use el idioma. Por ejemplo, en las vastas extensiones de la web, puede encontrar la Guía de estilo Java de Google y la Guía de estilo Java de Twitter.. Para esta revisión, necesitamos un sujeto de prueba. Usaremos el sistema de automatización de compilación Gradle. Nos permitirá comenzar rápidamente creando un nuevo proyecto a partir de una plantilla. Gradle tiene un gran complemento: Build Init Plugin . Vayamos a un nuevo directorio y ejecutemos el siguiente comando allí: gradle init --type java-application Después de eso, inicie IntelliJ IDEA. Si ve una ventana con un proyecto abierto (es decir, ve el editor de código y el árbol del proyecto), cierre este proyecto usando File -> Close Project. Ahora, en la ventana de bienvenida, ejecute " Import Project" e importe nuestro nuevo proyecto. Al importar, establezca la Use autoimportcasilla de verificación " ". Averigüemos si podemos usar herramientas de desarrollo de última generación para simplificar la vida de alguna manera.

Formateo de código en IDEA

Después de importar el proyecto, presione Ctrl+N y vaya a la AppTestclase. Esta es la clase de prueba predeterminada. Se parece a esto:

import org.junit.Test;
import static org.junit.Assert.*;

public class AppTest {
    @Test public void testAppHasAGreeting() {
        App classUnderTest = new App();
        assertNotNull("app should have a greeting", classUnderTest.getGreeting());
    }
}

¿Qué te llama la atención de inmediato? Una anotación en la misma línea que la declaración de un método, que se ve feo, ¿verdad? ¿Cómo arreglar esto? IntelliJ IDEA tiene una Codeentrada de menú " " para varias manipulaciones de código. Una de esas manipulaciones es " Reformat Code", que puede aplicar usando Ctrl+L. Después de hacer esto, la anotación estará en una línea y la declaración del método en otra. Vale la pena señalar de inmediato que esta operación se realiza en el código seleccionado actualmente . Si no hay selección, la operación de formateo se realiza en todo. Ahora agreguemos un nuevo método de prueba:

@Test
public void testSumOfOddNumbers() {
	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
	Integer result = data.stream().filter(number -> number % 2 == 0).reduce((n1, n2) -> n1 + n2).get();
	assertThat(result, is(12));
}

Y dos importaciones:

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

Como puede ver, la operación en Stream es en una línea. Pero, ¿qué sucede si queremos asegurarnos de que las llamadas a métodos encadenados siempre se dividan en nuevas líneas en cada operador de período? Podríamos hacer esto manualmente. Pero recuerda que queremos que todo suceda automáticamente. De hecho, seguramente olvidaremos el paso manual de vez en cuando, y luego terminaremos con un formato diferente en todas partes, y eso no es bueno. Entonces necesitamos editar la regla que IDEA usa para formatear. ElegirFile -> Settingsen el menú IDEA (o presione Ctrl+Alt+S). Ingrese "Estilo de código" en el campo de búsqueda en la ventana de configuración. En la sección "Estilo de código", puede especificar configuraciones para más idiomas además de Java. Pero Java es lo que nos interesa en este momento. Como puede ver, la configuración se divide en varias pestañas. Una característica súper útil es que se muestra un ejemplo de la operación en la parte derecha de la ventana: La captura de pantalla muestra que podemos configurar "Llamadas a métodos encadenados" para "envolver siempre", es decir, dividir siempre las llamadas a métodos encadenados en líneas separadas. ¡Ahora haga clic en el botón de formato nuevamente en la clase de prueba y vemos que realmente funciona! Pero a veces necesita formatear algún código fuera de las reglas de formato estándar. Configure el formato de la siguiente manera: Para evitar el formateo, en la sección "Estilo de código", habilite los marcadores de formateador: Ahora podemos cambiar nuestra clase de prueba para que su código no se reformatee:

@Test
public void testSumOfOddNumbers() {
	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
	// @formatter:off
	Integer result = data.stream().filter(number -> number % 2 == 0)
                             .reduce((n1, n2) -> n1 + n2)
                             .get();
	assertThat(result, is(12));
	// @formatter:on
}

Es posible que haya notado que cuando presiona Tabulador, IDEA lo interpreta como un espacio (este es el comportamiento predeterminado). Pero puede cambiar esto en la Code Stylesección " ": Como puede ver, hay muchas configuraciones allí. Puede leer más detalles sobre Code stylela configuración de " " aquí: " Ayuda de IDEA: Estilo de código ". Hay otra función de formato importante: las importaciones de formato. Esta operación se ejecuta por separado y se denomina " Optimize Imports". Se encuentra debajo de Code -> Optimize Imports(Ctrl+Alt+O). La optimización de las importaciones elimina las importaciones innecesarias y organiza las importaciones en el orden correcto de acuerdo con la configuración en la Importspestaña " " de la Code Styleconfiguración " " de Java. Además, si desea que este formato se realice automáticamente, hay buenas noticias:Complemento Guardar acciones .

Distribuir configuraciones en un comando

Vimos anteriormente que puede personalizar su estilo de formato como lo desee. Pero, ¿cómo se usa este estilo dentro de un equipo? Muy facilmente. Hay varias opciones. El más simple es guardar un esquema de estilo de código. Abra la configuración de IDEA usando File -> Settings(o presione Ctrl+Alt+S). En la Code Stylesección " ", podemos ver "Esquema". Este es nuestro esquema de formato. De manera predeterminada, se usa el esquema "Predeterminado" y se etiqueta como "IDE", lo que significa que esta configuración solo se aplica a nuestro IDE, no afecta a nadie más. Para hacer un esquema "personalizado", use el botón de la derecha para hacer una copia y darle un nombre, por ejemplo: CodeGym Luego que podemos importar o exportar la configuración: Otra opción es importar la configuración de IDEA: Una tercera opción es el repositorio de configuración. Para usar el Repositorio de configuraciones, consulte la documentación de ayuda de IntelliJ IDEA para obtener más detalles en el siguiente enlace: Repositorio de configuraciones ". Hablando de impulsar un estilo unificado en un equipo, tampoco puedo dejar de mencionar el buen soporte para estilos de Eclipse IDE. Para hacer esto, debe instalar un complemento separado: abra la configuración de IDEA a través de Archivo -> Configuración (Ctrl + Alt + S) y vaya a la sección "Complementos". Para encontrar nuevos complementos, haga clic en el botón " ". Browse RepositoriesLuego busque el complemento Eclipse Code Formatter en la ventana de búsqueda. Después de instalarlo, deberá reiniciar IDEA; este es el procedimiento estándar. Ahora todo está hecho. Hay una nueva sección en la configuración de IDEA: "Eclipse Code Formatter".. Se verá algo como esto:

Requisitos más estrictos

Además de las herramientas de IDEA, también puede usar complementos de automatización de compilación para ajustar los requisitos. No hay forma de que pueda verificar manualmente que alguien haya usado el formato adecuado. Tal vez podrías con 5 personas en un equipo. Pero con 100 personas en una empresa, no es realista. E incluso cinco serán difíciles de rastrear. ¿Y por qué perder el tiempo en nada de esto? Sería mucho más fácil evitar que se construya el proyecto si se violan las reglas. De hecho, este es un tema completamente separado llamado "Inspeccionar código". En este artículo, solo quiero mostrarte cómo funciona. Uno de los complementos de Gradle más populares (ya que compila nuestro proyecto, recordará) es pmd. Para habilitarlo, simplemente vaya al script de compilación de nuestro proyecto Gradle (el archivo build.gradle en la raíz de nuestro proyecto) y agregue pmd junto al resto de los complementos:

plugins {
    // Apply the java plugin to add support for Java
    id 'java'
    // Check source code
    id 'pmd'
    // Apply the application plugin to add support for building an application
    id 'application'
}

Ahora podemos ingresar configuraciones más detalladas en el mismo lugar:

pmd {
    ignoreFailures = false
    pmdTest.enabled = true
    ruleSets = [
            'java-basic',
            'java-braces',
            'java-clone',
            'java-codesize',
            'java-comments',
            'java-controversial',
            'java-coupling',
            'java-design',
            'java-empty',
            'java-finalizers',
            'java-imports',
            'java-optimizations',
            'java-strictexception',
            'java-strings',
            'java-typeresolution',
            'java-unnecessary',
            'java-unusedcode'
    ]
}

Incluso nuestro proyecto está roto ahora. Ejecutar gradle buildy obtenemos un error. Lo bueno es que se genera un informe durante la compilación. Y si hay errores, nos sale un mensaje como este:

BUILD FAILED in 35s
6 actionable tasks: 6 executed
7 PMD rule violations were found. See the report at: file:///C:/_study/codestyle/build/reports/pmd/main.html

Al ir al informe, vemos algo como esto: Además, la Problemcolumna " " proporciona un enlace a una descripción del problema en el sitio web del complemento pmd. Por ejemplo, para el headerCommentRequirement Requirederror " ", el enlace va aquí: pmd — CommentRequired . Este error es una pista de que nuestra clase no tiene un JavaDoc. Podemos usar plantillas para configurar un JavaDoc por encima de las clases: Y especificar los contenidos para File Header: Después de eso, podemos convertir el comentario por encima de la clase App en un JavaDoc y ver que el error desaparece en una nueva compilación.

La línea de fondo

El estilo del código es importante para maximizar la productividad en un proyecto. El hermoso código escrito de acuerdo con las reglas compartidas garantiza que sus compañeros de trabajo lo entenderán más fácil y rápidamente y no lo criticarán. Con las herramientas de desarrollo modernas, no es tan difícil apegarse a las reglas de estilo. Espero que esta revisión le haya demostrado que esto es cierto. Siguiendo la tradición, aquí hay un poco de material adicional sobre el tema:

• Video de JetBrainsTV: " Inspeccionar código (IntelliJ IDEA) "
• Revisión de " Análisis de código con complementos de Gradle "
• Curso " Automatización de la calidad del código "