IntelliJ IDEA : Style de codage et formatage du code

Un langage de programmation est très similaire à un langage parlé. La seule différence est qu'il s'agit d'un langage spécial dont le but principal est de faciliter la communication avec un ordinateur afin d'expliquer à l'ordinateur ce que nous voulons qu'il fasse. Mais vous ne pouvez pas avoir une conversation personnelle avec un ordinateur. Lorsque vous avez commencé à apprendre un langage de programmation, vous avez regardé des livres ou des ressources pédagogiques comme CodeGym. Et cette ressource vous a montré du code que l'ordinateur comprend. Mais vous aussi devriez le comprendre en découvrant le langage Java. Comme pour tout langage, certaines conventions de formatage ont été adoptées dans la programmation. Par exemple, dans une société polie, écrire comme ça serait considéré comme de mauvaises manières. Et en Java, commencer le nom d'une méthode par une majuscule est une violation flagrante des conventions de codage. Les règles du code Java sont données dans le document Code Conventions for the Java Programming Language . Les conventions de codage peuvent également réglementer des détails plus petits, tels que l'indentation. Imaginez le cauchemar total que deviendrait le contrôle de version si l'indentation était incohérente, certaines personnes utilisant des tabulations et d'autres des espaces. À quoi cela ressemblerait-il pour quelqu'un qui a besoin d'enregistrer un correctif en une seule méthode, mais qui trouve que l'ensemble du fichier a été modifié en raison de différences d'espaces et de tabulations ? Bien sûr, comme pour le langage ordinaire, les conventions peuvent changer selon l'endroit où un langage est utilisé. Par exemple, dans les vastes étendues du Web, vous pouvez trouver le Google Java Style Guide et le Twitter Java Style Guide. Pour cet examen, nous avons besoin d'un sujet de test. Nous utiliserons le système d'automatisation de construction Gradle. Cela nous permettra de démarrer rapidement en créant un nouveau projet à partir d'un modèle. Gradle a un super plugin : Build Init Plugin . Allons dans un nouveau répertoire et exécutons-y la commande suivante : gradle init --type java-application Après cela, démarrez IntelliJ IDEA. Si vous voyez une fenêtre avec un projet ouvert (c'est-à-dire que vous voyez l'éditeur de code et l'arborescence du projet), fermez ce projet à l'aide de File -> Close Project. Maintenant dans la fenêtre de bienvenue, lancez " Import Project" et importez notre nouveau projet. Lors de l'importation, cochez la Use autoimportcase " ". Voyons si nous pouvons utiliser des outils de développement de pointe pour simplifier la vie d'une manière ou d'une autre.

Formatage du code dans IDEA

Après avoir importé le projet, appuyez sur Ctrl+N et accédez à la AppTestclasse. Il s'agit de la classe de test par défaut. Il ressemble à ceci :

 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'est-ce qui saute immédiatement aux yeux ? Une annotation sur la même ligne qu'une déclaration de méthode, qui a l'air moche, non ? Comment régler ceci? IntelliJ IDEA a une Codeentrée de menu " " pour diverses manipulations de code. Une de ces manipulations est " Reformat Code", que vous pouvez appliquer en utilisant Ctrl+L. Après cela, l'annotation sera sur une ligne et la déclaration de méthode sur une autre. Il convient de noter tout de suite que cette opération est effectuée sur le code actuellement sélectionné . S'il n'y a pas de sélection, l'opération de formatage est effectuée sur tout. Ajoutons maintenant une nouvelle méthode de test :

 @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));
 }

Et deux importations :

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

Comme vous pouvez le voir, l'opération sur le Stream se fait sur une seule ligne. Mais que se passe-t-il si nous voulons nous assurer que les appels de méthode chaînés sont toujours divisés en nouvelles lignes à chaque opérateur de période ? Nous pourrions le faire manuellement. Mais rappelez-vous que nous voulons que tout se passe automatiquement. En effet, on oubliera certainement l'étape manuelle de temps en temps, et puis on se retrouvera avec un formatage différent partout, et ça ne sert à rien. Nous devons donc modifier la règle utilisée par IDEA pour le formatage. ChoisirFile -> Settingsdans le menu IDEA (ou appuyez sur Ctrl+Alt+S). Entrez "Style de code" dans le champ de recherche de la fenêtre des paramètres. Dans la section "Style de code", vous pouvez spécifier des paramètres pour d'autres langages que Java. Mais Java est ce qui nous intéresse en ce moment. Comme vous pouvez le voir, les paramètres sont divisés en plusieurs onglets. Une fonctionnalité super utile est qu'un exemple de l'opération est affiché dans la partie droite de la fenêtre : la capture d'écran montre que nous pouvons définir "Chained method calls" sur "wrap always", c'est-à-dire toujours diviser les appels de méthode chaînés en lignes séparées. Maintenant, cliquez à nouveau sur le bouton de formatage dans la classe de test et nous voyons que cela fonctionne vraiment ! Mais parfois, vous devez formater du code en dehors des règles de formatage standard. Configurez le formatage comme suit : Afin d'empêcher le formatage, dans la section "Code Style", activez les marqueurs de formatage : nous pouvons maintenant modifier notre classe de test afin que son code ne soit pas reformaté :

 @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
 }

