Consola Artisan

• Introducción
  • Tinker (REPL)
• Escritura de comandos
  • Generación de comandos
  • Estructura del comando
  • Comandos basados en cierres
  • Comandos aislables
• Definición de expectativas de entrada
  • Argumentos
  • Opciones
  • Arrays de entrada
  • Descripciones de entrada
  • Solicitud de entrada faltante
• Entrada/Salida del comando
  • Recuperación de entrada
  • Solicitud de entrada
  • Escritura de salida
• Registro de comandos
• Ejecución programática de comandos
  • Llamada a comandos desde otros comandos
• Manejo de señales
• Personalización de plantillas
• Eventos

Introducción

Artisan es la interfaz de línea de comandos incluida con Laravel. Artisan existe en la raíz de tu aplicación como el script artisan y proporciona varios comandos útiles que pueden ayudarte mientras construyes tu aplicación. Para ver una lista de todos los comandos disponibles de Artisan, puedes usar el comando list:

php artisan list

Cada comando también incluye una pantalla de "ayuda" que muestra y describe los argumentos y opciones disponibles del comando. Para ver una pantalla de ayuda, antecede el nombre del comando con help:

php artisan help migrate

Laravel Sail

Si estás utilizando Laravel Sail como tu entorno de desarrollo local, recuerda usar el comando sail para invocar comandos de Artisan. Sail ejecutará tus comandos de Artisan dentro de los contenedores Docker de tu aplicación:

./vendor/bin/sail artisan list

Tinker (REPL)

Laravel Tinker es un potente REPL para el framework Laravel, impulsado por el paquete PsySH.

Instalación

Todas las aplicaciones de Laravel incluyen Tinker por defecto. Sin embargo, puedes instalar Tinker usando Composer si previamente lo has eliminado de tu aplicación:

composer require laravel/tinker

Nota ¿Buscas una interfaz gráfica de usuario para interactuar con tu aplicación Laravel? ¡Echa un vistazo a Tinkerwell!

Uso

Tinker te permite interactuar con toda tu aplicación Laravel en la línea de comandos, incluyendo tus modelos Eloquent, trabajos, eventos y más. Para entrar al entorno de Tinker, ejecuta el comando tinker de Artisan:

php artisan tinker

Puedes publicar el archivo de configuración de Tinker usando el comando vendor:publish:

php artisan vendor:publish --provider="Laravel\Tinker\TinkerServiceProvider"

Advertencia La función auxiliar dispatch y el método dispatch en la clase Dispatchable dependen de la recolección de basura para colocar el trabajo en la cola. Por lo tanto, al usar Tinker, debes usar Bus::dispatch o Queue::push para despachar trabajos.

Lista de permitidos del comando

Tinker utiliza una lista "allow" para determinar qué comandos de Artisan se pueden ejecutar dentro de su shell. Por defecto, puedes ejecutar los comandos clear-compiled, down, env, inspire, migrate, optimize y up. Si deseas permitir más comandos, puedes agregarlos al array commands en tu archivo de configuración tinker.php:

'commands' => [
    // App\Console\Commands\ExampleCommand::class,
],

Clases que no deben ser aliased

Normalmente, Tinker aliasa automáticamente clases a medida que interactúas con ellas en Tinker. Sin embargo, es posible que nunca desees aliasar algunas clases. Puedes lograr esto enumerando las clases en el array dont_alias de tu archivo de configuración tinker.php:

'dont_alias' => [
    App\Models\User::class,
],

Escritura de comandos

Además de los comandos proporcionados con Artisan, puedes crear tus propios comandos personalizados. Los comandos se suelen almacenar en el directorio app/Console/Commands; sin embargo, eres libre de elegir tu propia ubicación de almacenamiento siempre que tus comandos puedan cargarse mediante Composer.

Generación de comandos

Para crear un nuevo comando, puedes usar el comando Artisan make:command. Este comando creará una nueva clase de comando en el directorio app/Console/Commands. No te preocupes si este directorio no existe en tu aplicación; se creará la primera vez que ejecutes el comando Artisan make:command:

php artisan make:command SendEmails

Estructura del comando

Después de generar tu comando, debes definir valores apropiados para las propiedades signature y description de la clase. Estas propiedades se utilizarán al mostrar tu comando en la pantalla list. La propiedad signature también te permite definir las expectativas de entrada de tu comando. El método handle se llamará cuando se ejecute tu comando. Puedes colocar la lógica de tu comando en este método.

Veamos un ejemplo de comando. Observa que podemos solicitar cualquier dependencia que necesitemos a través del método handle del comando. El contenedor de servicios de Laravel inyectará automáticamente todas las dependencias que se indiquen en la firma de este método:

<?php
 
namespace App\Console\Commands;
 
use App\Models\User;
use App\Support\DripEmailer;
use Illuminate\Console\Command;
 
class SendEmails extends Command
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';
 
    /**
     * La descripción del comando de consola.
     *
     * @var string
     */
    protected $description = 'Enviar un correo electrónico de marketing a un usuario';
 
    /**
     * Ejecuta el comando de consola.
     */
    public function handle(DripEmailer $drip): void
    {
        $drip->send(User::find($this->argument('user')));
    }
}

Nota Para lograr una mayor reutilización de código, es una buena práctica mantener tus comandos de consola ligeros y dejar que se deleguen en los servicios de la aplicación para realizar sus tareas. En el ejemplo anterior, observa que inyectamos una clase de servicio para hacer el "trabajo pesado" de enviar los correos electrónicos.

Comandos basados en cierres

Los comandos basados en cierres proporcionan una alternativa para definir comandos de consola como clases. De la misma manera que los cierres de ruta son una alternativa a los controladores, piensa en los cierres de comando como una alternativa a las clases de comando. Dentro del método commands de tu archivo app/Console/Kernel.php, Laravel carga el archivo routes/console.php:

/**
 * Registra los comandos basados en cierres para la aplicación.
 */
protected function commands(): void
{
    require base_path('routes/console.php');
}

Aunque este archivo no define rutas HTTP, define puntos de entrada (rutas) basados en consola en tu aplicación. Dentro de este archivo, puedes definir todos tus comandos basados en cierres utilizando el método Artisan::command. El método command acepta dos argumentos: la firma del comando y un cierre que recibe los argumentos y opciones del comando:

Artisan::command('mail:send {user}', function (string $user) {
    $this->info("Enviando correo electrónico a: {$user}!");
});

El cierre está vinculado a la instancia de comando subyacente, por lo que tienes acceso completo a todos los métodos auxiliares a los que normalmente tendrías acceso en una clase de comando completa.

Tipado de dependencias

Además de recibir los argumentos y opciones de tu comando, los cierres de comando también pueden hacer type-hint a dependencias adicionales que desees resolver del contenedor de servicios:

use App\Models\User;
use App\Support\DripEmailer;
 
Artisan::command('mail:send {user}', function (DripEmailer $drip, string $user) {
    $drip->send(User::find($user));
});

Descripciones de comandos basados en cierres

Cuando defines un comando basado en cierres, puedes usar el método purpose para agregar una descripción al comando. Esta descripción se mostrará cuando ejecutes los comandos php artisan list o php artisan help:

Artisan::command('mail:send {user}', function (string $user) {
    // ...
})->purpose('Enviar un correo electrónico de marketing a un usuario');

Comandos aislables

Advertencia Para utilizar esta característica, tu aplicación debe estar utilizando el controlador de caché memcached, redis, dynamodb, database, file o array como controlador de caché predeterminado de tu aplicación. Además, todos los servidores deben estar comunicándose con el mismo servidor central de caché.

A veces, es posible que desees asegurarte de que solo se pueda ejecutar una instancia de un comando a la vez. Para lograrlo, puedes implementar la interfaz Illuminate\Contracts\Console\Isolatable en tu clase de comando:

<?php
 
namespace App\Console\Commands;
 
use Illuminate\Console\Command;
use Illuminate\Contracts\Console\Isolatable;
 
