Din One-Stop Guide till Laravel-kommandon

I denna dag och ålder är det ganska normalt att en utvecklare förstår konsoler och hur man utfärdar grundläggande kommandon. Men vad händer om du kan koda dina egna anpassade kommandon för att förbättra ditt arbetsflöde? Om vi ser tillbaka till Laravel 3, kanske du kommer ihåg att det erbjöd uppdrag. Uppgifterna var oerhört hjälpsamma, men blev fortfarande korta för mer komplexa operationer. Tack och lov, Laravel 4 packar en böjd upp hantverkare som kommer att göra ditt liv som utvecklare så mycket lättare!

Vad är Artisan?

Artisan är kommandoradsverktyget som släpptes i Laravel 3.

Om du inte är bekant med Laravel, kanske du inte är medveten om Artisan. Artisan är kommandoradsverktyget som släpptes i Laravel 3. Om du har använt andra ramar kan du jämföra Artisan till Oil in FuelPHP, ZFTool i Zend eller konsolen i Symfony 2.

Artisan erbjuder många användbara kommandon som kan hjälpa dig att utföra olika uppgifter, till exempel att generera migreringar eller publicera ett paketets tillgångar. Förutom de inbyggda kommandona kan du förlänga Artisan med egna kommandon.

Artisans Foundations

Det är här hantverkaren drar sin makt.

I Laravel 3, var artisan skriven från början av Taylor Otwell (Laravel skapare), så det var ganska grundläggande (även om det fortfarande var fantastiskt). Nu när Laravel 4 är Composer-baserad, kan den använda befintliga paket som utvecklats av andra briljanta utvecklare. Som ett resultat beror Laravel 4 nu på många paket från Symfony-ramverket. Ett av dessa paket är den utmärkta konsolkomponenten.

Om vi tittar på källan till artisan ansökan på Illuminate \ Console \ Application, vi kan se att klassen i sig sträcker sig Symfony \ Component \ Console \ Application. Det är här hantverkaren drar sin makt. Även om Artisan använder sig av Symfony's Console-komponent, har många vanliga metoder fått mer flytande Laravel-liknande aliaser. Så oroa dig inte, det känns fortfarande som om du utvecklar dig med Laravel!

Vanliga frågor

Två frågor dyker upp automatiskt när man försöker utveckla ett nytt kommando.

Q Var ska jag lägga kommandon?

När du installerar en kopia av Laravel hittar du en fördefinierad katalog på app / kommandon. Den här katalogen finns också i classMap av din composer.json som standard. Det betyder att när du har skapat ett kommando måste du springa kompositör dump-autoload att generera en uppdaterad autoload-fil. Om du inte gör det får du fel och klagar på att ditt kommando inte kan hittas.

Om du utvecklar ett paket måste du skapa en katalog i dina paket src // katalog för att hålla dina kommandon. I hela Laravel 4-kodbasen heter denna katalog Trösta. Kom ihåg att se till att katalogen är autoloaded i dina paket composer.json.

Q Hur ska jag namnge kommandon?

I hela Laravel 4-kodbasen är alla kommandon suffixed med Kommando, och är uppkallade efter den uppgift de utför. Låt oss exempelvis säga att du har ett kommando som rensar cacheminnet. Du kan namnge det här kommandot, CacheClearCommand.

Grunderna i en kommando

Ett kommando ska utföra en enda uppgift. Under resten av denna artikel kommer vi att utveckla ett användargeneratorkommando. Låt oss granska grunderna för ett kommando.

// app / kommandon / UserGeneratorCommand.php linje ('Välkommen till användargenerator.');

Laravel kan generera den här boilerplate-koden för dig! Helt enkelt springa:

$ php artisan kommando: gör UserGeneratorCommand

Detta kommer att skapa ett skelettkommando för att du ska kunna ändra, men i den här handledningen kommer vi att gå igenom processen att bygga ett kommando från början, så att vi kan lära oss varje del av processen.

Kommandonamn

Alla kommandon måste ange ett namn. Detta namn används för att köra kommandot från konsolen och bör beskriva den uppgift som kommandot utför. Medan det inte finns någon konvention för hur ditt kommando heter, kan du överväga något av följande: namnutrymme: grupp / kommando, namespace: kommando, eller bara kommando.

Kommando Beskrivning

Alla kommandon måste ge en beskrivning. Beskrivningen används när man hämtar en lista med tillgängliga kommandon från Artisan, och när man tittar på hjälpdokumenten för ett kommando. Beskrivningar ska kort beskriva den uppgift som kommandot utför.

Om vi skulle öppna vår konsol och hämta en lista med tillgängliga kommandon, kan vi fortfarande inte se vårt kommando listat.

