Parlons de Laravel exécutant des scripts de ligne de commande

Cet article vous apporte des connaissances pertinentes sur Laravel, qui présente principalement les problèmes liés à l'exécution de scripts de ligne de commande. Il existe un répertoire séparé dans Laravel, qui est le répertoire Console, qui est utilisé pour stocker les fichiers de script. Jetons-y un coup d'œil ensemble, j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : Premiers pas avec Laravel

Nous avons vu qu'il existe un répertoire séparé dans Laravel, qui est le répertoire Console, qui est utilisé pour stocker les fichiers de script. Ce fichier de script fait généralement référence au script de ligne de commande que nous exécutons via la commande php, qui a une telle fonction dans de nombreux frameworks. Pour le développement d'applications modernes, certaines fonctions chronophages telles que les statistiques de données, l'exportation de données, le traitement des files d'attente et certains programmes d'exécution back-end automatisés doivent être exécutées à l'aide de ce script de ligne de commande.

Scripts fournis par défaut

Dans le répertoire du framework actuel, nous exécutons php artisan dans le répertoire racine et vous pouvez voir les informations d'aide en ligne de commande. Tous les scripts de ligne de commande existants sont répertoriés ici. Dans le premier article, nous sommes entrés en contact avec deux de ces commandes.

# php artisan key:generate
# php artisan serve

L'une de leurs fonctions est de générer une clé unique qui doit être utilisée pour le cache crypté, etc., et l'autre est d'exécuter un serveur simple qui l'accompagne. Nous pouvons voir dans le nom du script que le script peut être séparé par un :, et il y a de grandes catégories avant les deux-points, telles que cache:xxx Related et make:xxx Related. Le cache est lié au traitement de certaines informations du cache, tandis que make est lié à la création de certains fichiers dont nous avons besoin. Par exemple, pour créer un contrôleur, vous pouvez utiliser make:controller, et pour créer un modèle de données, vous pouvez utiliser make:model.

Concernant ces scripts intégrés par défaut, nous en apprendrons davantage lorsque nous connaîtrons le contenu pertinent.

Personnaliser un script

La personnalisation d'un script est très simple. Nous pouvons utiliser la commande make:command pour générer un script de ligne de commande.

# php artisan make:command test1
Console command created successfully.

À ce moment, un fichier test1.php apparaîtra dans le répertoire app/Console/Commands. Ouvrez ce fichier, nous devons apporter quelques modifications.

/**
 * The name and signature of the console command.
 *
 * @var string
 */
protected $signature = 'command:name';
/**
 * The console command description.
 *
 * @var string
 */
protected $description = 'Command description';

signature est utilisé pour définir le nom du script actuel, et description est utilisée pour définir la description du commentaire du script. Où sont-ils utilisés ? En fait, signature est le nom que nous devons utiliser lors de l'exécution de ce script via php artisan. Par exemple, si nous exécutons directement php artisan maintenant, nous verrons apparaître le script de ligne de commande exécutable suivant.

 command
  command:name         Command description

Bien sûr, utiliser ce nom par défaut n'est pas une bonne idée, nous pouvons donc modifier ces deux propriétés.

/**
 * The name and signature of the console command.
 *
 * @var string
 */
protected $signature = 'ZyBlog:Test1';
/**
 * The console command description.
 *
 * @var string
 */
protected $description = '硬核测试1';

Si nous exécutons à nouveau php artisan à ce moment-là, nous pouvons voir les informations que nous avons définies.

 ZyBlog
  ZyBlog:Test1         硬核测试1

C'est très simple d'exécuter ce script.

# php artisan ZyBlog:Test1

Bien sûr, nous n’avons encore rien fait, donc il n’y aura pas de sortie. Ensuite, nous avons combiné les paramètres de réception et les informations de sortie. Pour recevoir des paramètres, nous devons définir les paramètres et options que nous souhaitons recevoir en signature. Vous vous souvenez de l'article dont nous avons parlé précédemment sur la façon de recevoir les paramètres de script et les informations sur les options en PHP ? Laravel les a déjà encapsulées, vous n'avez donc pas besoin d'utiliser ces fonctions pour la réception et le traitement, utilisez-les simplement directement. Les étudiants qui ont besoin de réviser peuvent accéder à [Comment obtenir les paramètres de ligne de commande PHP] mp.weixin.qq.com/s/dFuGaM1JT… pour révision ou étude.