class SendEmails extends Command implements Isolatable
{
    // ...
}

Cuando un comando está marcado como Isolatable, Laravel agregará automáticamente una opción --isolated al comando. Cuando se invoque el comando con esa opción, Laravel se asegurará de que no haya otras instancias de ese comando ya en ejecución. Laravel logra esto intentando adquirir un bloqueo atómico utilizando el controlador de caché predeterminado de tu aplicación. Si hay otras instancias del comando en ejecución, el comando no se ejecutará; sin embargo, el comando aún saldrá con un código de estado de salida exitoso:

php artisan mail:send 1 --isolated

Si deseas especificar el código de estado de salida que debería devolver el comando si no puede ejecutarse, puedes proporcionar el código de estado deseado mediante la opción isolated:

php artisan mail:send 1 --isolated=12

ID de bloqueo

Por defecto, Laravel utilizará el nombre del comando para generar la clave de cadena que se utiliza para adquirir el bloqueo atómico en la caché de tu aplicación. Sin embargo, puedes personalizar esta clave definiendo un método isolatableId en tu clase de comando Artisan, lo que te permite integrar los argumentos u opciones del comando en la clave:

/**
 * Obtén el ID aislable para el comando.
 */
public function isolatableId(): string
{
    return $this->argument('user');
}

Tiempo de expiración del bloqueo

Por defecto, los bloqueos de aislamiento caducan después de que el comando haya terminado. O, si el comando se interrumpe y no puede terminar, el bloqueo caducará después de una hora. Sin embargo, puedes ajustar el tiempo de caducidad del bloqueo mediante la definición de un método isolationLockExpiresAt en tu comando:

use DateTimeInterface;
use DateInterval;
 
/**
 * Determina cuándo expira el bloqueo de aislamiento para el comando.
 */
public function isolationLockExpiresAt(): DateTimeInterface|DateInterval
{
    return now()->addMinutes(5);
}

Definición de expectativas de entrada

Al escribir comandos de consola, es común recopilar información del usuario a través de argumentos u opciones. Laravel facilita mucho la definición de la entrada que esperas del usuario utilizando la propiedad signature en tus comandos. La propiedad signature te permite definir el nombre, los argumentos y las opciones del comando en una sintaxis única y expresiva similar a la de las rutas.

Argumentos

Todos los argumentos y opciones proporcionados por el usuario se envuelven entre llaves. En el siguiente ejemplo, el comando define un argumento requerido: user:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user}';

También puedes hacer que los argumentos sean opcionales o definir valores predeterminados para los argumentos:

// Argumento opcional...
'mail:send {user?}'
 
// Argumento opcional con valor predeterminado...
'mail:send {user=foo}'

Opciones

Las opciones, al igual que los argumentos, son otra forma de entrada de usuario. Las opciones se prefijan con dos guiones (--) cuando se proporcionan a través de la línea de comandos. Hay dos tipos de opciones: aquellas que reciben un valor y aquellas que no. Las opciones que no reciben un valor sirven como un "interruptor" booleano. Veamos un ejemplo de este tipo de opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue}';

En este ejemplo, el interruptor --queue se puede especificar al llamar al comando Artisan. Si se pasa el interruptor --queue, el valor de la opción será true. De lo contrario, el valor será false:

php artisan mail:send 1 --queue

Opciones con valores

A continuación, veamos una opción que espera un valor. Si el usuario debe especificar un valor para una opción, debes agregar un signo = al final del nombre de la opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue=}';

En este ejemplo, el usuario puede pasar un valor para la opción de la siguiente manera. Si no se especifica la opción al invocar el comando, su valor será null:

php artisan mail:send 1 --queue=default

Puedes asignar valores predeterminados a las opciones especificando el valor predeterminado después del nombre de la opción. Si el usuario no pasa ningún valor de opción, se utilizará el valor predeterminado:

'mail:send {user} {--queue=default}'

Atajos de opciones

Para asignar un atajo al definir una opción, puedes especificarlo antes del nombre de la opción y usar el carácter | como delimitador para separar el atajo del nombre completo de la opción:

