Ihr One-Stop-Leitfaden für Laravel-Befehle

In der heutigen Zeit ist es für einen Entwickler normal, Konsolen zu verstehen und grundlegende Befehle zu geben. Aber was wäre, wenn Sie Ihre eigenen benutzerdefinierten Befehle programmieren könnten, um Ihren Workflow zu verbessern? Wenn wir auf Laravel 3 zurückblicken, erinnern Sie sich vielleicht daran, dass es Aufgaben bot. Die Aufgaben waren äußerst hilfreich, wurden jedoch für komplexere Vorgänge immer noch als zu gering angesehen. Glücklicherweise packt Laravel 4 einen aufgemotzten Artisan, der Ihnen das Leben als Entwickler so viel einfacher macht!

Was ist Handwerker??

Artisan ist das Befehlszeilenprogramm, das in Laravel 3 veröffentlicht wurde.

Wenn Sie mit Laravel nicht vertraut sind, kennen Sie Artisan möglicherweise nicht. Artisan ist das Befehlszeilenprogramm, das in Laravel 3 veröffentlicht wurde. Wenn Sie andere Frameworks verwendet haben, können Sie Artisan mit Oil in FuelPHP, ZFTool in Zend oder der Konsole in Symfony 2 vergleichen.

Artisan bietet viele nützliche Befehle, mit denen Sie verschiedene Aufgaben ausführen können, z. B. zum Generieren von Migrationen oder zum Veröffentlichen von Paketassets. Neben den integrierten Befehlen können Sie Artisan um eigene Befehle erweitern.

Handwerker Stiftungen

Hier setzt Artisan seine Macht an.

In Laravel 3 wurde Artisan von Taylor Otwell (dem Schöpfer von Laravel) von Grund auf neu geschrieben, daher war es ziemlich einfach (obwohl immer noch großartig). Jetzt, da Laravel 4 auf Composer basiert, kann es vorhandene Pakete verwenden, die von anderen brillanten Entwicklern entwickelt wurden. Daher ist Laravel 4 nun auf zahlreiche Pakete aus dem Symfony-Framework angewiesen. Eines dieser Pakete ist die ausgezeichnete Konsolenkomponente.

Schauen wir uns die Quelle der Artisan-Anwendung an Illuminate \ Console \ Application, Wir können sehen, dass sich die Klasse selbst ausdehnt Symfony \ Component \ Console \ Application. Hier setzt Artisan seine Macht an. Obwohl Artisan die Console-Komponente von Symfony verwendet, wurden viele der gängigen Methoden flüssiger mit Laravel-ähnlichen Aliasnamen versehen. Machen Sie sich keine Sorgen, es wird sich immer noch so anfühlen, als ob Sie mit Laravel entwickeln würden!

Häufige Fragen

In der Regel werden zwei Fragen angezeigt, wenn Sie versuchen, einen neuen Befehl zu entwickeln.

F Wo soll ich Befehle eingeben??

Wenn Sie eine Kopie von Laravel installieren, finden Sie ein vordefiniertes Verzeichnis unter App / Befehle. Dieses Verzeichnis befindet sich auch im Classmap von deinem composer.json standardmäßig. Das heißt, sobald Sie einen Befehl erstellt haben, müssen Sie ihn ausführen composer dump-autoload um eine aktualisierte Autoload-Datei zu generieren. Wenn Sie dies nicht tun, erhalten Sie Fehler. Sie beschweren sich, dass Ihr Befehl nicht gefunden werden kann.

Wenn Sie ein Paket entwickeln, müssen Sie ein Verzeichnis in Ihren Paketen erstellen src // Verzeichnis für Ihre Befehle. In der gesamten Laravel 4-Codebase wird dieses Verzeichnis benannt Konsole. Denken Sie daran, dass das Verzeichnis automatisch in Ihre Pakete geladen wird composer.json.

F Wie soll ich Befehle benennen??

In der gesamten Laravel 4-Codebasis sind alle Befehle mit dem Suffix Befehl, und sind nach der Aufgabe benannt, die sie ausführen. Nehmen wir zum Beispiel an, Sie haben einen Befehl, der den Cache löscht. Sie können diesen Befehl benennen, CacheClearCommand.

Grundlagen eines Befehls

Ein Befehl sollte eine einzelne Aufgabe ausführen. Im weiteren Verlauf dieses Artikels werden wir einen Benutzergeneratorbefehl entwickeln. Sehen wir uns die Grundlagen eines Befehls an.

// app / command / UserGeneratorCommand.php line ('Willkommen beim Benutzergenerator.');

Laravel kann diesen Code für Sie generieren! Einfach ausführen:

$ php handwerklicher Befehl: UserGeneratorCommand erstellen

Dadurch wird ein Skelettbefehl erstellt, den Sie ändern können. Für die Zwecke dieses Lernprogramms erstellen wir jedoch einen von Grund auf neuen Befehl, sodass wir jeden Teil des Prozesses lernen können.

Befehlsname

Alle Befehle müssen einen Namen angeben. Dieser Name wird zum Ausführen des Befehls von der Konsole aus verwendet und sollte die Aufgabe beschreiben, die der Befehl ausführt. Es gibt zwar keine Konvention für die Benennung Ihres Befehls, Sie können jedoch eine der folgenden Möglichkeiten in Betracht ziehen: Namespace: Gruppe / Befehl, Namespace: Befehl, oder nur Befehl.

Befehlsbeschreibung

Alle Befehle müssen eine Beschreibung enthalten. Die Beschreibung wird beim Abrufen einer Liste verfügbarer Befehle von Artisan und beim Anzeigen der Hilfedokumente für einen Befehl verwendet. Beschreibungen sollten kurz die Aufgabe beschreiben, die der Befehl ausführt.

Wenn wir unsere Konsole öffnen und eine Liste der verfügbaren Befehle abrufen würden, können wir unseren Befehl immer noch nicht auflisten.

$ php artisan list Laravel Framework version 4.0.0 Verwendung: [Optionen] Befehl [Argumente] Optionen: --help -h Diese Hilfemeldung anzeigen. --quiet -q Keine Nachricht ausgeben. --verbose -v Erhöht die Ausführlichkeit von Nachrichten. --version -V Zeigt diese Anwendungsversion an. --ansi Force ANSI-Ausgabe. --no-ansi Deaktiviert die ANSI-Ausgabe. --no-interact -n Keine interaktive Frage stellen. --env Die Umgebung, unter der der Befehl ausgeführt werden soll. Verfügbare Befehle: help Zeigt die Hilfe für eine Befehlsliste an. Listet Befehle auf, die migriert werden. Ausführen der Datenbankmigrationsservices. Dient der Anwendung auf dem PHP-Entwicklungsserver. Tinker. Interaktion mit Ihrer Anwendungs-Workbench auth: erinnerungen Erstellen Sie eine Migration für den Befehl befehl mit der Tabelle der erinnerungstabelle: make Erstellen Sie einen neuen Artisan-Befehl config config: publish Veröffentlichen Sie die Konfiguration eines Pakets für den Controller des Anwendungscontrollers: make Erstellen Sie einen neuen Ressourcencontroller Schlüssel: Generieren Anwendungsschlüssel festlegen Migrieren Migrieren: Installieren Migrations-Repository erstellen Migrieren: Erstellen Neue Migrationsdatei erstellen Migrieren: Aktualisieren Alle Migrationen zurücksetzen und erneut ausführen Migrieren: Zurücksetzen Migrieren aller Datenbankmigrationen Migrieren: Rollback Rollback der letzten Warteschlange der Datenbankmigrationswarteschlange : listen Abhören einer bestimmten Warteschlange: work Verarbeitet den nächsten Job in einer Warteschlangensitzung session: table Erstellen Sie eine Migration für die Session-Datenbanktabelle

Um unseren neuen Befehl zu registrieren, öffnen Sie app / start / artisan.php und lesen Sie schnell den Standard-Kommentarblock, der sich dort befindet. Wenn wir Artisan von der Konsole aus ausführen, ist diese Datei enthalten. Wir werden es benutzen, um unsere Befehle zu booten. In dieser Datei haben wir Zugriff auf eine $ Handwerker Variable, die vor dem Einfügen der Datei deklariert wurde. Erinnern Sie sich an die Artisan-Anwendungsklasse, die wir zuvor angesehen haben? Der, der die Symfony Console-Komponente erweitert hat? Gut, $ Handwerker ist eine Instanz dieser Klasse.

Fügen Sie unseren Befehl hinzu, um ihn in der Konsole verfügbar zu machen.

$ artisan-> add (neuer UserGeneratorCommand);

Oder, wenn Sie die statische Syntax bevorzugen:

Artisan :: add (neuer UserGeneratorCommand);

Das hinzufügen Methode akzeptiert eine Befehlsinstanz. Sobald unser Befehl hinzugefügt wurde, können wir über die Konsole darauf zugreifen.

$ php handwerklicher Benutzer: Generiere Willkommen beim Benutzergenerator.

Der Befehl sollte auch in den verfügbaren Befehlen sowie in den Hilfeinformationen aufgeführt sein.

$ php Handwerkerliste

$ php Handwerker Benutzer: Generieren --help Verwendung: Benutzer: Generieren Optionen: --help (-h) Diese Hilfemeldung anzeigen. --quiet (-q) Keine Nachricht ausgeben. --verbose (-v) Erhöht die Ausführlichkeit von Nachrichten. --version (-V) Zeigt diese Anwendungsversion an. --ansi Force ANSI-Ausgabe. --no-ansi Deaktiviert die ANSI-Ausgabe. --no-interact (-n) Stellen Sie keine interaktiven Fragen. --env Die Umgebung, unter der der Befehl ausgeführt werden soll.

Wenn Sie Fehler erhalten, stellen Sie sicher, dass Sie ausgeführt werden composer dump-autoload von Ihrem Anwendungsstamm aus, nachdem Sie den Befehl erstellt haben.

Farbige Ausgabe

Das Ausgeben von farbigem Text an die Konsole ist in Artisan ein Kinderspiel. Es gibt vier verschiedene Hilfsmethoden, um die farbige ANSI-Ausgabe auszugeben.

$ this-> info ("Dies sind einige Informationen."); $ this-> comment ("Dies ist ein Kommentar."); $ this-> question ("Dies ist eine Frage."); $ this-> error ("Dies ist ein Fehler.");

Optionen und Argumente

Eine aufregende neue Funktion von Artisan ist die Möglichkeit, einen Befehl mit Optionen und Argumenten bereitzustellen.

Argumente

Argumente sind Zeichenfolgen, die Sie an einen Befehl senden. Sie müssen einem Befehl in der Reihenfolge übergeben werden, in der sie definiert sind. Betrachten Sie den folgenden Befehl:

$ php handwerklicher Benutzer: Generiere [Name] [E-Mail]

Das Name Argument muss vor dem angegeben werden Email Streit.

Argumente können als optional definiert werden.

Optionen

Optionen sind immer optional und mit zwei Bindestrichen versehen, sofern vorhanden.

$ php Handwerker: Generiere --admin

Neben der Verwendung als boolesche Schalter kann eine Option so konfiguriert werden, dass sie einen Wert oder ein Array von Werten akzeptiert.

$ php Handwerker Benutzer: Generiere --name = Jason $ Php Handwerker Benutzer: Generiere --role = Benutzer --role = Editor

Optionen und Argumente definieren

Bevor wir unsere Optionen und Argumente definieren, ist es am besten, die erforderlichen Symfony-Klassen zu importieren (sie sind lang und würden sich die ganze Zeit nur schwer schreiben lassen). Die zwei Klassen, die wir brauchen, sind Symfony \ Component \ Console \ Input \ InputOption und Symfony \ Component \ Console \ Input \ InputArgument.

Über unserer Klassendeklaration importieren wir beide Klassen.

// app / command / UserGenerateCommand.php line ('Willkommen beim Benutzergenerator.');

Um die Optionen und Argumente zu definieren, müssen Sie zwei neue Methoden erstellen: getArguments und getOptions. Beide Methoden geben ein Array von Argumenten oder Optionen zurück. Lassen Sie uns unseren Befehl dazu akzeptieren, a zu akzeptieren Name Argument und ein Alter Möglichkeit.

// app / command / UserGenerateCommand.php line ('Willkommen beim Benutzergenerator.'); // Rufen Sie die Namensargumente und die Option Alter von der Eingabeinstanz ab. $ name = $ this-> Argument ('Name'); $ age = $ this-> Option ('Alter'); $ this-> line ("$ name ist $ age Jahre alt.");  / ** * Ruft die Konsolenbefehlsargumente ab. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name des neuen Benutzers'),);  / ** * Ruft die Befehlsoptionen für die Konsole ab. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Alter des neuen Benutzers'));

Denken Sie daran: Laravel kann den gesamten Code für Sie generieren. Wir machen es einfach manuell, um jede Zeile in der Klasse zu überprüfen.

Jetzt können wir eine Name Argument und ein Alter Option von unserer Konsole.

$ php Handwerker-Benutzer: Jason generieren - Seite = 22 Jason ist 22 Jahre alt.

Sowohl Argumente als auch Optionen sind als mehrdimensionale Arrays definiert. Schauen wir uns die Definitionen für jeden einzelnen genauer an.

Argumentdefinitionen

Die Array-Definition für ein Argument akzeptiert vier Schlüssel, wobei nur der erste (der Name der Argumente) erforderlich ist. Der zweite Schlüssel ist der Argumentmodus und sollte beides sein InputArgument :: OPTIONAL oder InputArgument :: ERFORDERLICH. Der dritte ist die Beschreibung und der vierte Schlüssel ist ein Standardwert, wenn der Modus auf festgelegt ist InputArgument :: OPTIONAL.

Hier ist ein Argument, bei dem alle Array-Schlüssel verwendet werden.

array ('name', InputArgument :: OPTIONAL, 'Name des neuen Benutzers', 'Jason')

Optionsdefinitionen

Die Array-Definition für eine Option akzeptiert fünf Schlüssel, wobei nur der erste (der Name der Option) erforderlich ist. Die zweite Taste ist eine Abkürzung für die Option (-ein zum Beispiel). Der dritte ist der Optionsmodus und kann einen der folgenden Werte annehmen: Eingabeoption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, Eingabeoption :: VALUE_OPTIONAL, oder Eingabeoption :: VALUE_IS_ARRAY. Der vierte Schlüssel ist die Beschreibung der Optionen. Der fünfte Schlüssel ist ein Standardwert, wenn der Modus nicht ist Eingabeoption :: VALUE_NONE oder InputOption :: VALUE_REQUIRED.

Hier ist eine Option, die alle Array-Schlüssel verwendet.

array ('age', 'a', InputOption :: VALUE_OPTIONAL, 'Alter des neuen Benutzers', 22)

Sie können das auch kombinieren Eingabeoption :: VALUE_IS_ARRAY Modus mit InputOption :: VALUE_REQUIRED oder Eingabeoption :: VALUE_OPTIONAL.