$ php hantverkslista Laravel Framework version 4.0.0 Användning: [options] command [arguments] Alternativ: --help -h Visa detta hjälpmeddelande. --quiet -q Skriv inte ut något meddelande. --verbose -v Öka volymen av meddelanden. --version -V Visa denna applikationsversion. --ansi Force ANSI-utgång. --no-ansi Inaktivera ANSI-utgång. - ingen interaktion -n Fråga inte någon interaktiv fråga. --env Miljön kommandot bör köras under. Tillgängliga kommandon: hjälp Visar hjälp för en kommandolista Listor kommandon migrerar Kör databasmigrationerna Servera applikationen på PHP-utvecklingsservern Tinker Interagera med din arbetsbänk Skapa en ny arbetsbänk för aktiva paket: publicera Publicera ett paketets tillgångar till den offentliga katalogen auth: påminnelser Skapa en migrering för kommandot kommandot lösenordsminnelser bordkommando: skapa Skapa ett nytt Artisan-kommando config: publicera Publicera en paketets konfiguration till programstyrenhetskontrollen: skapa Skapa en ny resursfull kontroller db db: frö Se databasen med registreringsnyckel tangent: generera Ställ in migrering av applikationsnyckeln: installera Skapa migreringsdatabasen migrera: skapa Skapa en ny migreringsfil migrera: uppdatera Återställ och återkör alla migreringar migrera: återställ Återställ alla databasmigreringar migrera: återuppringning Återställ den senaste databasens migreringskö : lyssna Lyssna på en given kökö: arbete Bearbeta nästa jobb i en kösession session: tabell Skapa en migrering för sessionsdatatabellen

För att registrera vårt nya kommando, öppna app / start / artisan.php och få en snabb läsning genom standardkommentationsblocket som finns där. När vi kör Artisan från konsolen ingår den här filen; Vi använder det för att starta upp våra kommandon. I den här filen har vi tillgång till en $ hantverkare variabel som deklarerades innan filen inkluderades. Kom ihåg den artisiska applikationsklassen som vi tittade på tidigare? Den som utvidgade komponenten Symfony Console? Väl, $ hantverkare är en förekomst av den klassen.

Låt oss lägga till vårt kommando för att göra det tillgängligt i konsolen.

$ artisan-> add (new UserGeneratorCommand);

Eller, om du föredrar den statiska syntaxen:

Artisan :: Lägg till (ny UserGeneratorCommand);

De Lägg till Metoden accepterar en kommandotinstans. När vårt kommando har lagts till kan vi komma åt det från konsolen.

$ php artisan användare: generera Välkommen till användargenerator.

Kommandot bör också anges i de tillgängliga kommandon, liksom hjälpinformationen.

$ php hantverkslista

$ php artisan användare: generera --hjälp Användning: användare: generera alternativ: --hjälp (-h) Visa detta hjälpmeddelande. --quiet (-q) Skriv inte ut något meddelande. --verbose (-v) Öka volymen av meddelanden. --version (-V) Visa denna applikationsversion. --ansi Force ANSI-utgång. --no-ansi Inaktivera ANSI-utgång. - ingen interaktion (-n) Fråga inte någon interaktiv fråga. --env Miljön kommandot bör köras under.

Om du får några fel, se till att du kör kompositör dump-autoload från dina program rot, efter att du skapat kommandot.

Färgad utgång

Utmatning av färgad text till konsolen är en film i Artisan. Det finns fyra olika hjälpar metoder för att echo färgad ANSI-utgång.

$ this-> info ("Detta är lite information."); $ this-> comment ("Detta är en kommentar."); $ this-> question ("Detta är en fråga."); $ this-> error ("Detta är ett fel.");

Alternativ och Argument

En spännande ny funktion för Artisan är förmågan att ge ett kommando med alternativ och argument.

Argument

Argument är strängar som du skickar genom till ett kommando. De måste ges till ett kommando i den ordning de definieras. Tänk på följande kommando:

$ php artisan användare: generera [namn] [email]

De namn argument måste anges före e-post argument.

Argument kan definieras som valfritt.

alternativ

Alternativen är alltid valfritt, och är prefixat med två streck, när de tillhandahålls.

$ php artisan användare: generera --admin

Förutom att användas som boolesiska omkopplare kan ett alternativ konfigureras för att acceptera ett värde eller en uppsättning värden.

$ php artisan användare: generera --name = Jason $ php artisan användare: generera --role = user --role = editor

Definiera alternativ och argument

Innan vi definierar våra alternativ och argument är det bäst att importera de nödvändiga Symfony-klasserna (de är långa och skulle vara en smärta att skriva ut hela tiden). De två klasserna vi behöver är Symfony \ Component \ Console \ Input \ InputOption och Symfony \ Component \ Console \ Input \ InputArgument.