Vous avez peut-être remarqué que lorsque vous appuyez sur Tab, IDEA l'interprète comme un espace (c'est le comportement par défaut). Mais vous pouvez modifier cela dans la Code Stylesection " " : comme vous pouvez le voir, il y a beaucoup de paramètres ici. Vous pouvez lire plus de détails sur Code styleles paramètres " " ici : " Aide IDEA : Style de code ". Il existe une autre fonctionnalité de formatage importante : le formatage des importations. Cette opération est exécutée séparément et s'appelle " Optimize Imports". Il se trouve sous Code -> Optimize Imports(Ctrl+Alt+O). L'optimisation des importations supprime les importations inutiles et organise les importations dans le bon ordre en fonction des paramètres de l' Importsonglet " " des Code Styleparamètres " " pour Java. De plus, si vous souhaitez que ce formatage se fasse automatiquement, il y a de bonnes nouvelles :Plug-in Enregistrer les actions .

Distribution des paramètres dans une commande

Nous avons vu ci-dessus que vous pouvez personnaliser votre style de mise en forme comme bon vous semble. Mais comment utiliser ce style au sein d'une équipe ? Très facilement. Il existe plusieurs options. Le plus simple consiste à enregistrer un schéma de style de code. Ouvrez les paramètres IDEA à l'aide de File -> Settings(ou appuyez sur Ctrl+Alt+S). Dans la Code Stylesection " ", nous pouvons voir " Schéma ". Ceci est notre schéma de formatage. Par défaut, le schéma "Default" est utilisé et est étiqueté "IDE", ce qui signifie que ce paramètre ne s'applique qu'à notre IDE - il n'affecte personne d'autre. Pour faire un schéma "personnalisé", utilisez le bouton à droite pour en faire une copie et lui donner un nom, par exemple : CodeGym Ensuite que l'on peut importer ou exporter les paramètres : Une autre option est d'importer les paramètres IDEA : Une troisième option est le référentiel de paramètres. Pour utiliser le référentiel de paramètres, consultez la documentation d'aide d'IntelliJ IDEA pour plus de détails sur le lien suivant : Référentiel de paramètres ". IDE. Pour ce faire, vous devez installer un plugin séparé : ouvrez les paramètres IDEA via Fichier -> Paramètres (Ctrl+Alt+S) et accédez à la section "Plugins". Pour trouver de nouveaux plugins, cliquez sur le bouton " ". Browse RepositoriesEnsuite trouvez le plug-in Eclipse Code Formatter dans la fenêtre de recherche. Après l'avoir installé, vous devrez redémarrer IDEA - c'est la procédure standard. Maintenant, tout est fait. Il y a une nouvelle section dans les paramètres IDEA : "Eclipse Code Formatter".. Cela ressemblera à ceci :

Des exigences plus strictes

En plus des outils IDEA, vous pouvez également utiliser des plugins d'automatisation de construction pour renforcer les exigences. Il n'y a aucun moyen de vérifier manuellement que quelqu'un a utilisé le bon formatage. Peut-être que vous pourriez avec 5 personnes dans une équipe. Mais avec 100 personnes dans une entreprise, ce n'est pas réaliste. Et même cinq seront difficiles à suivre. Et pourquoi perdre votre temps avec tout ça ? Il serait beaucoup plus facile d'empêcher la construction du projet si les règles sont violées. En fait, il s'agit d'un sujet à part entière appelé "Inspecter le code". Dans cet article, je veux juste vous montrer comment cela fonctionne. L'un des plugins Gradle les plus populaires (car il construit notre projet, vous vous en souviendrez) est pmd. Pour l'activer, allez simplement dans le script de construction de notre projet Gradle (le fichier build.gradle à la racine de notre projet) et ajoutez-y pmd à côté du reste des plugins :

 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'
 }

Nous pouvons maintenant saisir des paramètres plus détaillés au même endroit :

 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'
     ]
 }

Même notre projet est cassé maintenant. Exécutez gradle buildet nous obtenons une erreur. La bonne chose est qu'un rapport est généré pendant la construction. Et s'il y a des erreurs, nous recevons un message comme celui-ci :

 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

En allant au rapport, nous voyons quelque chose comme ceci : De plus, la Problemcolonne " " fournit un lien vers une description du problème sur le site Web du plugin pmd. Par exemple, pour l' headerCommentRequirement Requirederreur " ", le lien va ici : pmd — CommentRequired . Cette erreur est un indice que notre classe n'a pas de JavaDoc. Nous pouvons utiliser des modèles pour configurer un JavaDoc au-dessus des classes : Et spécifier le contenu pour le File Header: Après cela, nous pouvons transformer le commentaire au-dessus de la classe App en un JavaDoc et voir que l'erreur a disparu dans une nouvelle construction.

La ligne du bas

Le style de code est important pour maximiser la productivité d'un projet. Un beau code écrit selon des règles partagées garantit que vos collègues le comprendront plus facilement et plus rapidement et ne vous feront pas l'oreille de critiques. Avec les outils de développement modernes, il n'est pas si difficile de respecter les règles de style. J'espère que cette revue vous a prouvé que c'est vrai. Suivant la tradition, voici un peu de matériel supplémentaire sur le sujet :

• Vidéo de JetBrainsTV : " Inspecter le code (IntelliJ IDEA) "
• Examen de " Analyse de code avec les plugins Gradle "
• Formation " Automatiser la qualité du code "