protected $signature = 'ZyBlog:Test1 {a=1} {--b=*}';
/**
 * Execute the console command.
 *
 * @return int
 */
public function handle()
{
    echo "欢迎进来测试！", PHP_EOL;
    print_r($this->arguments());
    // Array
    // (
    //     [command] => ZyBlog:Test1
    //     [a] => 1
    // )
    print_r($this->options());
    // Array
    // (
    //     [b] => Array
    //         (
    //             [0] => 2
    //         )
    
    //     [help] => 
    //     [quiet] => 
    //     [verbose] => 
    //     [version] => 
    //     [ansi] => 
    //     [no-ansi] => 
    //     [no-interaction] => 
    //     [env] => 
    // )
    echo $this->argument('a'); // 1
    print_r($this->option('b'));
    // Array
    // (
    //     [0] => 2
    // )
    return 0;
}

Dans la fonction handle(), nous pouvons écrire le code de fonction que le script actuel doit exécuter. Parmi eux, les informations sur les paramètres du script peuvent être reçues via arguments() et argument(), et les informations sur les options du script peuvent être reçues via options() et option(). Concernant les paramètres et options, nous les avons également expliqués dans des articles précédents, nous n’entrerons donc pas dans les détails ici. Tout est basé sur les bases.

Analyse du code source des options de paramètres

Pour les paramètres et les options, l'appel sous-jacent de Laravel est en fait le composant Console de symfony. Dans symfony/console/Input/ArgvInput.php, nous pouvons voir le code suivant.

public function __construct(array $argv = null, InputDefinition $definition = null)
{
    $argv = $argv ?? $_SERVER['argv'] ?? [];
    // strip the application name
    array_shift($argv);
    $this->tokens = $argv;
    parent::__construct($definition);
}
// ……………………
// ……………………
protected function parse()
{
    $parseOptions = true;
    $this->parsed = $this->tokens;
    while (null !== $token = array_shift($this->parsed)) {
        if ($parseOptions && '' == $token) {
            $this->parseArgument($token);
        } elseif ($parseOptions && '--' == $token) {
            $parseOptions = false;
        } elseif ($parseOptions && 0 === strpos($token, '--')) {
            $this->parseLongOption($token);
        } elseif ($parseOptions && '-' === $token[0] && '-' !== $token) {
            $this->parseShortOption($token);
        } else {
            $this->parseArgument($token);
        }
    }
}

Évidemment, dans Symfony, argv est également utilisé pour obtenir des paramètres et des options, puis ils sont placés dans des variables d'entrée et transmis. Cette variable d'entrée est très importante, et nous y entrerons également en contact plus tard lorsque nous connaîtrons le contenu lié à la requête. Plus tard, dans notre code d'exécution, c'est-à-dire en utilisant argument() ou option() dans la méthode handle() de Command, les données de cette entrée sont obtenues. Nous pouvons les voir grâce au débogage des points d'arrêt.

Alors, comment Laravel exécute-t-il la fonction handle() ? Tout d'abord, appelez le fichier laravel/framework/src/Illuminate/Foundation/Console/Kernel.php via le fichier artisan. Dans la méthode handle() dans Kernel.php, symfony/console/Application.php sera appelé, puis entrez. laravel/framework Exécutez la méthode execute() dans /src/Illuminate/Console/Command.php et appelez notre méthode handle() personnalisée via un rappel.

Notez qu'en bas de laravel/framework/src/Illuminate/Console/Command.php, la méthode dans console/command.php sous symfony est toujours appelée.

L'ensemble de la chaîne d'appel est très longue, mais on voit aussi clairement que notre Laravel est bien un shell basé sur Symfony. Et il n'y a pas que la ligne de commande. En termes de requêtes Web, Symfony joue toujours un rôle crucial au niveau inférieur.

Apprentissage recommandé : Tutoriel vidéo Laravel

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!