Över vår klassdeklaration importerar vi båda klasserna.

// app / kommandon / UserGenerateCommand.php linje ('Välkommen till användargenerator.');

För att definiera alternativen och argumenten måste du skapa två nya metoder: getArguments och getOptions. Båda dessa metoder returnerar en rad argument eller alternativ. Låt oss göra vårt kommando acceptera a namn argument och an ålder alternativ.

// app / kommandon / UserGenerateCommand.php linje ('Välkommen till användargenerator.'); // Hämta namnet argument och åldersalternativet från inmatningsinstansen. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); $ this-> line ("$ name är $ age år gammal.");  / ** * Hämta konsolkommandot. * * @return array * / skyddad funktion getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Namn på den nya användaren'););  / ** * Hämta kommandon för konsolkommandon. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Ålder för den nya användaren'));

Kom ihåg: Laravel kan generera all denna kedjekodskod för dig. Vi gör det enkelt manuellt för att granska varje rad i klassen.

Nu kan vi erbjuda en namn argument och an ålder alternativ från vår konsol.

$ php artisan användare: generera Jason --age = 22 Jason är 22 år gammal.

Båda argumenten och alternativen definieras som multidimensionella arrays. Låt oss se närmare på definitionerna för var och en av dem.

Argument Definitioner

Arraydefinitionen för ett argument accepterar fyra nycklar, med endast den första (argumentsnamnet) som krävs. Den andra nyckeln är argumentläget och ska antingen vara InputArgument :: EXTRA eller InputArgument :: KRÄVS. Den tredje är beskrivningen, och den fjärde nyckeln är ett standardvärde, om läget är inställt på InputArgument :: EXTRA.

Här är ett argument med alla matrisnycklar.

array ('name', InputArgument :: OPTIONAL, 'Namn på den nya användaren', 'Jason')

Alternativ Definitioner

Arraydefinitionen för ett alternativ accepterar fem nycklar med endast det första (alternativnamnet) som krävs. Den andra nyckeln är en genväg för alternativet (-en till exempel). Den tredje är alternativläget och kan vara ett av följande värden: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, eller InputOption :: VALUE_IS_ARRAY. Den fjärde nyckeln är alternativbeskrivningen, och den femte nyckeln är ett standardvärde, om läget inte är det InputOption :: VALUE_NONE eller InputOption :: VALUE_REQUIRED.

Här är ett alternativ, med alla matrisnycklar.

array ('ålder', 'a', InputOption :: VALUE_OPTIONAL, 'Ålder för den nya användaren', 22)

Du kan också kombinera InputOption :: VALUE_IS_ARRAY läge med InputOption :: VALUE_REQUIRED eller InputOption :: VALUE_OPTIONAL.

array ('roll', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Roller of the new user', 'user')

Bekräftelser och Frågor

En annan spännande ny funktion för Artisan är dess förmåga att begära bekräftelse, eller till och med fråga användaren en fråga. Detta gör det möjligt att utveckla interaktiva kommandon så enkelt som möjligt.

bekräftelser

Använder sig av bekräfta, Vi kan fråga en användare en fråga och bekräfta dem med antingen "ja" eller "nej". Låt oss bekräfta att användaren har angivit sin ålder korrekt.

// app / kommandon / UserGenerateCommand.php linje ('Välkommen till användargenerator.'); // Hämta namnet argument och åldersalternativet från inmatningsinstansen. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); om ! $ this-> confirm ("Är du verkligen $ ålder år gammal? [ja | nej]", sant)) $ this-> comment ('Varför sa du att du var !?'); lämna tillbaka;  $ this-> comment ("$ name är $ ålder år gammal.");  / ** * Hämta konsolkommandot. * * @return array * / skyddad funktion getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Namn på den nya användaren'););  / ** * Hämta kommandon för konsolkommandon. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Den första parametern är den fråga som du skulle vilja fråga, och den andra är standardvärdet, om en användare träffar anger utan att skriva något.

frågor

Använder sig av fråga, Vi kan fråga en användare en fråga och förvänta sig ett svar från dem. I stället för att döda vårt kommando om användaren anger att de har angett sin ålder felaktigt, låt oss istället be dem komma in igen.

// app / kommandon / UserGenerateCommand.php linje ('Välkommen till användargenerator.'); // Hämta namnet argument och åldersalternativet från inmatningsinstansen. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); // Bekräfta att användaren angav sin ålder korrekt och om de inte har det ska vi // be dem att skriva in det igen. om ! $ this-> confirm ("Är du verkligen $ ålder år gammal? [ja | nej]", sant)) $ ålder = $ this-> ask ('Så hur gammal är du då?') ;  $ this-> comment ("$ name är $ ålder år gammal.");  / ** * Hämta konsolkommandot. * * @return array * / skyddad funktion getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Namn på den nya användaren'););  / ** * Hämta kommandon för konsolkommandon. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Kommandoförhållanden

Dependensinsprutning är ett viktigt steg för att säkerställa att din kod är testbar och framtida bevis. Låt oss ta vårt kommando ett steg längre genom att injicera en modellinstans så att vi kan generera användaren. Vi börjar med att skapa ett användargränssnitt och användarmodell.

// app / models / UserInterface.php   Vår Användargränssnitt definierar inte egentligen någon metodimplementering, eftersom detta bara är ett exempel. För en verklig applikation, definierar du de metoder du kan förvänta dig på din modell.
 
 // app / models / User.php  Nu när vi har vårt Användare modell som implementerar vår Användargränssnitt, Vi kan fortsätta att ställa in vårt beroende i vårt kommando. Jag ska lägga till lite mer till vårt generera kommando och interagera med Användare modell som injiceras.
 // app / kommandon / UserGenerateCommand.php user = $ user;  / ** * Kör konsolkommandot. * * @return void * / public function fire () $ this-> line ('Välkommen till användargenerator.'); // Hämta namnet argument och åldersalternativet från inmatningsinstansen. $ this-> user-> name = $ this-> argument ('name'); $ this-> user-> age = $ this-> option ('age'); // Bekräfta att användaren angav sin ålder korrekt och om de inte har det ska vi // be dem att skriva in det igen. Vi fortsätter att fråga dem tills de är / / säker på att de har gått rätt ålder. $ correctAge = false; medan ! $ correctAge if (! $ this-> confirm ("Är du verkligen $ this-> användare-> ålder år gammal? [ja | nej], sant)) $ this-> > ålder = $ this-> ask ('Så hur gammal är du då?');  annat $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('Vad är din favoritram?', 'Laravel'); $ this-> user-> website = $ this-> ask ('Vad är din webbplatsadress?'); // Spara användaren i databasen. $ This-> user-> save (); // Rapportera att användaren har sparats. $ this-> info ("$ this-> user-> name har skapats och sparats.");  / ** * Hämta konsolkommandot. * * @return array * / skyddad funktion getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Namn på den nya användaren'););  / ** * Hämta kommandon för konsolkommandon. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null)); 
 Det första du bör märka är att kommandot nu har en konstruktör. Denna konstruktör accepterar en enda parameter och vi har typen antydde Användargränssnitt, så vi vet att den klass vi får implementerar de metoder som definieras på gränssnittet. Kommandokonstruktörer borde också ringa förälderkonstruktören.
 I brand Metoden för kommandot, vi tilldelar direkt egenskaperna på Användare modell förekomst. Vi använder också en slinga för att fortsätta fråga användaren om de har fyllt sin ålder korrekt. Slutligen sparas användaren i databasen och vi matar ut till konsolen som användaren genererades och sparades.
 Men vänta! Innan vi kan använda kommandot, måste vi injicera en förekomst av vår Användare modell.
 // app / start / artisan.php $ user = new User; $ artisan-> add (ny UserGeneratorCommand ($ användare));
 Om du har en databasinstallation och konfigurerad på rätt sätt, borde du nu kunna köra kommandot och få en ny användare som sparats i databasen!
 
 Paketkommandon
 Om du utvecklar ett paket i Laravel kanske du vill inkludera kommandon. Registrering av kommandon från paket är oftast samma process, förutom att du inte (eller kan inte) lägga till kommandot i app / start / artisan.php. Istället löser du dem med Artisan från din paketleverantör.
 // path / to / your / PackageServiceProvider.php / ** * Registrera tjänsteleverantören. * * @return void * / offentligt funktionsregister () $ this-> app ['command.package.command'] = $ this-> app-> share (funktion ($ app) returnera nytt PackageCommand ($ app [ "beroende"]);); $ This-> kommandon ( 'command.package.command'); 
 De kommandon Metoden kan acceptera ett antal argument och löser kommandot ur applikationsbehållaren när artisan startas.
 
 Slutsats
 När du jämför Artisan i Laravel 4 till dess Laravel 3 motsvarighet, kommer du snabbt att upptäcka att förbättringarna är monumentala. Kommandon kan nu vara bundna till IoC-behållaren och inkludera beroendeinsprutning, ge färgad ANSI-utgång, använda argument och alternativ och begära användarinteraktion.
 Kunskapen från Artisan, tack vare Symfony's Console-komponent, är otroligt. Kommandon kommer att spela en stor roll, när vi går framåt - så ta ombord tidigt!



		
			
	   
	




Koda