La evolución del componente de la consola Symfony ha sido un viaje de refinamiento consistente. Durante años, los desarrolladores se han acostumbrado al ritual de extender la clase de comandos, implementando la método para definir argumentos y opciones y colocar su lógica dentro Era robusto, determinista y verboso. configure() execute() Con la llegada de la Sinfonía 5 y 6, vimos la introducción de los comandos invocables, un cambio de paradigma que nos permitió tratar los comandos más como controladores. El método se convirtió en el nuevo punto de entrada y la boilerplate de comenzó a desaparecer, sustituido parcialmente por atributos PHP como Sin embargo, un punto de fricción permaneció: la desconexión entre la firma del comando y el análisis de entrada real. o dependiendo de configuraciones complejas para mapear las entradas a las variables tipificadas. __invoke() configure() #[AsCommand] $input->getArgument(‘…’) Sinfonía 7.4 cambia todo Lanzado en noviembre de 2025, Symfony 7.4 introduce una serie de mejoras de calidad de vida para el componente de la consola que puja eficazmente la brecha entre los comandos de la consola y los controladores Http. , de vía La interacción declarativa con y , la escritura de herramientas CLI nunca ha sido tan seguro de tipo o expresivo. Backed Enums Input DTOs #[MapInput] #[Interact] #[Ask] En esta guía completa, exploraremos estas nuevas características en profundidad. refactoremos un comando legado en una obra maestra moderna de Symfony 7.4, que cubre la instalación, implementación, verificación y pruebas. Requisitos y instalación Antes de sumergirse en el código, asegúrese de que su entorno esté listo. 
 
 
 PHP 8.2 o superior (PHP 8.4 recomendado para un mejor soporte de sintaxis). Composer instalado globalmente. Para seguir con los ejemplos, es necesario crear un nuevo proyecto Symfony 7.4 o actualizar uno existente. Si estás empezando fresco: composer create-project symfony/skeleton:^7.4 my_cli_app