'mail:send {user} {--Q|queue}'

Al invocar el comando en tu terminal, los atajos de opciones deben ir precedidos por un guion simple y no debe incluirse ningún carácter = al especificar un valor para la opción:

php artisan mail:send 1 -Qdefault

Arrays de entrada

Si deseas definir argumentos u opciones que esperen múltiples valores de entrada, puedes usar el carácter *. Primero, veamos un ejemplo que especifica dicho argumento:

'mail:send {user*}'

Al llamar a este método, los argumentos user se pueden pasar en orden a la línea de comandos. Por ejemplo, el siguiente comando establecerá el valor de user en un array con 1 y 2 como sus valores:

php artisan mail:send 1 2

Este carácter * se puede combinar con una definición de argumento opcional para permitir cero o más instancias de un argumento:

'mail:send {user?*}'

Arrays de opciones

Al definir una opción que espera múltiples valores de entrada, cada valor de opción pasado al comando debe ir precedido por el nombre de la opción:

'mail:send {--id=*}'

Un comando así se puede invocar pasando varios argumentos --id:

php artisan mail:send --id=1 --id=2

Descripciones de entrada

Puedes asignar descripciones a argumentos de entrada y opciones separando el nombre del argumento de la descripción mediante dos puntos. Si necesitas un poco más de espacio para definir tu comando, siéntete libre de distribuir la definición en varias líneas:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send
                        {user : El ID del usuario}
                        {--queue : Si el trabajo debe encolarse}';

Solicitud de entrada faltante

Si tu comando contiene argumentos obligatorios, el usuario recibirá un mensaje de error cuando no se proporcionen. Alternativamente, puedes configurar tu comando para preguntar automáticamente al usuario cuando falten argumentos obligatorios implementando la interfaz PromptsForMissingInput:

<?php
 
namespace App\Console\Commands;
 
use Illuminate\Console\Command;
use Illuminate\Contracts\Console\PromptsForMissingInput;
 
class SendEmails extends Command implements PromptsForMissingInput
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';
 
    // ...
}

Si Laravel necesita recopilar un argumento obligatorio del usuario, le pedirá automáticamente el argumento formulando inteligentemente la pregunta utilizando tanto el nombre del argumento como la descripción. Si deseas personalizar la pregunta utilizada para recopilar el argumento obligatorio, puedes implementar el método promptForMissingArgumentsUsing, devolviendo un array de preguntas indexadas por los nombres de los argumentos:

/**
 * Solicita los argumentos de entrada que faltan utilizando las preguntas devueltas.
 *
 * @return array
 */
protected function promptForMissingArgumentsUsing()
{
    return [
        'user' => '¿A qué ID de usuario debería llegar el correo?',
    ];
}

También puedes proporcionar texto de marcador de posición usando una tupla que contenga la pregunta y el marcador de posición:

return [
    'user' => ['¿A qué ID de usuario debería llegar el correo?', 'Ej. 123'],
];

Si deseas tener un control total sobre la pregunta, puedes proporcionar un cierre que debe preguntar al usuario y devolver su respuesta:

use App\Models\User;
use function Laravel\Prompts\search;
 
// ...
 
return [
    'user' => fn () => search(
        label: 'Buscar un usuario:',
        placeholder: 'Ej. Taylor Otwell',
        options: fn ($value) => strlen($value) > 0
            ? User::where('name', 'like', "%{$value}%")->pluck('name', 'id')->all()
            : []
    ),
];

Nota La documentación completa de Laravel Prompts incluye información adicional sobre las opciones de prompts disponibles y su uso.

Si deseas solicitar al usuario que seleccione o ingrese opciones, puedes incluir prompts en el método handle de tu comando. Sin embargo, si solo deseas pedir al usuario cuando también se le haya pedido automáticamente por argumentos faltantes, puedes implementar el método afterPromptingForMissingArguments:

use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use function Laravel\Prompts\confirm;
 
// ...
 
/**
 * Realiza acciones después de que al usuario se le haya solicitado los argumentos que faltan.
 *
 * @param  \Symfony\Component\Console\Input\InputInterface  $input
 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
 * @return void
 */
protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output)
{
    $input->setOption('queue', confirm(
        label: '¿Te gustaría poner en cola el correo?',
        default: $this->option('queue')
    ));
}

Entrada/Salida del comando

Recuperación de entrada

Mientras tu comando se esté ejecutando, es probable que necesites acceder a los valores de los argumentos y opciones aceptados por tu comando. Para hacerlo, puedes usar los métodos argument y option. Si un argumento u opción no existe, se devolverá null:

/**
 * Ejecuta el comando de consola.
 */
public function handle(): void
{
    $userId = $this->argument('user');
}

Si necesitas recuperar todos los argumentos como un array, llama al método arguments:

$arguments = $this->arguments();

Las opciones se pueden recuperar tan fácilmente como los argumentos usando el método option. Para recuperar todas las opciones como un array, llama al método options:

// Recupera una opción específica...
$queueName = $this->option('queue');
 
// Recupera todas las opciones como un array...
$options = $this->options();

Solicitud de entrada

Nota Laravel Prompts es un paquete de PHP para agregar formularios hermosos y amigables para el usuario a tus aplicaciones de línea de comandos, con funciones similares a las de un navegador, incluido el texto de marcador de posición y la validación.

Además de mostrar salida, también puedes pedir al usuario que proporcione entrada durante la ejecución de tu comando. El método ask solicitará al usuario con la pregunta dada, aceptará su entrada y luego devolverá la entrada del usuario de nuevo a tu comando:

/**
 * Ejecuta el comando de consola.
 */
public function handle(): void
{
    $name = $this->ask('¿Cuál es tu nombre?');
 
    // ...
}

El método secret es similar a ask, pero la entrada del usuario no será visible para ellos mientras escriben en la consola. Este método es útil al solicitar información sensible como contraseñas:

$password = $this->secret('¿Cuál es la contraseña?');

Solicitud de confirmación

Si necesitas preguntar al usuario por una simple confirmación de "sí o no", puedes usar el método confirm. Por defecto, este método devolverá false. Sin embargo, si el usuario ingresa y o yes en respuesta al mensaje, el método devolverá true.

if ($this->confirm('¿Deseas continuar?')) {
    // ...
}

Si es necesario, puedes especificar que la confirmación por defecto debería devolver true pasando true como segundo argumento al método confirm:

if ($this->confirm('¿Deseas continuar?', true)) {
    // ...
}

Autocompletado

El método anticipate se puede usar para proporcionar autocompletado para posibles opciones. El usuario aún puede proporcionar cualquier respuesta, independientemente de las sugerencias de autocompletado:

$name = $this->anticipate('¿Cuál es tu nombre?', ['Taylor', 'Dayle']);

Alternativamente, puedes pasar un cierre como segundo argumento al método anticipate. El cierre se llamará cada vez que el usuario escriba un carácter de entrada. El cierre debe aceptar un parámetro de cadena que contenga la entrada del usuario hasta ahora y devolver un array de opciones para el autocompletado:

$name = $this->anticipate('¿Cuál es tu dirección?', function (string $input) {
    // Devuelve opciones de autocompletado...
});

Preguntas de opción múltiple

Si necesitas dar al usuario un conjunto predefinido de opciones al hacer una pregunta, puedes usar el método choice. Puedes establecer el índice de matriz del valor predeterminado que se devolverá si no se elige ninguna opción pasando el índice como tercer argumento al método:

$name = $this->choice(
    '¿Cuál es tu nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex
);

Además, el método choice acepta cuarto y quinto argumentos opcionales para determinar el número máximo de intentos para seleccionar una respuesta válida y si se permiten selecciones múltiples:

$name = $this->choice(
    '¿Cuál es tu nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex,
    $maxAttempts = null,
    $allowMultipleSelections = false
);

Escritura de salida

Para enviar salida a la consola, puedes usar los métodos line, info, comment, question, warn y error. Cada uno de estos métodos utilizará colores ANSI apropiados para su propósito. Por ejemplo, mostraremos información general al usuario. Típicamente, el método info se mostrará en la consola como texto de color verde:

/**
 * Ejecuta el comando de consola.
 */
public function handle(): void
{
    // ...
 
    $this->info('¡El comando se ejecutó con éxito!');
}

Para mostrar un mensaje de error, usa el método error. El texto del mensaje de error suele mostrarse en rojo:

$this->error('¡Algo salió mal!');

Puedes usar el método line para mostrar texto simple y sin colores:

$this->line('Mostrar esto en la pantalla');

Puedes usar el método newLine para mostrar una línea en blanco:

// Escribe una sola línea en blanco...
$this->newLine();
 
// Escribe tres líneas en blanco...
$this->newLine(3);

Tablas

El método table facilita el formato correcto de varias filas/columnas de datos. Todo lo que necesitas hacer es proporcionar los nombres de las columnas y los datos de la tabla y Laravel calculará automáticamente el ancho y la altura apropiados de la tabla por ti: automáticamente calculará el ancho y la altura apropiados de la tabla por ti:

use App\Models\User;
 
$this->table(
    ['Nombre', 'Correo electrónico}'],
    User::all(['name', 'email'])->toArray()
);

Barras de progreso

Para tareas que llevan mucho tiempo, puede ser útil mostrar una barra de progreso que informe a los usuarios qué tan completa está la tarea. Usando el método withProgressBar, Laravel mostrará una barra de progreso y avanzará su progreso por cada iteración sobre un valor iterable dado:

use App\Models\User;
 
$users = $this->withProgressBar(User::all(), function (User $user) {
    $this->performTask($user);
});

A veces, es posible que necesites un control más manual sobre cómo avanza una barra de progreso. Primero, define el número total de pasos por los que iterará el proceso. Luego, avanza la barra de progreso después de procesar cada elemento:

$users = App\Models\User::all();
 
$bar = $this->output->createProgressBar(count($users));
 
$bar->start();
 
foreach ($users as $user) {
    $this->performTask($user);
 
    $bar->advance();
}
 
$bar->finish();

Nota Para opciones más avanzadas, consulta la documentación del componente Symfony Progress Bar.

Registro de comandos

Todos tus comandos de consola están registrados dentro de la clase App\Console\Kernel de tu aplicación, que es tu "núcleo de consola" de la aplicación. Dentro del método commands de esta clase, verás una llamada al método load del núcleo. El método load escaneará el directorio app/Console/Commands y registrará automáticamente cada comando que contenga con Artisan. Incluso eres libre de hacer llamadas adicionales al método load para escanear otros directorios en busca de comandos de Artisan:

/**
 * Registra los comandos para la aplicación.
 */
protected function commands(): void
{
    $this->load(__DIR__.'/Commands');
    $this->load(__DIR__.'/../Domain/Orders/Commands');
 
    // ...
}

Si es necesario, puedes registrar comandos manualmente agregando el nombre de la clase del comando a una propiedad $commands dentro de tu clase App\Console\Kernel. Si esta propiedad aún no está definida en tu núcleo, debes definirla manualmente. Cuando Artisan se inicia, todos los comandos enumerados en esta propiedad serán resueltos por el contenedor de servicios y registrados con Artisan:

protected $commands = [
    Commands\SendEmails::class
];

Ejecución programática de comandos

A veces, es posible que desees ejecutar un comando de Artisan fuera de la CLI. Por ejemplo, es posible que desees ejecutar un comando de Artisan desde una ruta o controlador. Puedes usar el método call en la fachada Artisan para lograr esto. El método call acepta como primer argumento el nombre de la firma o el nombre de la clase del comando, y como segundo argumento un array de parámetros del comando. Se devolverá el código de salida:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/user/{user}/mail', function (string $user) {
    $exitCode = Artisan::call('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);
 
    // ...
});

Alternativamente, puedes pasar el comando de Artisan completo al método call como una cadena:

Artisan::call('mail:send 1 --queue=default');

Paso de valores de matriz

Si tu comando define una opción que acepta un array, puedes pasar un array de valores a esa opción:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/mail', function () {
    $exitCode = Artisan::call('mail:send', [
        '--id' => [5, 13]
    ]);
});

Paso de valores booleanos

Si necesitas especificar el valor de una opción que no acepta valores de cadena, como la bandera --force en el comando migrate:refresh, debes pasar true o false como el valor de la opción:

$exitCode = Artisan::call('migrate:refresh', [
    '--force' => true,
]);

Encolado de comandos Artisan

Usando el método queue en la fachada Artisan, incluso puedes encolar comandos de Artisan para que se procesen en segundo plano por tus trabajadores de la cola. Antes de usar este método, asegúrate de haber configurado tu cola y estar ejecutando un escucha de la cola:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/user/{user}/mail', function (string $user) {
    Artisan::queue('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);
 
    // ...
});

Usando los métodos onConnection y onQueue, puedes especificar la conexión o cola a la que se debe despachar el comando de Artisan:

Artisan::queue('mail:send', [
    'user' => 1, '--queue' => 'default'
])->onConnection('redis')->onQueue('commands');

Llamada a comandos desde otros comandos

A veces, es posible que desees llamar a otros comandos desde un comando de Artisan existente. Puedes hacerlo usando el método call. Este método call acepta el nombre del comando y un array de argumentos / opciones del comando:

/**
 * Ejecuta el comando de consola.
 */
public function handle(): void
{
    $this->call('mail:send', [
        'user' => 1, '--queue' => 'default'
    ]);
 
    // ...
}

Si deseas llamar a otro comando de consola y suprimir toda su salida, puedes usar el método callSilently. El método callSilently tiene la misma firma que el método call:

$this->callSilently('mail:send', [
    'user' => 1, '--queue' => 'default'
]);

Manejo de señales

Como sabrás, los sistemas operativos permiten enviar señales a los procesos en ejecución. Por ejemplo, la señal SIGTERM es la forma en que los sistemas operativos solicitan a un programa que se cierre. Si deseas escuchar señales en tus comandos de consola de Artisan y ejecutar código cuando ocurran, puedes usar el método trap:

/**
 * Ejecuta el comando de consola.
 */
public function handle(): void
{
    $this->trap(SIGTERM, fn () => $this->shouldKeepRunning = false);
 
    while ($this->shouldKeepRunning) {
        // ...
    }
}

Para escuchar múltiples señales a la vez, puedes proporcionar un array de señales al método trap:

$this->trap([SIGTERM, SIGQUIT], function (int $signal) {
    $this->shouldKeepRunning = false;
 
    dump($signal); // SIGTERM / SIGQUIT
});

Personalización de plantillas

Los comandos make de la consola de Artisan se utilizan para crear diversas clases, como controladores, trabajos, migraciones y pruebas. Estas clases se generan utilizando archivos "stub" que se llenan con valores basados en tu entrada. Sin embargo, es posible que desees hacer pequeños cambios en los archivos generados por Artisan. Para lograr esto, puedes usar el comando stub:publish para publicar los "stubs" más comunes en tu aplicación para que puedas personalizarlos:

php artisan stub:publish

Los "stubs" publicados se encontrarán dentro de un directorio stubs en la raíz de tu aplicación. Cualquier cambio que realices en estos "stubs" se reflejará cuando generes sus clases correspondientes utilizando los comandos make de Artisan.

Eventos

Artisan despacha tres eventos al ejecutar comandos: Illuminate\Console\Events\ArtisanStarting, Illuminate\Console\Events\CommandStarting e Illuminate\Console\Events\CommandFinished. El evento ArtisanStarting se despacha inmediatamente cuando Artisan comienza a ejecutarse. Luego, el evento CommandStarting se despacha inmediatamente antes de que se ejecute un comando. Finalmente, el evento CommandFinished se despacha una vez que un comando termina de ejecutarse.