Lassen Sie uns darüber sprechen, wie Laravel Befehlszeilenskripte ausführt

Dieser Artikel vermittelt Ihnen relevantes Wissen über Laravel, das hauptsächlich die Probleme im Zusammenhang mit der Ausführung von Befehlszeilenskripten vorstellt. Es gibt ein separates Verzeichnis in Laravel, das Konsolenverzeichnis, das zum Speichern von Skriptdateien verwendet wird. Schauen wir es uns gemeinsam an, ich hoffe, es wird für alle hilfreich sein.

Empfohlenes Lernen: Erste Schritte mit Laravel

Wir haben gesehen, dass es in Laravel ein separates Verzeichnis gibt, nämlich das Konsolenverzeichnis, in dem Skriptdateien gespeichert werden. Diese Skriptdatei bezieht sich im Allgemeinen auf das Befehlszeilenskript, das wir über den PHP-Befehl ausführen, der in vielen Frameworks eine solche Funktion hat. Für die moderne Anwendungsentwicklung müssen einige zeitaufwändige Funktionen wie Datenstatistik, Datenexport, Warteschlangenverarbeitung und einige automatisierte Back-End-Laufprogramme mit diesem Befehlszeilenskript ausgeführt werden.

Standardmäßig bereitgestellte Skripte

Im aktuellen Framework-Verzeichnis führen wir php artisan im Stammverzeichnis aus, und Sie können die Hilfeinformationen zur Befehlszeile sehen. Alle vorhandenen Befehlszeilenskripte werden hier aufgelistet. Im ersten Artikel sind wir mit zwei dieser Befehle in Berührung gekommen.

# php artisan key:generate
# php artisan serve

Eine ihrer Funktionen besteht darin, einen eindeutigen Schlüssel zu generieren, der für den verschlüsselten Cache usw. verwendet werden muss, und die andere darin, einen einfachen Server zu betreiben, der im Lieferumfang enthalten ist. Aus dem Skriptnamen können wir ersehen, dass das Skript durch ein : getrennt werden kann und vor dem Doppelpunkt große Kategorien stehen, wie zum Beispiel „cache:xxx bezogen“ und „make:xxx bezogen“. Cache bezieht sich auf die Verarbeitung einiger Cache-Informationen, während make sich auf die Erstellung einiger von uns benötigter Dateien bezieht. Um beispielsweise einen Controller zu erstellen, können Sie make:controller verwenden, und um ein Datenmodell zu erstellen, können Sie make:model verwenden.

Was diese standardmäßig integrierten Skripte betrifft, erfahren wir mehr darüber, wenn wir den relevanten Inhalt lernen.

Passen Sie ein Skript an

Das Anpassen eines Skripts ist sehr einfach. Wir können den Befehl make:command verwenden, um ein Befehlszeilenskript zu generieren.

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

Zu diesem Zeitpunkt wird eine test1.php-Datei im Verzeichnis app/Console/Commands angezeigt. Öffnen Sie diese Datei. Wir müssen einige Änderungen vornehmen.

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

Signatur wird verwendet, um den Namen des aktuellen Skripts festzulegen, und Beschreibung wird verwendet, um die Kommentarbeschreibung des Skripts zu definieren. Wo werden sie verwendet? Tatsächlich ist Signatur der Name, den wir verwenden müssen, wenn wir dieses Skript über PHP Artisan ausführen. Wenn wir jetzt beispielsweise php artisan direkt ausführen, wird das folgende ausführbare Befehlszeilenskript angezeigt.

 command
  command:name         Command description

Natürlich ist die Verwendung dieses Standardnamens keine gute Idee, daher können wir diese beiden Eigenschaften ändern.

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

Wenn wir php artisan zu diesem Zeitpunkt erneut ausführen, können wir die von uns definierten Informationen sehen.

 ZyBlog
  ZyBlog:Test1         硬核测试1

Es ist sehr einfach, dieses Skript auszuführen.

# php artisan ZyBlog:Test1

Natürlich haben wir noch nichts gemacht, daher wird es auch keinen Output geben. Als nächstes haben wir die Empfangsparameter und Ausgabeinformationen kombiniert. Um Parameter zu empfangen, müssen wir die Parameter und Optionen definieren, die wir in der Signatur erhalten möchten. Erinnern Sie sich an den Artikel über den Empfang von Skriptparametern und Optionsinformationen in PHP, über den wir zuvor gesprochen haben? Laravel hat diese bereits gekapselt, sodass Sie diese Funktionen nicht für den Empfang und die Verarbeitung verwenden müssen, sondern sie einfach direkt verwenden müssen. Studenten, die eine Wiederholung benötigen, können zur Wiederholung oder zum Studium zu [So erhalten Sie PHP-Befehlszeilenparameter] mp.weixin.qq.com/s/dFuGaM1JT… gehen.

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;
}

In der Funktion handle() können wir den Funktionscode schreiben, den das aktuelle Skript ausführen muss. Unter diesen können die Parameterinformationen des Skripts über arguments() und argument() empfangen werden, und die Optionsinformationen des Skripts können über options() und option() empfangen werden. Bezüglich der Parameter und Optionen haben wir diese ebenfalls in früheren Artikeln erläutert, daher gehen wir hier nicht auf Details ein. Alles basiert auf den Grundlagen.

Analyse des Quellcodes der Parameteroptionen

Für Parameter und Optionen ist der zugrunde liegende Aufruf von Laravel tatsächlich die Konsolenkomponente von Symfony. In symfony/console/Input/ArgvInput.php können wir den folgenden Code sehen.

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);
        }
    }
}

Offensichtlich wird argv in Symfony auch zum Abrufen von Parametern und Optionen verwendet, und diese werden dann in Eingabevariablen eingefügt und weitergegeben. Diese Eingabevariable ist sehr wichtig und wir werden später auch damit in Kontakt kommen, wenn wir anfragebezogene Inhalte lernen. Später werden in unserem Ausführungscode, also unter Verwendung von argument() oder option() in der handle()-Methode von Command, die Daten in dieser Eingabe abgerufen. Wir können sie beim Debuggen von Haltepunkten erkennen.

Wie führt Laravel die Funktion handle() aus? Rufen Sie zunächst die Datei laravel/framework/src/Illuminate/Foundation/Console/Kernel.php über die Datei artisan auf. In der Methode handle() in Kernel.php wird symfony/console/Application.php aufgerufen und dann eingegeben laravel/framework Führen Sie die Methode „execute()“ in /src/Illuminate/Console/Command.php aus und rufen Sie unsere angepasste Methode „handle()“ per Rückruf auf.

Beachten Sie, dass unten in laravel/framework/src/Illuminate/Console/Command.php immer noch die Methode in console/command.php unter Symfony aufgerufen wird.

Die gesamte Aufrufkette ist sehr lang, aber es ist deutlich zu erkennen, dass es sich bei unserem Laravel tatsächlich um eine Shell handelt, die auf Symfony basiert. Und es ist nicht nur die Befehlszeile, sondern Symfony spielt immer noch eine entscheidende Rolle auf der untersten Ebene.

Empfohlenes Lernen: Laravel-Video-Tutorial

Das obige ist der detaillierte Inhalt vonLassen Sie uns darüber sprechen, wie Laravel Befehlszeilenskripte ausführt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!