Ewolucja komponentu Symfony Console była podróżą konsekwentnego udoskonalenia. Przez lata deweloperzy przyzwyczaili się do rytuału rozszerzania klasy Command, wdrażania Metoda definiowania argumentów i opcji oraz umieszczenia ich logiki wewnątrz Był on solidny, deterministyczny i słowny. configure() execute() Wraz z pojawieniem się Symfonii 5 i 6 zobaczyliśmy wprowadzenie Invokable Commands – zmiany paradygmatu, która pozwoliła nam traktować polecenia bardziej jak kontrolery. Metoda ta stała się nowym punktem wejścia i kotłownią zniknął, częściowo zastąpiony przez atrybuty PHP, takie jak Jednak jeden punkt tarcia pozostał: odłączenie między podpisem polecenia a faktycznym analizowaniem danych wejściowych. lub poleganie na złożonych konfiguracjach do mapowania wejść do zmiennych typowanych. __invoke() configure() #[AsCommand] $input->getArgument(‘…’) Symfonia 7.4 zmienia wszystko Opublikowany w listopadzie 2025 roku Symfony 7.4 wprowadza zestaw ulepszeń jakości życia dla komponentu konsoli, które skutecznie pomijają przepaść między poleceniami konsoli a kontrolerami Http. , przez Deklaracja interakcji z i , pisanie narzędzi CLI nigdy nie było takie bezpieczne lub ekspresyjne. Backed Enums Input DTOs #[MapInput] #[Interact] #[Ask] W tym kompleksowym przewodniku szczegółowo przeanalizujemy te nowe funkcje, przekształcając tradycyjne polecenie w nowoczesne arcydzieło Symfony 7.4, obejmujące instalację, wdrażanie, weryfikację i testowanie. Warunki i instalacja Przed zanurzeniem się w kodzie upewnij się, że Twoje środowisko jest gotowe. 
 
 
 PHP 8.2 lub nowszy (PHP 8.4 zalecany dla lepszej obsługi syntaxowej). Kompozytor instalowany na całym świecie. Aby śledzić przykłady, konieczne jest stworzenie nowego projektu Symfony 7.4 lub uaktualnienie istniejącego. Jeśli chcesz zacząć świeżo: composer create-project symfony/skeleton:^7.4 my_cli_app
