"Symfony Console" komponento evoliucija buvo nuoseklaus tobulinimo kelionė. argumentų ir variantų apibrėžimo metodas ir jų logikos pateikimas Tai buvo tvirtas, deterministinis ir verbas. configure() execute() Su Simfonijos 5 ir 6 atsiradimu mes matėme, kad buvo įvestos skambinamos komandos - paradigmos pasikeitimas, leidžiantis mums elgtis su komandomis labiau kaip su kontrolieriais. metodu tapo naujas įėjimo taškas ir katilinė plokštė pradėjo išnykti, iš dalies pakeistas PHP atributais, tokiais kaip Tačiau liko vienas trinties taškas: atjungimas tarp komandos parašo ir faktinio įvesties analizavimo. arba remiantis sudėtingomis konfigūracijomis, kad būtų galima perkelti įvestis į įvestus kintamuosius. __invoke() configure() #[AsCommand] $input->getArgument(‘…’) Simfonija 7.4 keičia viską Paskelbta 2025 m. Lapkričio mėn., „Symfony 7.4“ pristato „Console“ komponento gyvenimo kokybės patobulinimų rinkinį, kuris veiksmingai sumažina atotrūkį tarp „Console Commands“ ir „Http Controller“. , per ir deklaratyvi sąveika su ir , CLI įrankių rašymas niekada nebuvo toks saugus ar išraiškingas. Backed Enums Input DTOs #[MapInput] #[Interact] #[Ask] Šiame išsamiame vadovėlyje išsamiai išnagrinėsime šias naujas funkcijas. „Symfony 7.4“ šedevras, apimantis diegimą, įgyvendinimą, patikrinimą ir bandymus. Būtinos sąlygos ir įrengimas Prieš pasinerdami į kodą, įsitikinkite, kad jūsų aplinka yra paruošta. 
 
 
 PHP 8.2 arba aukštesnė (PHP 8.4 rekomenduojama geresnei sintaksės palaikymui). Kompozitorius įdiegtas visame pasaulyje. Būtina sekti pavyzdžiais, sukurti naują „Symfony 7.4“ projektą arba atnaujinti esamą. Jei norite pradėti šviežiai: composer create-project symfony/skeleton:^7.4 my_cli_app
cd my_cli_app
composer require symfony/console:^7.4
 Jei atnaujinate esamą projektą, įsitikinkite, kad jūsų aiškiai nukreiptas į 7.4 leidimą konsolės komponentui: composer.json {
    "require": {
        "php": ">=8.2",
        "symfony/console": "^7.4",
        "symfony/framework-bundle": "^7.4",
        "symfony/runtime": "^7.4"
    }
}
 Įveskite atnaujinimo komandą: composer update symfony/*
 Patikrinkite savo versiją: php bin/console --version
# Output should look like: Symfony 7.4.x (env: dev, debug: true)
 Native Enum parama Senasis kelias (Pre-7.4) Anksčiau išvardytų reikšmių tvarkymas komandose buvo rankinis procesas.Jūs priimtumėte eilutės argumentą, rankiniu būdu patvirtintumėte jį pagal leistinų reikšmių sąrašą ir galbūt nukopijuotumėte jį į PHP Enum naudojimą. // 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;
    }
}
 Tai veikia, tačiau į vykdymo srautą patenka patvirtinimo logika ir trūksta tipo saugumo. Simfonijos 7.4 kelias „Symfony 7.4“ konsolės komponento logika buvo perkelta į komandas. Dabar galite rašyti argumentus su Simfonija automatiškai: ArgumentResolver Backed Enums 
 
 
 
 Perskaitykite įvesties eilutę. Pabandykite jį nukreipti į „Enum“ palaikymo vertę. Išmeskite aprašomąją klaidą, jei reikšmė yra negaliojanti, nurodydami turimas parinktis. Pirmiausia apibrėžkime savo 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';
}
 Dabar komanda tampa neįtikėtinai paprasta: // 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;
    }
}
 Pabandykite paleisti komandą su negaliojančia verte: php bin/console app:create-server mars
 Išėjimai : [ERROR] The value "mars" is not allowed for argument "region".
         Allowed values are: "us-east-1", "eu-central-1", "ap-northeast-1".
 Šis patvirtinimas yra "nemokamas", griežtai vykdomas sistemos, kol jūsų kodas netgi vykdomas. Įveskite DTO su #[MapInput] Kai jūsų įsakymai auga, jūsų metodas gali būti supainiojamas su dešimtimis argumentų ir parinkčių. Tai yra „ilgo parametrų sąrašo“ kodo kvapas. ir dabar „Console“ seka su . __invoke #[MapRequestPayload] #[MapInput] Tai leidžia jums išgauti komandos įvesties apibrėžimą į specialų duomenų perdavimo objektą (DTO). The DTO Class Sukurkite paprastą PHP klasę, kad išlaikytumėte savo įvesties duomenis. Naudokite standartinius patvirtinimo apribojimus, jei įdiegėte "Validator" komponentą! // 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;
}
 Reaktyvinė komanda Dabar mes įvedame šį DTO į komandą, naudojant ir atributų. #[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;
    }
}
 Kodėl tai svarbu 
 
 
 
 Pakartotinis naudojimas: ServerInput DTO galite pakartotinai naudoti kitose paslaugose ar netgi valdikliuose, jei jie yra teisingai suplanuoti. Komandos logika yra atskirta nuo argumentų ir parinkčių konfigūracijos. Patvirtinimas: jei naudojate simfoniją / patvirtinimą, DTO automatiškai patvirtinamas prieš skambinant __invoke. Deklaracinė sąveika su #[Interaktyvus] ir #[Ask] Interaktyvios komandos yra gyvybiškai svarbios geram DX, tačiau metodas dažnai atrodė kaip rašyti antrą komandą tik užpildyti tuščias pirmojo. „Symfony 7.4“ įveda atributus, kad tai būtų tvarkomi deklaratyviai. interact() Atributas #[Ask] atributas Paprastais atvejais, kai trūkstamas argumentas turėtų paskatinti vartotoją, naudokite . #[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;
    }
}
 Jei vartotojas bėga Komanda sustojo ir paklausė. Jei jie bėga , it skips the prompt. php bin/console app:hello „Koks tavo vardas?“ php bin/console app:hello World #[Interaktyvus] atributas Sudėtingoms sąveikoms (pvz., dinamiškiems klausimams, pagrįstiems ankstesniais atsakymais), dabar galite pažymėti bet kurį metodą kaip sąveikos tvarkyklę, įpurškiant ir ir automatiškai. 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;
    }
}
 Išbandykite iškviestus komandas Simfonija 7.4 užtikrina, kad Testuojant komandas, kuriose naudojami DTO arba Enums, nereikia jokių specialių nustatymų. CommandTester Testavimo atvejis Mes išbandysime Mes sukūrėme anksčiau. 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', 
        ]);
    }
}
 Atlikite savo testus: php bin/phpunit tests/Command/DeployServerCommandTest.php
 Realaus pasaulio scenarijus: sudėtingas ataskaitų generatorius Pabandykime sujungti visas funkcijas - , ir Įsivaizduokite komandą, kuri generuoja finansines ataskaitas. Enums DTOs Attributes Įžymybės 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';
}
 Įvadas 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;
}
 Paslaugų Idealiu atveju jūsų logika yra paslauga, o ne komanda. namespace App\Service;

use App\Dto\ReportInput;

class ReportGenerator
{
    public function generate(ReportInput $input): void
    {
        // ... generation logic
    }
}
 Komandoje 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;
    }
}
 Šis pavyzdys demonstruoja „Symfony 7.4“ galią: 
 
 
 
 Susirūpinimo atskyrimas: „ReportInput DTO“ tvarko duomenų struktūrą. „Service“ tvarko logiką. „Command“ tvarko CLI sąsają. Konteksto suvokimo interaktyvumas: #[Interaktyvumo] metodas leidžia dinamiškus klausimus (tik paprašyti el. Pašto, jei yra pasirinktas PDF), kurių grynieji atributai negali lengvai tvarkyti. Tipo sauga: Mes niekada rankiniu būdu patvirtinti, jei $format yra pdf arba csv. Išvada Įgyvendinant atributus ir DTO, sistema pripažįsta, kad konsolės komandos yra pirmos klasės piliečiai šiuolaikinėse programose, nusipelno tos pačios kūrėjo patirties (DX) kaip HTTP kontrolieriai. Key Takeaways: 
 
 
 
 Nustokite analizuoti, pradėkite deklaruoti: Naudokite #[MapInput] ir „Enums“, kad „Symfony“ galėtų tvarkyti duomenų hidrataciją ir patvirtinimą. Išvalykite parašus: Perkelkite ilgus argumentų sąrašus į DTO. Apimkite deklaratyvią sąveiką: naudokite #[Ask] paprastoms užklausoms ir #[Interact] sudėtingoms srautams, nepažeidžiant pagrindinės klasės logikos. Šie pakeitimai sumažina katilo plokštę, padidina bandomumą ir daro jūsų kodą žymiai lengviau perskaityti. Būkime prisilietę Ar esate pasiruošę modernizuoti savo CLI įrankius?Pradėkite iš naujo atlikdami sudėtingiausią komandą Pasidalinkite savo patirtimi. #[MapInput] Jei manote, kad šis vadovas yra naudingas arba turite klausimų apie konkrečius krašto atvejus, susisiekite su manimi! Prenumeruokite naujienlaiškį, kad galėtumėte giliau pasinerti į „Symfony“ ekosistemą. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/ Laimingas kodavimas!

Read My Stories

Šis garso įrašas sukurtas originalia istorijos kalba!

Rašykite simfonines komandas, kaip rašote valdiklius – pagaliau

About Author

KOMENTARAI

PABAIGTI ŽYMES

ŠIS STRAIPSNIS BUVO PRISTATYMAS

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps