Je One-Stop Guide to Laravel Commands

In deze tijd is het normaal dat een ontwikkelaar een goed begrip heeft van consoles en hoe basiscommando's kunnen worden uitgegeven. Maar wat als u uw eigen aangepaste commando's zou kunnen coderen om uw workflow te verbeteren? Als we terugkijken naar Laravel 3, weet je misschien nog dat het taken bood. Taken waren zeer nuttig, maar kwamen nog steeds tekort voor complexere operaties. Gelukkig heeft Laravel 4 een verbeterde artisan die je leven als ontwikkelaar zoveel gemakkelijker maakt!

Wat is ambachtelijk?

Artisan is het opdrachtregelhulpprogramma dat is uitgebracht in Laravel 3.

Als u niet bekend bent met Laravel, bent u misschien niet op de hoogte van Artisan. Artisan is het opdrachtregelhulpprogramma dat is uitgebracht in Laravel 3. Als u andere frameworks hebt gebruikt, kunt u Artisan vergelijken met Oil in FuelPHP, ZFTool in Zend of de console in Symfony 2.

Artisan biedt veel nuttige opdrachten die u kunnen helpen bij het uitvoeren van verschillende taken, zoals het genereren van migraties of het publiceren van de activa van een pakket. Naast de ingebouwde opdrachten kunt u Artisan uitbreiden met uw eigen opdrachten.

Artisan's Foundations

Dit is waar Artisan zijn kracht put.

In Laravel 3 werd Artisan helemaal opnieuw geschreven door Taylor Otwell (Laravel's maker), dus het was vrij basic (hoewel nog steeds geweldig). Nu Laravel 4 op Composer is gebaseerd, kan het bestaande pakketten gebruiken die zijn ontwikkeld door andere briljante ontwikkelaars. Als gevolg hiervan is Laravel 4 nu afhankelijk van een groot aantal pakketten uit het Symfony-framework. Een van deze pakketten is de uitstekende Console Component.

Als we kijken naar de bron van de Artisan-toepassing op Verlichten \ Console \ Application, we kunnen zien dat de klasse zelf uitbreidt Symfony \ Component \ Console \ Application. Dit is waar Artisan zijn kracht put. Hoewel Artisan gebruikmaakt van Symfony's Console-component, zijn veel van de veelgebruikte methoden vloeiendere Laravel-achtige aliassen gegeven. Dus maak je geen zorgen, het voelt nog steeds alsof je je ontwikkelt met Laravel!

Veelgestelde vragen

Twee vragen duiken meestal op bij het ontwikkelen van een nieuwe opdracht.

V Waar moet ik opdrachten plaatsen?

Wanneer u een kopie van Laravel installeert, vindt u een voorgedefinieerde map op app / commando's. Deze map bevindt zich ook in de classmap van uw composer.json standaard. Dit betekent dat je, zodra je een commando hebt gemaakt, moet uitvoeren componist dump-autoload om een bijgewerkt autoload-bestand te genereren. Als u dat niet doet, ontvangt u fouten, waarbij u klaagt dat uw opdracht niet kan worden gevonden.

Als u een pakket ontwikkelt, moet u een map in uw pakketten maken src // map om uw opdrachten vast te houden. In de codebase Laravel 4 wordt deze map genoemd Troosten. Vergeet niet om ervoor te zorgen dat de map automatisch wordt geladen in uw pakketten composer.json.

V Hoe moet ik opdrachten benoemen?

In de codebase van Laravel 4 zijn alle opdrachten van achtervoegsels voorzien Commando, en zijn genoemd naar de taak die ze uitvoeren. Laten we bijvoorbeeld zeggen dat je een commando hebt dat je cache wist. U kunt deze opdracht een naam geven, CacheClearCommand.

Basisprincipes van een commando

Een opdracht zou één taak moeten uitvoeren. In de rest van dit artikel gaan we een user generator-commando ontwikkelen. Laten we de basis van een opdracht bekijken.

// app / commands / UserGeneratorCommand.php regel ('Welkom bij de gebruikersgenerator.');

Laravel kan deze boilerplate-code voor u genereren! Gewoon rennen:

$ php artisan commando: maak UserGeneratorCommand

Dit zal een skeletcommando creëren dat je kunt aanpassen, maar voor de doeleinden van deze tutorial zullen we het hele proces van het bouwen van een nieuwe opdracht doorlopen, zodat we elk stuk van het proces kunnen leren.

Commandienaam

Alle commando's moeten een naam geven. Deze naam wordt gebruikt om de opdracht vanuit de console uit te voeren en moet de taak beschrijven die door de opdracht wordt uitgevoerd. Hoewel er geen afspraak bestaat over hoe uw opdracht wordt genoemd, kunt u een van de volgende dingen overwegen: namespace: groep / command, namespace: command, of gewoon commando.

Commando beschrijving

Alle commando's moeten een beschrijving geven. De beschrijving wordt gebruikt bij het ophalen van een lijst met beschikbare opdrachten van Artisan en bij het bekijken van de helpdocumenten voor een opdracht. Beschrijvingen moeten een korte beschrijving geven van de taak die de opdracht uitvoert.

Als we onze console openen en een lijst met beschikbare opdrachten ophalen, kunnen we onze opdracht nog steeds niet zien.

$ php artisan list Laravel Framework versie 4.0.0 Gebruik: [options] command [arguments] Opties: --help -h Geef dit help-bericht weer. --quiet - q Geen berichten uitvoeren. --verbose -v Vergroot de breedsprakigheid van berichten. --version -V Geef deze applicatieversie weer. --ansi Forceer ANSI-uitvoer. --no-ansi Schakel ANSI-uitvoer uit. --no-interaction -n Stel geen interactieve vraag. --env De omgeving waarin de opdracht moet worden uitgevoerd. Beschikbare commando's: help Toont hulp voor een commandolijst Lijstenopdrachten migreren Voer de databasemigraties in Serveer de applicatie op de PHP development server tinker Interactie met uw applicatie workbench Creëer een nieuw pakket workbench asset asset: publiceer de assets van een package naar de openbare map auth auth: reminders Maak een migratie voor de opdracht commandoreferenties voor wachtwoordherinneringen: make Maak een nieuw Artisan-commando config config: publish Publiceer de configuratie van een pakket naar de controller van de toepassingscontroller: maak Een nieuwe vindingrijke controller maken db db: seed Zaad de database met recordsleutel sleutel: genereren Stel de toepassingscode in migreren migreren: install Maak de migratiemigratierosemigratie: maak Maak een nieuw migratiebestand migreren: vernieuwen Herstel en herhaal alle migraties migreren: reset Terugdraaien alle databasemigraties migreren: terugdraaien Terugdraaien van de laatste wachtrij voor wachtrij van databasemigratie : luister Luister naar een bepaalde wachtrij voor wachtrij: werk Verwerk de volgende taak in een wachtrijsessie sessie: tabel Maak een migratie voor de sessiedatabasetabel

Om ons nieuwe commando te registreren, open app / start / artisan.php en lees snel het standaardblok voor opmerkingen dat daarin staat. Wanneer we Artisan vanaf de console uitvoeren, is dit bestand inbegrepen; we zullen het gebruiken om onze commando's te booten. In dit bestand hebben we toegang tot een $ artisan variabele die werd aangegeven voordat het bestand werd opgenomen. Denk aan de Artisan-applicatieklasse waar we eerder naar keken? Degene die de Symfony Console-component heeft uitgebreid? Goed, $ artisan is een instantie van die klasse.

Laten we onze opdracht toevoegen om deze beschikbaar te maken in de console.

$ artisan-> add (nieuwe UserGeneratorCommand);

Of, als u de statische syntaxis verkiest:

Artisan :: add (nieuwe UserGeneratorCommand);

De toevoegen methode accepteert een opdrachtinstantie. Zodra onze opdracht is toegevoegd, kunnen we deze openen via de console.

$ php artisan user: generate Welkom bij de gebruikersgenerator.

De opdracht moet ook worden vermeld in de beschikbare opdrachten, evenals de helpinformatie.

$ php artisan list

$ php artisan user: generate --help Gebruik: user: genereer Opties: --help (-h) Toon dit help-bericht. --quiet (-q) Geen berichten uitvoeren. --verbose (-v) Vergroot de breedsprakigheid van berichten. --version (-V) Geef deze applicatieversie weer. --ansi Forceer ANSI-uitvoer. --no-ansi Schakel ANSI-uitvoer uit. --no-interaction (-n) Stel geen interactieve vraag. --env De omgeving waarin de opdracht moet worden uitgevoerd.

Als u fouten ontvangt, zorg er dan voor dat u loopt componist dump-autoload vanuit de root van uw toepassing, na het maken van de opdracht.

Gekleurde uitvoer

Het doorgeven van gekleurde tekst aan de console is een makkie in Artisan. Er zijn vier verschillende hulpmethoden om gekleurde ANSI-uitvoer te echoën.

$ this-> info ("Dit is wat informatie."); $ this-> comment ("Dit is een commentaar."); $ this-> vraag ("Dit is een vraag."); $ this-> error ("Dit is een fout.");

Opties en argumenten

Een opwindende nieuwe functie voor Artisan is de mogelijkheid om een commando met opties en argumenten te bieden.

argumenten

Argumenten zijn tekenreeksen die u doorstuurt naar een opdracht. Ze moeten aan een commando worden gegeven in de volgorde waarin ze zijn gedefinieerd. Overweeg het volgende commando:

$ php artisan user: genereer [naam] [email]

De naam argument moet worden opgegeven vóór de e-mail argument.

Argumenten kunnen als optioneel worden gedefinieerd.

opties

Opties zijn altijd optioneel, en worden voorafgegaan door twee streepjes, indien opgegeven.

$ php artisan user: generate --admin

Behalve dat het wordt gebruikt als Booleaanse switches, kan een optie worden geconfigureerd om een waarde of een reeks waarden te accepteren.

$ php artisan user: generate --name = Jason $ php artisan user: generate --role = user --role = editor

Opties en argumenten definiëren

Voordat we onze opties en argumenten definiëren, is het het beste om de vereiste Symfony-klassen te importeren (ze zijn lang en het zou lastig zijn om de hele tijd op te schrijven). De twee klassen die we nodig hebben zijn Symfony \ Component \ Console \ Input \ InputOption en Symfony \ Component \ Console \ Input \ InputArgument.

Boven onze klassenverklaring importeren we beide klassen.

// app / commands / UserGenerateCommand.php regel ('Welkom bij de gebruikersgenerator.');

Om de opties en argumenten te definiëren, moet u twee nieuwe methoden maken: getArguments en getOptions. Beide methoden retourneren een reeks argumenten of opties. Laten we onze opdracht accepteren a naam argument, en een leeftijd keuze.

// app / commands / UserGenerateCommand.php regel ('Welkom bij de gebruikersgenerator.'); // Haal de naamargumenten en de leeftijdsoptie uit de invoerexemplaar. $ name = $ this-> argument ('naam'); $ age = $ this-> optie ('age'); $ this-> regel ("$ name is $ age jaar oud.");  / ** * Verkrijg de console-opdrachtargumenten. * * @return array * / beschermde functie getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Verkrijg de console-opdrachtopties. * * @return array * / beschermde functie getOptions () return-array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user'));

Onthoud: Laravel kan al deze boilerplate-code voor u genereren. We doen het eenvoudig handmatig om elke regel in de klas te beoordelen.

Nu kunnen we een naam argument en een leeftijd optie van onze console.

$ php artisan user: produce Jason --age = 22 Jason is 22 jaar oud.

Beide argumenten en opties worden gedefinieerd als meerdimensionale matrices. Laten we de definities voor elk ervan eens nader bekijken.

Argumentdefinities

De arraydefinitie voor een argument accepteert vier sleutels, waarbij alleen de eerste (de naam van de argumenten) vereist is. De tweede sleutel is de argumentenmodus en zou dat ook moeten zijn InputArgument :: OPTIONEEL of InputArgument :: VERPLICHT. De derde is de beschrijving en de vierde sleutel is een standaardwaarde, als de modus is ingesteld op InputArgument :: OPTIONEEL.

Hier is een argument dat alle array-sleutels gebruikt.

array ('name', InputArgument :: OPTIONAL, 'Naam van de nieuwe gebruiker', 'Jason')

Optiedefinities

De arraydefinitie voor een optie accepteert vijf sleutels waarvan alleen de eerste (de naam van de optie) vereist is. De tweede sleutel is een snelkoppeling voor de optie (-een bijvoorbeeld). De derde is de optiemodus en kan een van de volgende waarden zijn: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, of InputOption :: VALUE_IS_ARRAY. De vierde sleutel is de optiebeschrijving en de vijfde sleutel is een standaardwaarde, als de modus dat niet is InputOption :: VALUE_NONE of InputOption :: VALUE_REQUIRED.

Hier is een optie, met behulp van alle array-toetsen.

array ('age', 'a', InputOption :: VALUE_OPTIONAL, 'Age of the new user', 22)

Je kunt ook het InputOption :: VALUE_IS_ARRAY modus met InputOption :: VALUE_REQUIRED of InputOption :: VALUE_OPTIONAL.

array ('role', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Roles of the new user', 'user')

Bevestigingen en vragen

Nog een andere opwindende nieuwe functie voor Artisan is de mogelijkheid om bevestiging te vragen of zelfs om de gebruiker een vraag te stellen. Dit maakt het ontwikkelen van interactieve opdrachten zo eenvoudig mogelijk.

bevestigingen

Gebruik makend van bevestigen, we kunnen een gebruiker een vraag stellen en deze bevestigen met "ja" of "nee". Laten we bevestigen dat de gebruiker zijn leeftijd correct heeft ingevoerd.

// app / commands / UserGenerateCommand.php regel ('Welkom bij de gebruikersgenerator.'); // Haal de naamargumenten en de leeftijdsoptie uit de invoerexemplaar. $ name = $ this-> argument ('naam'); $ age = $ this-> optie ('age'); if (! $ this-> confirm ("Ben je echt $ age jaar oud? [yes | no]", true)) $ this-> comment ('Then why did you say you were !?'); terug te keren;  $ this-> comment ("$ name is $ age years old.");  / ** * Verkrijg de console-opdrachtargumenten. * * @return array * / beschermde functie getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Verkrijg de console-opdrachtopties. * * @return array * / beschermde functie getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

De eerste parameter is de vraag die u wilt stellen en de tweede is de standaardwaarde als een gebruiker op enter komt zonder iets te typen.

vragen

Gebruik makend van vragen, we kunnen een gebruiker een vraag stellen en een reactie van hen verwachten. In plaats van onze opdracht te doden als de gebruiker aangeeft dat hij zijn leeftijd verkeerd heeft ingevoerd, vragen we hem om deze opnieuw in te voeren.

// app / commands / UserGenerateCommand.php regel ('Welkom bij de gebruikersgenerator.'); // Haal de naamargumenten en de leeftijdsoptie uit de invoerexemplaar. $ name = $ this-> argument ('naam'); $ age = $ this-> optie ('age'); // Bevestig dat de gebruiker zijn leeftijd correct heeft ingevoerd en als dat niet het geval is, zullen we // ze vragen het opnieuw in te voeren. if (! $ this-> confirm ("Ben je echt $ age jaar oud? [yes | no]", true)) $ age = $ this-> ask ('Dus hoe oud ben je dan?') ;  $ this-> comment ("$ name is $ age years old.");  / ** * Verkrijg de console-opdrachtargumenten. * * @return array * / beschermde functie getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Verkrijg de console-opdrachtopties. * * @return array * / beschermde functie getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Commando afhankelijkheden

Injectie door afhankelijkheid is een belangrijke stap om ervoor te zorgen dat uw code toetsbaar en toekomstbestendig is. Laten we onze opdracht een stap verder brengen door een modelinstantie te injecteren, zodat we de gebruiker kunnen genereren. We beginnen met het maken van een gebruikersinterface en een gebruikersmodel.

// app / models / UserInterface.php   Onze Gebruikersomgeving definieert geen enkele methode-implementatie, omdat dit slechts een voorbeeld is. Voor een toepassing in de echte wereld definieert u de methoden die u op uw model zou verwachten.
 
 // app / models / User.php  Nu dat we onze hebben Gebruiker model dat ons implementeert Gebruikersomgeving, we kunnen doorgaan met het instellen van onze afhankelijkheid in onze opdracht. Ik ga een beetje meer toevoegen aan ons genereren commando, en communiceren met de Gebruiker model dat is geïnjecteerd.
 // app / commands / UserGenerateCommand.php gebruiker = $ gebruiker;  / ** * Voer de opdracht console uit. * * @return void * / public function fire () $ this-> line ('Welkom bij de gebruikersgenerator.'); // Haal de naamargumenten en de leeftijdsoptie uit de invoerexemplaar. $ this-> user-> name = $ this-> argument ('name'); $ this-> user-> age = $ this-> optie ('age'); // Bevestig dat de gebruiker zijn leeftijd correct heeft ingevoerd en als dat niet het geval is, zullen we // ze vragen het opnieuw in te voeren. We blijven vragen totdat ze zeker zijn dat ze de juiste leeftijd hebben bereikt. $ correctAge = false; while (! $ correctAge) if (! $ this-> confirm ("Ben je echt $ this-> user-> age years old? [yes | no]", true)) $ this-> user- > age = $ this-> ask ('Dus hoe oud ben je dan?');  else $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('Wat is je favoriete framework?', 'Laravel'); $ this-> user-> website = $ this-> ask ('Wat is uw websiteadres?'); // Sla de gebruiker op in de database. $ This-> gebruiksvriendelijkheid> save (); // Rapporteer dat de gebruiker is opgeslagen. $ this-> info ("$ this-> user-> name is gegenereerd en opgeslagen.");  / ** * Verkrijg de console-opdrachtargumenten. * * @return array * / beschermde functie getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Verkrijg de console-opdrachtopties. * * @return array * / beschermde functie getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null)); 
 Het eerste dat opvalt is dat het commando nu een constructor heeft. Deze constructor accepteert een enkele parameter en we hebben een hint gegeven aan de Gebruikersomgeving, dus we weten dat de klasse die we krijgen de methoden implementeert die op de interface zijn gedefinieerd. Commandoconstructeurs moeten ook de bovenliggende constructor aanroepen.
 In de brand methode van het commando, we zijn direct de eigenschappen aan het toewijzen Gebruiker model exemplaar. We gebruiken ook een lus om de gebruiker te blijven vragen of hij zijn leeftijd correct heeft ingevoerd. Ten slotte wordt de gebruiker in de database opgeslagen en wordt naar de console geëxporteerd die de gebruiker heeft gegenereerd en opgeslagen.
 Maar wacht! Voordat we de opdracht kunnen gebruiken, moeten we een instantie van onze injecteren Gebruiker model-.
 // app / start / artisan.php $ user = nieuwe gebruiker; $ artisan-> add (nieuwe UserGeneratorCommand ($ user));
 Als u een database hebt ingesteld en correct hebt geconfigureerd, kunt u nu de opdracht uitvoeren en een nieuwe gebruiker in de database opslaan!
 
 Pakketopdrachten
 Als u een pakket in Laravel aan het ontwikkelen bent, wilt u misschien opdrachten toevoegen. Het registreren van opdrachten uit pakketten is meestal hetzelfde proces, behalve dat u de opdracht niet (of niet) toevoegt app / start / artisan.php. In plaats daarvan lost u ze met Artisan op vanuit uw pakketserviceprovider.
 // pad / naar / uw / PackageServiceProvider.php / ** * Registreer de serviceprovider. * * @return void * / public function register () $ this-> app ['command.package.command'] = $ this-> app-> share (function ($ app) retourneer nieuwe PackageCommand ($ app [ 'afhankelijkheid']);); $ This-> commando's ( 'command.package.command'); 
 De commando's methode kan elk aantal argumenten accepteren en zal de opdracht uit de toepassingscontainer oplossen wanneer Artisan wordt gestart.
 
 Conclusie
 Wanneer je Artisan vergelijkt in Laravel 4 met zijn tegenhanger Laravel 3, zul je snel merken dat de verbeteringen gigantisch zijn. Opdrachten kunnen nu worden gebonden aan de IoC-container en afhankelijkheidsinjectie omvatten, gekleurde ANSI-uitvoer leveren, argumenten en opties gebruiken en gebruikersinteractie aanvragen.
 De kracht van Artisan is, dankzij de Console-component van Symfony, ongelofelijk. Opdrachten gaan een grote rol spelen, terwijl we verder gaan - dus ga vroeg aan boord!



		
			
	   
	




Code