cd my_cli_app
composer require symfony/console:^7.4
 Jeśli modernizujesz istniejący projekt, upewnij się, że Ekspresowo kieruje się do wydania 7.4 dla komponentu konsoli: composer.json {
    "require": {
        "php": ">=8.2",
        "symfony/console": "^7.4",
        "symfony/framework-bundle": "^7.4",
        "symfony/runtime": "^7.4"
    }
}
 Uruchom polecenie Aktualizacja: composer update symfony/*
 Sprawdź swoją wersję: php bin/console --version
# Output should look like: Symfony 7.4.x (env: dev, debug: true)
 Wsparcie Native Enum Stary sposób (Pre-7.4) Wcześniej obsługa wymienionych wartości w poleceniach była procesem ręcznym.Akceptowałbyś argument wiersza, walidowałbyś go ręcznie w stosunku do listy dozwolonych wartości, a następnie prawdopodobnie mapowałbyś go do użycia w 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;
    }
}
 To działa, ale wycieka logikę walidacji do przepływu wykonywania i brakuje zabezpieczeń typu. Symfonia 7.4 sposób W Symfony 7.4 komponent konsoli logika została przeniesiona do poleceń. Możesz teraz wprowadzać argumenty wskazujące Symfony automatycznie: ArgumentResolver Backed Enums 
 
 
 
 Przeczytaj strunę wejściową. Spróbuj skopiować go do wartości wsparcia Enum. Wyrzuć błąd opisowy, jeśli wartość jest nieważna, wymieniając dostępne opcje. Najpierw zdefiniujmy nasz 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';
}
 Teraz polecenie staje się niesamowicie proste: // 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;
    }
}
 Spróbuj uruchomić polecenie z nieprawidłową wartością: php bin/console app:create-server mars
 Wydajność : [ERROR] The value "mars" is not allowed for argument "region".
         Allowed values are: "us-east-1", "eu-central-1", "ap-northeast-1".
 Ta walidacja jest „za darmo”, ściśle egzekwowana przez ramy, zanim nawet wykona kod. Wprowadź DTO z #[MapInput] W miarę jak rosną twoje polecenia, twoje Metoda może być zakłócona kilkudziesięciu argumentami i opcjami. Jest to zapach kodu „Długa lista parametrów”. a teraz konsola następuje zgodnie z . __invoke #[MapRequestPayload] #[MapInput] Pozwala to na wyodrębnienie definicji wprowadzania polecenia do dedykowanego obiektu transferu danych (DTO). Klasa DTO Stwórz prostą klasę PHP, aby zachować dane wejściowe.Użyj standardowych ograniczeń walidacyjnych, jeśli zainstalowany jest komponent Validator! // 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;
}
 Reaktywowane dowództwo Teraz wstrzykujemy ten DTO do polecenia za pomocą i atrybutów. #[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;
    }
}
 Why this matters 
 
 
 
 Możliwość ponownego użycia: Możesz ponownie użyć DTO ServerInput w innych usługach lub nawet kontrolerach, jeśli są prawidłowo mapowane. Czytelność: Logika polecenia jest oddzielona od konfiguracji argumentów i opcji. Walidacja: Jeśli używasz symfonii/walidatora, DTO jest automatycznie walidowane przed wywołaniem __invoke. Deklaracyjna interakcja z #[Interact] i #[Ask] Interaktywne polecenia są niezbędne dla dobrego DX, ale wdrażanie  method often felt like writing a second command just to fill in the blanks of the first one. Symfony 7.4 introduces attributes to handle this declaratively. interact() Atrakcje w pobliżu #[Ask] Attribute W prostych przypadkach, gdy brakujące argumenty powinny zachęcić użytkownika, użyj . #[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;
    }
}
 Jeśli użytkownik pobiegnie Komandor zatrzyma się i zapyta Jeśli biegną A to skraca prędkość. php bin/console app:hello „Jak się nazywasz?” php bin/console app:hello World Atrybut #[Interaktywny] atrybut W przypadku złożonych interakcji (np. dynamicznych pytań opartych na poprzednich odpowiedziach) można teraz zaznaczyć dowolną metodę jako manipulator interakcji, wprowadzając i i automatycznie. 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;
    }
}
 Testowanie wzywających poleceń Symfonia 7.4 zapewnia, że Testowanie poleceń używających DTO lub Enums nie wymaga specjalnego ustawienia. CommandTester Testowy przypadek Będziemy testować Stworzyliśmy je wcześniej. 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', 
        ]);
    }
}
 Wykonaj swoje testy: php bin/phpunit tests/Command/DeployServerCommandTest.php
 Scenariusz świata rzeczywistego: Kompleksowy generator raportów Łączmy wszystkie cechy - , i Wyobraź sobie polecenie, które generuje raporty finansowe. Enums DTOs Attributes Jednostki 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';
}
 Wejście 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;
}
 Usługa Idealnie, twoja logika jest w służbie, a nie polecenie. namespace App\Service;

use App\Dto\ReportInput;

class ReportGenerator
{
    public function generate(ReportInput $input): void
    {
        // ... generation logic
    }
}
 Dowództwo 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;
    }
}
 Poniższy przykład demonstruje moc Symfony 7.4: 
 
 
 
 Rozdzielenie problemów: ReportInput DTO obsługuje strukturę danych. Usługa obsługuje logikę. Komenda obsługuje interfejs CLI. Interaktywność kontekstowa: Metoda #[Interaktywność] pozwala na dynamiczne pytania (po prostu prosić o wiadomość e-mail, jeśli jest zaznaczony plik PDF), których czyste atrybuty nie mogą łatwo obsłużyć. Bezpieczeństwo typu: Nigdy nie weryfikujemy ręcznie, czy format $ jest pdf lub csv. konkluzji Przyjmując atrybuty i DTO, ramy uznają, że polecenia konsoli są obywatelami pierwszej klasy w nowoczesnych aplikacjach, zasługując na to samo doświadczenie dewelopera (DX) jak kontrolery HTTP. Key Takeaways: 
 
 
 
 Przestań analizować, zacznij deklarować: Użyj #[MapInput] i Enums, aby umożliwić Symfony obsługę nawilżania danych i walidacji. Wyczyść podpisy: Przenieś długie listy argumentów do DTO. Obejrzyj interakcje deklaratywne: Użyj #[Ask] dla prostych wskazówek i #[Interact] dla złożonych przepływów, nie przekraczając logiki klasy rodzicielskiej. Zmiany te zmniejszają pojemność kotła, zwiększają testowalność i znacznie ułatwiają czytanie kodu.Jeśli jeszcze nie uaktualniłeś do Symfony 7.4, sam ulepszony komponent konsoli jest przekonującym powodem, aby zrobić ten skok. Bądźmy w kontakcie Czy jesteś gotowy do modernizacji narzędzi CLI?Zacznij od refaktorowania najbardziej złożonych poleceń za pomocą i podzielić się swoim doświadczeniem. #[MapInput] Jeśli uważasz, że ten przewodnik jest przydatny lub masz pytania dotyczące konkretnych przypadków krawędzi, skontaktuj się ze mną! Zarejestruj się na newsletter, aby zagłębić się w ekosystem Symfony. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/ Szczęśliwy kod!

Read My Stories

Ten dźwięk jest produkowany w oryginalnym języku historii!

Napisz polecenia symfoniczne tak, jak napiszesz kontrolery – wreszcie

About Author

UWAGI

ZAWIEŚĆ TAGI

ARTYKUŁ TEN ZOSTAŁ PREZENTOWANY W

Related Stories

Reach More Readers! BOOST Your Story on HackerNoon

Meet the Writer: HackerNoon's Contributor Emmanuel Nwaka, Content Marketing Professional

How HackerNoon Feels About AI Generated Content (Hint: 👎🏽)

Meet Klink Finance: HackerNoon Company of the Week

Reach More Readers! BOOST Your Story on HackerNoon

Meet the Writer: HackerNoon's Contributor Emmanuel Nwaka, Content Marketing Professional

How HackerNoon Feels About AI Generated Content (Hint: 👎🏽)

Meet Klink Finance: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps