Refactorisation du code à l'aide des normes de qualité de code Composer et PHP

Au fil du temps, à mesure que le projet continue d'itérer et de changer, la plupart des ingénieurs logiciels finiront par avoir l'impression que le code qu'ils écrivent est dans un état désordonné. Ces codes sont difficiles à lire, à maintenir, à tester et à développer, ce qui pose beaucoup de problèmes lors du développement ultérieur.

Le développement de logiciels est un art et implique également beaucoup de science et de technologie. Dans le processus de création et de maintenance d'une large base de code, nous devons trouver des méthodes réalisables pour maintenir la lisibilité et la maintenabilité du code. Cet article explique comment utiliser les normes de qualité du code Composer et PHP pour refactoriser le code afin de résoudre les problèmes ci-dessus.

Qu'est-ce que Composer ?

Composer est un gestionnaire de packages en PHP qui utilise des fichiers JSON pour la configuration et télécharge les dépendances à partir de sources comme Packagist.

Dans le passé, nous aurions pu utiliser le téléchargement manuel du code de la bibliothèque. Cependant, cela ne fait que nous créer davantage de maux de tête, car nous devons suivre manuellement les dépendances et les emplacements des fichiers. Composer est conçu pour résoudre ce problème.

En utilisant Composer, il suffit de créer un fichier composer.json dans le répertoire racine du projet, incluant le nom et la version de la bibliothèque dont dépend le projet :

{
    "require": {
        "vendor/library": "1.0.0"
    }
}

Utilisez la commande "composer install" pour télécharger automatiquement toutes les dépendances dans l’élément du projet.

Composer peut charger des dépendances via un mécanisme de "chargement automatique" spécifique, nous permettant d'utiliser ces bibliothèques de manière flexible dans notre code.

Commandes communes de Composer :

• composer install : installer toutes les dépendances dans l'environnement local ;
• composer update : mettre à jour toutes les dépendances
• composer require : ajouter des bibliothèques dépendantes au projet ;
• composer delete : supprimer les bibliothèques dépendantes ; du projet.

Maintenant que nous avons compris l'utilisation de base de Composer, nous allons ensuite utiliser les normes de qualité du code PHP pour optimiser notre code.

Quelles sont les normes de qualité du code PHP ?

Les normes de qualité du code sont des règles de codage convenues utilisées pour garantir que notre code est facile à lire, à comprendre et à maintenir.

Pour les développeurs PHP, il existe deux normes de qualité de code couramment utilisées :

• PHP_CodeSniffer
• PHP-CS-Fixer

PHP_CodeSniffer analyse le code selon des règles spécifiques et affiche ensuite les mauvaises pratiques dans le code. Avant d'utiliser PHP_CodeSniffer, nous devons définir une règle conforme à nos normes de codage. Ces règles peuvent être des règles communautaires ou des règles que vous définissez vous-même. Vous pouvez afficher toutes les règles disponibles en utilisant la commande "phpcs -i".

phpcs /path/to/my/code --standard=PSR2

PHPCS-Fixer est un outil de formatage de code automatisé qui peut corriger automatiquement les erreurs grammaticales et les erreurs de formatage dans le code. PHP-CS-Fixer est un normalisateur automatisé qui peut corriger rapidement les erreurs de syntaxe et les erreurs de formatage dans votre code. Lorsque vous validez du code, vous pouvez intégrer PHP-CS-Fixer dans votre service d'intégration continue.

php-cs-fixer fix /path/to/my/code --rules=@Symfony --verbose

Comment utiliser les standards de qualité de code Composer et PHP pour la refactorisation de code ?

L'utilisation des normes de qualité de code Composer et PHP pour la refactorisation du code dans le projet peut rendre notre code plus facile à maintenir et à étendre.

Ensuite, nous prendrons un exemple de projet simple comme exemple pour démontrer comment utiliser les normes de qualité de code Composer et PHP pour la refactorisation de code.

Tout d'abord, créez un nouveau projet PHP et installez les dépendances à l'aide de Composer.

composer require predis/predis

Ici, nous utilisons Redis comme stockage de données externe. Predis est un client PHP pour Redis qui peut être facilement installé à l'aide de Composer.

require 'vendor/autoload.php';
$client = new PredisClient();

$key = 'foo';
$value = 'bar';
$client->set($key, $value);
echo $client->get($key); // 'bar'

Dans l'exemple de code ci-dessus, nous utilisons Predis pour nous connecter à Redis, définissons la valeur de la clé 'foo' sur 'bar' et obtenons la valeur de la clé. Cependant, ce code rencontrera quelques problèmes après l'avoir analysé avec PHP_CodeSniffer.

Ensuite, nous allons créer et utiliser une règle pour vérifier notre code :

<?xml version="1.0"?>
<ruleset name="Project">
    <description>Custom rule set for Project</description>
    <rule ref="PSR2">
        <exclude name="PSR2.Classes.PropertyDeclaration"/>
        <exclude name="PSR2.Methods.FunctionCallSignature"/>
        <exclude name="PSR2.ControlStructures.ElseIfDeclaration"/>
        <exclude name="PSR2.ControlStructures.SwitchDeclaration"/>
        <exclude name="PSR2.ControlStructures.ControlStructureSpacing"/>
    </rule>
    <rule ref="Generic.CodeAnalysis.MissingFunctionDocComment"/>
    <rule ref="Generic.Arrays.DisallowLongArraySyntax">
        <properties>
            <property name="bracketSpacing" type="integer" value="1"/>
        </properties>
    </rule>
    <rule ref="Generic.Formatting.DisallowMultipleStatements"/>
    <rule ref="Generic.Functions.FunctionCallArgumentSpacing"/>
    <rule ref="Generic.Functions.FunctionCallSpace">
        <exclude-detection name="array"/>
        <exclude-detection name="parenthesis"/>
    </rule>
    <rule ref="Generic.Files.LineLength">
        <properties>
            <property name="lineLimit" type="integer" value="120"/>
            <property name="absoluteLineLimit" type="integer" value="120"/>
            <property name="ignoreComments" type="boolean" value="false"/>
        </properties>
    </rule>
</ruleset>

Une fois que nous avons défini notre règle, nous pouvons exécuter PHP_CodeSniffer en utilisant la commande suivante :

vendor/bin/phpcs ./src --standard=./phpcs.xml

Cette commande analysera le répertoire "src" dans tout PHP coder et signaler les pratiques irrégulières. Ensuite, nous utiliserons PHP-CS-Fixer pour corriger automatiquement tous les problèmes.

vendor/bin/php-cs-fixer fix ./src

La commande ci-dessus corrigera automatiquement toutes les erreurs de codage et les problèmes de formatage en fonction des règles que nous avons définies.

Maintenant, nous exécutons PHP_CodeSniffer et il ne signalera aucun problème.

Nous avons réalisé un exemple de refactorisation de code à l'aide de Composer et des normes de qualité de code PHP. Nous pouvons automatiser ce processus en intégrant PHP_CodeSniffer et PHP-CS-Fixer dans notre système d'intégration continue.

Conclusion

Dans cet article, nous avons appris à utiliser les normes de qualité de code Composer et PHP pour la refactorisation de code. Ces outils nous aident à mieux organiser notre code et à garantir qu'il est de haute qualité et maintenable.

Bien que cet article n'aborde que quelques outils, il existe un écosystème complet qui peut nous aider à automatiser la refactorisation et les tests de code. Ces outils nous permettent de fournir plus rapidement du code de haute qualité tout en réduisant les erreurs et les problèmes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!