array ('role', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Rollen des neuen Benutzers', 'Benutzer')

Bestätigungen und Fragen

Eine weitere aufregende neue Funktion von Artisan ist die Möglichkeit, eine Bestätigung anzufordern oder dem Benutzer sogar eine Frage zu stellen. Dies macht die Entwicklung interaktiver Befehle so einfach wie möglich.

Bestätigungen

Verwenden bestätigen, Wir können einem Benutzer eine Frage stellen und ihn entweder mit "Ja" oder "Nein" bestätigen. Bestätigen Sie, dass der Benutzer sein Alter richtig eingegeben hat.

// app / command / UserGenerateCommand.php line ('Willkommen beim Benutzergenerator.'); // Rufen Sie die Namensargumente und die Option Alter von der Eingabeinstanz ab. $ name = $ this-> Argument ('Name'); $ age = $ this-> Option ('Alter'); if (! $ this-> confirm ("Sind Sie wirklich $ age Jahre alt? [yes | no]", wahr)) $ this-> comment ('Warum haben Sie dann gesagt, dass Sie !?' waren); Rückkehr;  $ this-> comment ("$ name ist $ age Jahre alt.");  / ** * Ruft die Konsolenbefehlsargumente ab. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name des neuen Benutzers'),);  / ** * Ruft die Befehlsoptionen für die Konsole ab. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Alter des neuen Benutzers', null));

Der erste Parameter ist die Frage, die Sie stellen möchten, und der zweite ist der Standardwert, wenn ein Benutzer die Eingabetaste drückt, ohne etwas einzugeben.

Fragen

Verwenden Fragen, Wir können einem Benutzer eine Frage stellen und eine Antwort von ihm erwarten. Anstatt unseren Befehl zu beenden, wenn der Benutzer angibt, dass er sein Alter falsch eingegeben hat, bitten wir ihn, ihn erneut einzugeben.

// app / command / UserGenerateCommand.php line ('Willkommen beim Benutzergenerator.'); // Rufen Sie die Namensargumente und die Option Alter von der Eingabeinstanz ab. $ name = $ this-> Argument ('Name'); $ age = $ this-> Option ('Alter'); // Bestätigen Sie, dass der Benutzer sein Alter richtig eingegeben hat, und // wenn nicht, bitten wir ihn, ihn erneut einzugeben. if (! $ this-> confirm ("Sind Sie wirklich $ age Jahre alt? [yes | no]", true)) $ age = $ this-> ask ('Wie alt sind Sie dann?') ;  $ this-> comment ("$ name ist $ age Jahre alt.");  / ** * Ruft die Konsolenbefehlsargumente ab. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name des neuen Benutzers'),);  / ** * Ruft die Befehlsoptionen für die Konsole ab. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Alter des neuen Benutzers', null));

Befehlsabhängigkeiten

Abhängigkeitsinjektion ist ein wichtiger Schritt, um sicherzustellen, dass Ihr Code testbar und zukunftssicher ist. Nehmen wir unseren Befehl noch einen Schritt weiter, indem wir eine Modellinstanz einfügen, damit wir den Benutzer generieren können. Wir beginnen mit der Erstellung einer Benutzeroberfläche und eines Benutzermodells.

// app / models / UserInterface.php   Unsere Benutzeroberfläche Es werden keine Methodenimplementierungen definiert, da dies nur ein Beispiel ist. Für eine reale Anwendung würden Sie die Methoden definieren, die Sie für Ihr Modell erwarten würden.
 
 // app / models / User.php  Jetzt haben wir unsere Nutzer Modell implementieren unsere Benutzeroberfläche, Wir können unsere Abhängigkeit weiterhin in unserem Kommando einrichten. Ich füge unserem Generierungsbefehl etwas mehr hinzu und interagiere mit dem Nutzer Modell, das eingespritzt wird.
 // app / command / UserGenerateCommand.php Benutzer = $ Benutzer;  / ** * Führen Sie den Konsolenbefehl aus. * * @return void * / public function fire () $ this-> line ('Willkommen beim Benutzergenerator.'); // Rufen Sie die Namensargumente und die Option Alter von der Eingabeinstanz ab. $ this-> user-> name = $ this-> argument ('name'); $ this-> user-> age = $ this-> Option ('age'); // Bestätigen Sie, dass der Benutzer sein Alter richtig eingegeben hat, und // wenn nicht, bitten wir ihn, ihn erneut einzugeben. Wir fragen sie weiter, bis sie sicher sind, dass sie das richtige Alter erreicht haben. $ correctAge = falsch; while (! $ correctAge) if (! $ this-> confirm ("Sind Sie wirklich $ this-> user-> age Jahre alt? [yes | no]", true)) $ this-> user- > age = $ this-> ask ('Wie alt bist du dann?');  else $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('Was ist Ihr bevorzugtes Framework?', 'Laravel'); $ this-> user-> website = $ this-> ask ('Wie lautet Ihre Website-Adresse?'); // Speichern Sie den Benutzer in der Datenbank. $ this-> user-> save (); // Melden Sie, dass der Benutzer gespeichert wurde. $ this-> info ("$ this-> user-> name wurde generiert und gespeichert.");  / ** * Ruft die Konsolenbefehlsargumente ab. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name des neuen Benutzers'),);  / ** * Ruft die Befehlsoptionen für die Konsole ab. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Alter des neuen Benutzers', null)); 
 Das erste, was Sie beachten sollten, ist, dass der Befehl jetzt einen Konstruktor hat. Dieser Konstruktor akzeptiert einen einzelnen Parameter und wir haben den Typ angegeben Benutzeroberfläche, Wir wissen also, dass die Klasse, die wir erhalten, die auf der Schnittstelle definierten Methoden implementiert. Befehlskonstruktoren sollten auch den übergeordneten Konstruktor aufrufen.
 In dem Feuer Als Methode des Befehls weisen wir die Eigenschaften direkt auf der zu Nutzer Modellinstanz. Wir verwenden auch eine Schleife, um den Benutzer weiterhin zu fragen, ob er sein Alter korrekt eingegeben hat. Zuletzt wird der Benutzer in der Datenbank gespeichert und wir geben an die Konsole aus, dass der Benutzer generiert und gespeichert wurde.
 Aber warte! Bevor wir den Befehl verwenden können, müssen wir eine Instanz unseres Befehls einfügen Nutzer Modell-.
 // app / start / artisan.php $ user = neuer Benutzer; $ artisan-> add (neuer UserGeneratorCommand ($ user));
 Wenn Sie eine Datenbank eingerichtet und korrekt konfiguriert haben, sollten Sie jetzt den Befehl ausführen und einen neuen Benutzer in der Datenbank speichern können!
 
 Paketbefehle
 Wenn Sie ein Paket in Laravel entwickeln, möchten Sie möglicherweise Befehle einschließen. Das Registrieren von Befehlen aus Paketen ist im Wesentlichen derselbe Prozess, außer dass Sie den Befehl nicht hinzufügen (oder nicht hinzufügen können) app / start / artisan.php. Sie lösen sie stattdessen mit Artisan in Ihrem Paketdienstanbieter auf.
 // Pfad / zu / Ihrem / PackageServiceProvider.php / ** * Registrieren Sie den Dienstanbieter. * * @return void * / public function register () $ this-> app ['command.package.command'] = $ this-> app-> share (Funktion ($ app) neuen Paketbefehl zurückgeben ($ app [ 'Abhängigkeit']);); $ this-> -Befehle ('command.package.command'); 
 Das Befehle Die Methode kann eine beliebige Anzahl von Argumenten akzeptieren und löst den Befehl aus dem Anwendungscontainer aus, wenn Artisan gestartet wird.
 
 Fazit
 Wenn Sie Artisan in Laravel 4 mit seinem Gegenstück zu Laravel 3 vergleichen, werden Sie schnell feststellen, dass die Verbesserungen monumental sind. Befehle können jetzt an den IoC-Container gebunden werden und die Abhängigkeitseingabe einschließen, farbige ANSI-Ausgaben bereitstellen, Argumente und Optionen verwenden und Benutzerinteraktion anfordern.
 Die Leistungsfähigkeit von Artisan dank der Symfony Console-Komponente ist unglaublich. Kommandos werden eine große Rolle spielen, wenn wir vorankommen. Steigen Sie also frühzeitig ein!



		
			
	   
	




Code