cd my_cli_app
composer require symfony/console:^7.4
 Si está actualizando un proyecto existente, asegúrese de se dirige explícitamente a la versión 7.4 para el componente de consola: composer.json {
    "require": {
        "php": ">=8.2",
        "symfony/console": "^7.4",
        "symfony/framework-bundle": "^7.4",
        "symfony/runtime": "^7.4"
    }
}
 Executa el comando de actualización: composer update symfony/*
 Verifique su versión: php bin/console --version
# Output should look like: Symfony 7.4.x (env: dev, debug: true)
 Apoyo nativo enum El viejo camino (Pre-7.4) Anteriormente, el manejo de los valores enumerados en los comandos era un proceso manual.Usted aceptaría un argumento de cadena, lo validaría contra una lista de valores permitidos manualmente y luego tal vez lo mapearía a un uso de 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;
    }
}
 Esto funciona, pero leche la lógica de validación al flujo de ejecución y carece de seguridad de tipo. La Sinfonía 7.4 Way En Symfony 7.4, el componente de la consola la lógica se ha portado a comandos. Ahora puede escribir argumentos con Symfony será automáticamente: ArgumentResolver Backed Enums 
 
 
 
 Lea la cadena de entrada. Intenta mapearlo hasta el valor de respaldo de Enum. Arranque un error descriptivo si el valor es inválido, listando opciones disponibles. Definamos nuestro Enum primero. // 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';
}
 Ahora, el comando se vuelve increíblemente 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;
    }
}
 Try running the command with an invalid value: php bin/console app:create-server mars
 La salida: [ERROR] The value "mars" is not allowed for argument "region".
         Allowed values are: "us-east-1", "eu-central-1", "ap-northeast-1".
 Esta validación viene "gratuita", estrictamente aplicada por el marco antes de que su código incluso se ejecute. Introduce DTOs con #[MapInput] A medida que crecen tus órdenes, tu El método se puede confundir con docenas de argumentos y opciones. Este es el olor de código de "Lista de Parámetros Largos". y ahora la consola sigue el . __invoke #[MapRequestPayload] #[MapInput] Esto le permite extraer la definición de entrada de su comando en un Objeto de Transferencia de Datos dedicado (DTO). La clase DTO Cree una clase PHP simple para contener sus datos de entrada. Use restricciones de validación estándar si tiene el componente de validación instalado! // 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;
}
 El Comando Refactorizado Ahora injetamos este DTO en el comando utilizando el Los atributos. #[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;
    }
}
 ¿Por qué esto importa 
 
 
 
 Reusabilidad: Puede reutilizar el ServerInput DTO en otros servicios o incluso controladores si está mapeado correctamente. Legibilidad: La lógica de comandos está separada de la configuración de argumentos y opciones. Validación: Si utiliza simfonía/validador, el DTO se valida automáticamente antes de que se llame __invoke. Interacción declarativa con #[Interact] y #[Ask] Los comandos interactivos son vitales para un buen DX, pero implementar el El método a menudo se sentía como escribir un segundo comando sólo para llenar los vacíos del primero. Symfony 7.4 introduce atributos para manejar esto declarativamente. interact() El atributo #[Ask] Para casos simples en los que un argumento faltante debería animar al usuario, utilice . #[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 el usuario corre , el comando se detendrá y preguntará Si ellos corren Y eso despega la rapidez. php bin/console app:hello “¿Cuál es tu nombre?” php bin/console app:hello World El atributo #[Interact] Para interacciones complejas (por ejemplo, preguntas dinámicas basadas en respuestas anteriores), ahora puede marcar cualquier método como un manipulador de interacción, inyectando y de forma automática. 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;
    }
}
 Prueba de comandos invocables La simfonía 7.4 asegura que Funciona sin problemas con estas nuevas abstracciones.Testando comandos que usan DTOs o Enums no requiere una configuración especial. CommandTester El caso de la prueba Vamos a probar el Hemos creado antes. 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', 
        ]);
    }
}
 Realice sus pruebas: php bin/phpunit tests/Command/DeployServerCommandTest.php
 Escenario del mundo real: un generador de informes complejos Combinemos todas las características - , de y Imagina un comando que genera informes financieros. Enums DTOs Attributes Los 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';
}
 La entrada 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;
}
 El Servicio Idealmente, su lógica está en un servicio, no el comando. namespace App\Service;

use App\Dto\ReportInput;

class ReportGenerator
{
    public function generate(ReportInput $input): void
    {
        // ... generation logic
    }
}
 El Comando 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;
    }
}
 Este ejemplo demuestra el poder de Symfony 7.4: 
 
 
 
 Separación de Preocupaciones: El ReportInput DTO gestiona la estructura de datos. El Servicio gestiona la lógica. El Comando gestiona la interfaz CLI. Context-Aware Interactivity: El método #[Interact] permite preguntas dinámicas (sólo pidiendo correo electrónico si se selecciona PDF) que los atributos puros no pueden manejar fácilmente. Seguridad de tipo: Nunca validamos manualmente si el formato $ es pdf o csv. La fundición Enum lo garantiza. Conclusión Al adoptar atributos y DTOs, el marco reconoce que los comandos de la consola son ciudadanos de primera clase en las aplicaciones modernas, que merecen la misma experiencia de desarrollador (DX) que los controladores HTTP. Key Takeaways: 
 
 
 
 Deje de analizar, comience a declarar: Use #[MapInput] y Enums para permitir que Symfony maneje la hidratación y la validación de datos. Limpiar sus firmas: Mueve largas listas de argumentos a DTOs. Abrazar la interacción declarativa: Use #[Ask] para prompts simples y #[Interact] para flujos complejos sin sobrepasar la lógica de la clase madre. Estos cambios reducen la boilerplate, aumentan la probabilidad y hacen que su código sea significativamente más fácil de leer.Si aún no ha actualizado a Symfony 7.4, el componente mejorado de Console por sí solo es una razón convincente para hacer el salto. Vamos a estar en contacto ¿Estás listo para modernizar tus herramientas de CLI?Empieza refactorizando tu comando más complejo usando y compartir su experiencia. #[MapInput] Si usted ha encontrado esta guía útil o tiene preguntas sobre casos específicos de origen, póngase en contacto! Suscríbete a la newsletter para profundizar más en el ecosistema de Symfony. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/ ¡Happy Coding!

Read My Stories

Este audio es producido en el idioma original de la historia!

Escribe comandos de sinfonía como escribas controladores - finalmente

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps