L'évolution du composant Symfony Console a été un voyage de raffinement constant. Pendant des années, les développeurs se sont habitués au rituel d'extension de la classe Command, en mettant en œuvre le méthode pour définir les arguments et les options et placer leur logique à l'intérieur Il était robuste, déterministe et verbose. configure() execute() Avec l'avènement de la Symphonie 5 et 6, nous avons vu l'introduction des Commandes Invoquables - un changement de paradigme qui nous a permis de traiter les commandes plus comme des contrôleurs. La méthode est devenue le nouveau point d'entrée et le boilerplateau de commencé à s'évanouir, remplacé partiellement par des attributs PHP tels que Cependant, un point de friction est resté: la déconnexion entre la signature de la commande et le parsing d'entrée réel. ou en s'appuyant sur des configurations complexes pour cartographier les entrées vers les variables typées. __invoke() configure() #[AsCommand] $input->getArgument(‘…’) Symphony 7.4 change tout Lancé en novembre 2025, Symfony 7.4 introduit une suite d'améliorations de la qualité de vie pour le composant Console qui brise efficacement le fossé entre les commandes de la Console et les contrôleurs Http. , à via L’interactivité déclarative avec et L’écriture des outils CLI n’a jamais été aussi sécurisée ou expressive. Backed Enums Input DTOs #[MapInput] #[Interact] #[Ask] Dans ce guide complet, nous explorerons ces nouvelles fonctionnalités en profondeur.Nous réimprimerons une commande ancienne en un chef-d’œuvre moderne de Symfony 7.4, couvrant l’installation, la mise en œuvre, la vérification et les tests. Pré-requis et installation Avant de plonger dans le code, assurez-vous que votre environnement est prêt. 
 
 
 PHP 8.2 ou supérieur (PHP 8.4 recommandé pour un meilleur support de syntaxe). Composer installé mondialement. Pour suivre les exemples, il est nécessaire de créer un nouveau projet Symfony 7.4 ou de mettre à niveau un existant. Si vous commencez frais : composer create-project symfony/skeleton:^7.4 my_cli_app
cd my_cli_app
composer require symfony/console:^7.4
 Si vous mettez à niveau un projet existant, assurez-vous que votre vise explicitement la version 7.4 pour le composant de la console: composer.json {
    "require": {
        "php": ">=8.2",
        "symfony/console": "^7.4",
        "symfony/framework-bundle": "^7.4",
        "symfony/runtime": "^7.4"
    }
}
 Exécutez la commande mise à jour : composer update symfony/*
 Vérifiez votre version : php bin/console --version
# Output should look like: Symfony 7.4.x (env: dev, debug: true)
 Un soutien natif La Vieille Voie (Pre-7.4) Auparavant, le traitement des valeurs énumérées dans les commandes était un processus manuel. vous accepteriez un argument de chaîne, le valideriez manuellement contre une liste de valeurs autorisées, puis peut-être le cartographieriez-vous à un usage PHP Enum. // src/Command/LegacyServerCommand.php
namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:legacy-server')]
class LegacyServerCommand extends Command
{
    protected function configure(): void
    {
        $this->addArgument('region', InputArgument::REQUIRED, 'The server region (us, eu)');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $region = $input->getArgument('region');
        
        if (!in_array($region, ['us', 'eu'])) {
            $output->writeln('<error>Invalid region.</error>');
            return Command::FAILURE;
        }

        // Logic here...
        return Command::SUCCESS;
    }
}
 Cela fonctionne, mais il fuit la logique de validation dans le flux d'exécution et manque de sécurité de type. La Symphonie 7.4 Dans Symfony 7.4, le composant de la Console logique a été portée aux commandes. Vous pouvez désormais taper des arguments avec Symphony va automatiquement : ArgumentResolver Backed Enums 
 
 
 
 Lisez la chaîne d’entrée. Essayez de le cartographier à la valeur de soutien de l'Enum. Jetez une erreur descriptive si la valeur est invalide, en listant les options disponibles. Définissons d’abord notre Enum. // src/Enum/ServerRegion.php
namespace App\Enum;

enum ServerRegion: string
{
    case US = 'us-east-1';
    case EU = 'eu-central-1';
    case ASIA = 'ap-northeast-1';
}
 Maintenant la commande devient incroyablement simple : // src/Command/CreateServerCommand.php
namespace App\Command;

use App\Enum\ServerRegion;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\Argument; // Note: In 7.4 attributes are often simplified
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:create-server', description: 'Creates a server in a specific region.')]
class CreateServerCommand extends Command
{
    // The magic happens here: Type-hinting the Enum
    public function __invoke(
        OutputInterface $output, 
        #[Argument] ServerRegion $region
    ): int {
        $output->writeln(sprintf('Creating server in region: %s', $region->value));

        return Command::SUCCESS;
    }
}
 Essayez d'exécuter la commande avec une valeur invalide: php bin/console app:create-server mars
 La sortie : [ERROR] The value "mars" is not allowed for argument "region".
         Allowed values are: "us-east-1", "eu-central-1", "ap-northeast-1".
 Cette validation est "gratuite", strictement appliquée par le cadre avant même que votre code ne soit exécuté. Entrez des DTO avec #[MapInput] À mesure que vos commandes grandissent, vos La méthode peut se confondre avec des dizaines d’arguments et d’options. C’est l’odeur du code « Long Parameter List ». et maintenant la console suit avec . __invoke #[MapRequestPayload] #[MapInput] Cela vous permet d'extraire la définition d'entrée de votre commande dans un Objet de transfert de données dédié (DTO). La classe DTO Créez une classe PHP simple pour conserver vos données d'entrée. Utilisez des contraintes de validation standard si vous avez le composant Validator installé! // src/Dto/ServerInput.php
namespace App\Dto;

use App\Enum\ServerRegion;
use Symfony\Component\Console\Attribute\Argument;
use Symfony\Component\Console\Attribute\Option;
use Symfony\Component\Validator\Constraints as Assert;

class ServerInput
{
    #[Argument(description: 'The region to deploy to')]
    public ServerRegion $region;

    #[Option(description: 'The size of the instance')]
    #[Assert\Choice(['small', 'medium', 'large'])]
    public string $size = 'small';

    #[AsOption(name: 'dry-run', description: 'Simulate the creation')]
    public bool $dryRun = false;
}
 Le commandement réactif Maintenant, nous injectons ce DTO dans la commande en utilisant le des attributs. #[MapInput] // src/Command/DeployServerCommand.php
namespace App\Command;

use App\Dto\ServerInput;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\MapInput;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:deploy-server')]
class DeployServerCommand extends Command
{
    public function __invoke(
        OutputInterface $output,
        #[MapInput] ServerInput $input
    ): int {
        if ($input->dryRun) {
            $output->writeln('<info>Dry run enabled. No changes made.</info>');
        }

        $output->writeln(sprintf(
            'Deploying %s instance to %s...',
            $input->size,
            $input->region->value
        ));

        return Command::SUCCESS;
    }
}
 Pourquoi cela importe 
 
 
 
 Réutilisabilité: Vous pouvez réutiliser le DTO ServerInput dans d'autres services ou même des contrôleurs si elles sont correctement cartographiées. La logique de commande est séparée de la configuration des arguments et des options. Validation : Si vous utilisez symphonie/validateur, le DTO est automatiquement validé avant que __invoke ne soit appelé. Interaction déclarative avec #[Interact] et #[Ask] Les commandes interactives sont essentielles pour un bon DX, mais la mise en œuvre La méthode ressemblait souvent à l'écriture d'une seconde commande juste pour remplir les vides de la première. Symphony 7.4 introduit des attributs pour gérer cela de manière déclarative. interact() Le #[Ask] attribut Pour les cas simples où un argument manquant devrait induire l'utilisateur, utilisez . #[Ask] // src/Command/HelloCommand.php
namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\Argument;
use Symfony\Component\Console\Attribute\Ask; // New in 7.4
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:hello')]
class HelloCommand extends Command
{
    public function __invoke(
        OutputInterface $output,
        #[Argument, Ask(question: "What is your name?")] 
        string $name
    ): int {
        $output->writeln("Hello, $name!");
        return Command::SUCCESS;
    }
}
 Si l’utilisateur est en train de Le commandant s’arrêtera et demandera Si elles courent C’est lui qui détruit la promptitude. php bin/console app:hello « Quel est ton nom ? » php bin/console app:hello World L’attribut #[Interagir] Pour les interactions complexes (par exemple, des questions dynamiques basées sur des réponses antérieures), vous pouvez désormais marquer n'importe quelle méthode en tant que manipulateur d'interaction, en injectant et de façon automatique. InputInterface StyleInterface // src/Command/WizardCommand.php
namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\Interact;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

#[AsCommand(name: 'app:wizard')]
class WizardCommand extends Command
{
    protected function configure(): void
    {
        $this->addArgument('password', InputArgument::REQUIRED);
    }

    // This method is called automatically before __invoke if arguments are missing
    #[Interact]
    public function promptForPassword(InputInterface $input, SymfonyStyle $io): void
    {
        if (null === $input->getArgument('password')) {
            $password = $io->askHidden('Please enter your API password');
            $input->setArgument('password', $password);
        }
    }

    public function __invoke(OutputInterface $output, string $password): int
    {
        $output->writeln('Password received (hashed): ' . md5($password));
        return Command::SUCCESS;
    }
}
 Test des commandes invocables Symphony 7.4 assure que fonctionne en toute simplicité avec ces nouvelles abstractions. Les commandes de test qui utilisent des DTO ou des Enums ne nécessitent pas de configuration spéciale. CommandTester Le cas de test Nous allons tester le Nous avons créé auparavant. DeployServerCommand // tests/Command/DeployServerCommandTest.php
namespace App\Tests\Command;

use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Symfony\Component\Console\Tester\CommandTester;

class DeployServerCommandTest extends KernelTestCase
{
    public function testExecuteWithDto(): void
    {
        $kernel = self::bootKernel();
        $application = new Application($kernel);

        $command = $application->find('app:deploy-server');
        $commandTester = new CommandTester($command);

        $commandTester->execute([
            'region' => 'us-east-1', // Passing string, automatically converted to Enum
            '--size' => 'large',
            '--dry-run' => true,
        ]);

        $commandTester->assertCommandIsSuccessful();

        $output = $commandTester->getDisplay();
        $this->assertStringContainsString('Dry run enabled', $output);
        $this->assertStringContainsString('Deploying large instance to us-east-1', $output);
    }

    public function testInvalidEnumThrowsError(): void
    {
        $kernel = self::bootKernel();
        $application = new Application($kernel);
        $command = $application->find('app:deploy-server');
        $commandTester = new CommandTester($command);

        // We expect a runtime exception or validation error depending on configuration
        // In Console context, this usually results in a status code 1 and error output
        $this->expectException(\Throwable::class); 
        // Or inspect status code:
        // $exitCode = $commandTester->execute(['region' => 'mars']);
        // $this->assertNotSame(0, $exitCode);

        $commandTester->execute([
            'region' => 'mars', 
        ]);
    }
}
 Faites vos tests : php bin/phpunit tests/Command/DeployServerCommandTest.php
 Scénario du monde réel : un générateur de rapports complexes Combinons toutes les caractéristiques - , à et Imaginez une commande qui génère des rapports financiers. Enums DTOs Attributes Les Enums namespace App\Enum;

enum ReportFormat: string {
    case PDF = 'pdf';
    case CSV = 'csv';
    case JSON = 'json';
}

enum ReportPeriod: string {
    case DAILY = 'daily';
    case WEEKLY = 'weekly';
    case MONTHLY = 'monthly';
}
 L’entrée du DTO namespace App\Dto;

use App\Enum\ReportFormat;
use App\Enum\ReportPeriod;
use Symfony\Component\Console\Attribute\Argument;
use Symfony\Component\Console\Attribute\Option;
use Symfony\Component\Console\Attribute\Ask;

class ReportInput
{
    #[Argument(description: 'Type of report')]
    #[Ask('What type of report would you like to generate?')]
    public string $reportType;

    #[Option]
    public ReportPeriod $period = ReportPeriod::WEEKLY;

    #[Option]
    public ReportFormat $format = ReportFormat::PDF;

    #[AsOption(name: 'email', description: 'Email to send report to')]
    public ?string $recipientEmail = null;
}
 Le service Idéalement, votre logique est dans un service, pas la commande. namespace App\Service;

use App\Dto\ReportInput;

class ReportGenerator
{
    public function generate(ReportInput $input): void
    {
        // ... generation logic
    }
}
 Le commandement namespace App\Command;

use App\Dto\ReportInput;
use App\Service\ReportGenerator;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Attribute\Interact;
use Symfony\Component\Console\Attribute\MapInput;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

#[AsCommand(name: 'app:report:generate')]
class GenerateReportCommand extends Command
{
    public function __construct(
        private ReportGenerator $generator
    ) {
        parent::__construct();
    }

    #[Interact]
    public function interactRecipient(InputInterface $input, SymfonyStyle $io): void
    {
        // Only ask for email if not provided and format is PDF (business rule)
        // Accessing raw input here since mapping happens later
        if (null === $input->getOption('email') && 'pdf' === $input->getOption('format')) {
            $email = $io->ask('Enter recipient email for the PDF');
            $input->setOption('email', $email);
        }
    }

    public function __invoke(
        OutputInterface $output,
        #[MapInput] ReportInput $input
    ): int {
        $output->writeln("Starting {$input->period->value} report generation...");
        
        $this->generator->generate($input);
        
        $output->writeln("Report generated in {$input->format->value} format.");
        
        if ($input->recipientEmail) {
            $output->writeln("Sent to: {$input->recipientEmail}");
        }

        return Command::SUCCESS;
    }
}
 Cet exemple démontre la puissance de Symphony 7.4 : 
 
 
 
 Séparation des préoccupations : le ReportInput DTO gère la structure des données. le service gère la logique. le commandement gère l'interface CLI. Context-Aware Interactivity: La méthode #[Interact] permet des questions dynamiques (seulement en demandant un courrier électronique si le PDF est sélectionné) que les attributs purs ne peuvent pas facilement gérer. Sécurité de type: Nous ne validons jamais manuellement si le format $ est pdf ou csv. La coulée Enum le garantit. Conclusion En adoptant des attributs et des DTO, le cadre reconnaît que les commandes de la console sont des citoyens de première classe dans les applications modernes, méritant la même expérience de développeur (DX) que les contrôleurs HTTP. Key Takeaways: 
 
 
 
 Arrêtez le partage, commencez à déclarer : utilisez #[MapInput] et Enums pour permettre à Symfony de gérer l'hydratation et la validation des données. Nettoyez vos signatures : déplacez de longues listes d’arguments en DTO. Embrasser l'interaction déclarative: Utilisez #[Ask] pour les prompts simples et #[Interact] pour les flux complexes sans surpasser la logique de classe parentale. Ces changements réduisent la charge de chaudière, augmentent la testabilité et facilitent considérablement la lecture de votre code.Si vous n'avez pas encore mis à niveau vers Symfony 7.4, le composant Console amélioré seul est une raison convaincante pour faire le saut. Soyons en contact Êtes-vous prêt à moderniser vos outils CLI? Commencez par refactoring votre commande la plus complexe en utilisant  and share your experience. #[MapInput] If you found this guide helpful or have questions about specific edge cases, be in touch! You can find me on [LinkedIn] ( Abonnez-vous à la newsletter pour une plongée plus profonde dans l’écosystème de Symfony. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/ Joyeux code !

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

Écrivez des commandes symphoniques comme vous écrivez des contrôleurs - enfin

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Libérer la puissance de l’IA. Une revue systématique des techniques de pointe : résumé et introduction

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Libérer la puissance de l’IA. Une revue systématique des techniques de pointe : résumé et introduction

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps