Din One-Stop Guide til Laravel Commands

I denne dag og alder er det ganske normalt at en utvikler har forståelse for konsoller, og hvordan man utsteder grunnleggende kommandoer. Men hva om du kunne kode dine egne tilpassede kommandoer for å forbedre arbeidsflyten din? Hvis vi ser tilbake til Laravel 3, kan du huske at det tilbød oppgaver. Oppgaver var ekstremt hjelpsomme, men kom fremdeles kort for mer kompliserte operasjoner. Heldigvis, Laravel 4 pakker en bøyd opp håndtverker som vil gjøre livet ditt som en utvikler så mye lettere!

Hva er Artisan?

Artisan er kommandolinjeverktøyet som ble utgitt i Laravel 3.

Hvis du ikke er kjent med Laravel, er du kanskje ikke klar over håndverkeren. Artisan er kommandolinjeverktøyet som ble utgitt i Laravel 3. Hvis du har brukt andre rammer, kan du sammenligne Artisan med Oil in FuelPHP, ZFTool i Zend eller konsollen i Symfony 2.

Artisan tilbyr mange nyttige kommandoer som kan hjelpe deg med å utføre ulike oppgaver, for eksempel generering av migrasjoner eller publisering av pakkens eiendeler. I tillegg til de innebygde kommandoene, kan du utvide Artisan med dine egne kommandoer.

Artisans grunnlag

Det er her håndverkeren setter sin makt.

I Laravel 3 ble Artisan skrevet fra grunnen av Taylor Otwell (Laravel's creator), og det var ganske grunnleggende (selv om det fortsatt var kjempebra). Nå som Laravel 4 er Composer-basert, kan den bruke eksisterende pakker utviklet av andre strålende utviklere. Som et resultat avhenger Laravel 4 av mange pakker fra Symfony-rammen. En av disse pakker er den utmerkede konsollkomponenten.

Hvis vi tar en titt på kilden til artisan søknad på Belyse \ Console \ Program, vi kan se at klassen i seg selv strekker seg ut Symfony \ Component \ Console \ Program. Det er her håndverkeren setter sin makt. Selv om Artisan bruker Symfony's Console-komponent, har mange av de vanlige metodene blitt gitt mer flytende Laravel-lignende aliaser. Så ikke bekymre deg, det vil fortsatt føles som om du utvikler med Laravel!

Vanlige spørsmål

To spørsmål kommer vanligvis opp når du prøver å utvikle en ny kommando.

Q Hvor skal jeg legge kommandoer?

Når du installerer en kopi av Laravel, finner du en forhåndsdefinert katalog på app / kommandoer. Denne katalogen er også i classmap av din composer.json som standard. Dette betyr at når du har opprettet en kommando, må du kjøre komponist dump-autoload å generere en oppdatert autoload-fil. Hvis du ikke gjør det, mottar du feil, klager på at kommandoen din ikke kan bli funnet.

Hvis du utvikler en pakke, må du opprette en katalog i pakkene dine src // katalog for å holde kommandoene dine. I hele Larbals 4 kodebase, er denne katalogen navngitt Console. Husk å sikre at katalogen er autoloaded i pakkene dine composer.json.

Q Hvordan skal jeg nevne kommandoer?

I hele Larbals 4-kodebase er alle kommandoer suffiks med Kommando, og er oppkalt etter oppgaven de utfører. La oss for eksempel si at du har en kommando som sletter cachen din. Du kan kanskje nevne denne kommandoen, CacheClearCommand.

Grunnleggende om en kommando

En kommando bør utføre en enkelt oppgave. Gjennom resten av denne artikkelen skal vi utvikle en kommandoer for brukergenerator. La oss se på grunnleggende om en kommando.

// app / kommandoer / UserGeneratorCommand.php linje ('Velkommen til brukergeneratoren.');

Laravel kan generere denne boilerplate-koden for deg! Bare kjør:

$ php artisan kommando: gjør UserGeneratorCommand

Dette vil skape en skjelettkommando for deg å modifisere, men for denne veiledningens formål vil vi gå gjennom prosessen med å bygge en kommando fra grunnen, slik at vi kan lære hver del av prosessen.

Kommandoenavn

Alle kommandoer må gi et navn. Dette navnet brukes til å kjøre kommandoen fra konsollen, og bør beskrive oppgaven som kommandoen utfører. Mens det ikke er noen konvensjon for hvordan kommandoen din heter, kan du vurdere et av følgende: navnerom: group / kommando, navnerom: command, eller bare kommando.

Kommando Beskrivelse

Alle kommandoer må gi en beskrivelse. Beskrivelsen brukes når du henter en liste over tilgjengelige kommandoer fra Artisan, og når du ser hjelpedokumenter for en kommando. Beskrivelser bør kort beskrive oppgaven som kommandoen utfører.

Hvis vi skulle åpne konsollen vår og hente en liste over tilgjengelige kommandoer, vil vi fortsatt ikke kunne se vår kommando som er oppført.

$ php artisan liste Laravel Framework versjon 4.0.0 Bruk: [options] command [arguments] Alternativer: --help -h Vis denne hjelpemeldingen. --quiet -q Ikke skriv ut noen melding. --verbose -v Øk verbositet av meldinger. --versjon -V Vis denne applikasjonsversjonen. --ansi Force ANSI utgang. - no-ansi Deaktiver ANSI-utgang. - ingen interaksjon - ikke spør noe interaktivt spørsmål. --env Miljøet kommandoen skal kjøre under. Tilgjengelige kommandoer: hjelp Viser hjelp til en kommandoliste Lister kommandoer migrerer Kjør databasemigreringene tjene Servere programmet på PHP-utviklingsserveren tinker Interagere med arbeidsbøkens arbeidsboks Opprett en ny pakke arbeidsbenk-aktiva: publiser Publiser en pakks eiendeler til den offentlige katalogen auth: påminnelser Opprett en migrering for kommandoen kommandoer på påminnelser for passordpåminnelser: lag Opprett en ny Artisan-kommandoen config-config: publiser Publiser en pakkekonfigurasjon til programstyringscontrolleren: lag Opprett en ny ressursbestyrbar kontroller db db: frø Se databasen med registreringsnøkkel nøkkel: generer Sett inn programnøkkelen migrere migrere: installer Opprett flyttingsregisteret migrere: lag Opprett en ny migreringsfil migrere: oppdater Nullstill og gjenkjør alle migrasjoner migrere: tilbakestill Tilbakestill alle databasemigrasjoner migrere: tilbakestilling Tilbakestille siste kø : lytt Lytt til en gitt køekø: arbeid Behandle neste jobb i en køsøkt økt: tabell Opprett en migrering for øktdatabase-tabellen

For å registrere vår nye kommando, åpne app / start / artisan.php og få en rask gjennomgang gjennom standard kommentatorblokken som er der inne. Når vi kjører Artisan fra konsollen, er denne filen inkludert; Vi bruker det til å starte opp våre kommandoer. I denne filen har vi tilgang til en $ håndverker variabel som ble erklært før filen ble inkludert. Husk Artisan-søknadsklassen som vi så på tidligere? Den som utvidet Symfony Console-komponenten? Vi vil, $ håndverker er en forekomst av den klassen.

La oss legge til vår kommando for å gjøre den tilgjengelig i konsollen.

$ artisan-> add (ny UserGeneratorCommand);

Eller, hvis du foretrekker statisk syntaks:

Artisan :: legg til (ny UserGeneratorCommand);

De Legg til Metoden aksepterer en kommandoen forekomst. Når kommandoen vår er lagt til, kan vi få tilgang til den fra konsollen.

$ php artisan bruker: generer velkommen til brukergeneratoren.

Kommandoen bør også være oppført i de tilgjengelige kommandoene, i tillegg til hjelpinformasjonen.

$ php artisan liste

$ php artisan bruker: generer --hjelp Bruk: bruker: generer Alternativer: --hjelp (-h) Vis denne hjelpemeldingen. --quiet (-q) Ikke send noen melding. --verbose (-v) Øk verbositet av meldinger. --version (-V) Vis denne applikasjonsversjonen. --ansi Force ANSI utgang. - no-ansi Deaktiver ANSI-utgang. - ingen interaksjon (-n) Ikke spør noe interaktivt spørsmål. --env Miljøet kommandoen skal kjøre under.

Hvis du får feil, må du sørge for at du kjører komponist dump-autoload fra applikasjonsroten din, etter å ha opprettet kommandoen.

Farget utgang

Utlevering av farget tekst til konsollen er en cinch i Artisan. Det er fire forskjellige hjelpemetoder for å ekko farget ANSI-utgang.

$ this-> info ("Dette er litt informasjon."); $ this-> comment ("Dette er en kommentar."); $ this-> question ("Dette er et spørsmål."); $ this-> error ("Dette er en feil.");

Alternativer og argumenter

En spennende ny funksjon til Artisan er evnen til å gi en kommando med alternativer og argumenter.

argumenter

Argumenter er strenger som du sender gjennom til en kommando. De må gis til en kommando i den rekkefølgen de er definert. Vurder følgende kommando:

$ php artisan bruker: generer [navn] [email]

De Navn argumentet må spesifiseres før e-post argument.

Argumenter kan defineres som valgfritt.

alternativer

Alternativer er alltid valgfritt, og er prefiks med to bindestreker, når de leveres.

$ php artisan bruker: generer --admin

Bortsett fra å bli brukt som boolske brytere, kan et alternativ konfigureres for å godta en verdi eller en rekke verdier.

$ php artisan bruker: generer --name = Jason $ php artisan bruker: generer --role = user --role = editor

Definere alternativer og argumenter

Før vi definerer våre alternativer og argumenter, er det best å importere de nødvendige Symfony-klassene (de er lange og vil være en smerte for å skrive ut hele tiden). De to klassene vi trenger er Symfony \ Component \ Console \ Input \ InputOption og Symfony \ Component \ Console \ Input \ InputArgument.

Over vår klassedeklarasjon importerer vi begge klassene.

// app / kommandoer / UserGenerateCommand.php linje ('Velkommen til brukergeneratoren.');

For å definere alternativer og argumenter må du opprette to nye metoder: getArguments og getOptions. Begge disse metodene returnerer en rekke argumenter eller alternativer. La oss få vår kommando akseptere en Navn argument, og an alder alternativ.

// app / kommandoer / UserGenerateCommand.php linje ('Velkommen til brukergeneratoren.'); // Få navnet argumenter og aldersvalget fra inngangseksemplet. $ name = $ this-> argument ('navn'); $ alder = $ dette-> alternativ ('alder'); $ this-> line ("$ name er $ alder år gammel.");  / ** * Få konsoll kommandoen argumenter. * * @return array * / beskyttet funksjon getArguments () return array (array ('navn', InputArgument :: REQUIRED, 'Navn på den nye brukeren'););  / ** * Få konsollkommandoalternativene. * * @return array * / beskyttet funksjon getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user'));

Husk: Laravel kan generere all denne boilerplate-koden for deg. Vi gjør det enkelt manuelt for å vurdere hver linje i klassen.

Nå kan vi tilby en Navn argument og an alder alternativ fra konsollen vår.

$ php artisan bruker: generer Jason --age = 22 Jason er 22 år gammel.

Begge argumentene og alternativene er definert som flerdimensjonale arrays. La oss ta en nærmere titt på definisjonene for hver av dem.

Argumentdefinisjoner

Arraydefinisjonen for et argument aksepterer fire nøkler, med bare den første (argumentnavnet) som kreves. Den andre nøkkelen er argumentmodusen og bør enten være InputArgument :: VALGFRITT eller InputArgument :: KREVES. Den tredje er beskrivelsen, og den fjerde nøkkelen er en standardverdi hvis modusen er satt til InputArgument :: VALGFRITT.

Her er et argument som bruker alle matnøklene.

array ('navn', InputArgument :: OPTIONAL, 'Navn på den nye brukeren', 'Jason')

Alternativ Definisjoner

Arraydefinisjonen for et alternativ aksepterer fem taster med bare det første (alternativnavnet) som kreves. Den andre nøkkelen er en snarvei for alternativet (-en for eksempel). Den tredje er alternativmodusen og kan være en av følgende verdier: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, eller InputOption :: VALUE_IS_ARRAY. Den fjerde nøkkelen er alternativbeskrivelsen, og den femte nøkkelen er en standardverdi, hvis modusen ikke er InputOption :: VALUE_NONE eller InputOption :: VALUE_REQUIRED.

Her er et alternativ, ved hjelp av alle arraytastene.

array ('alder', 'a', InputOption :: VALUE_OPTIONAL, 'Alder av den nye brukeren', 22)

Du kan også kombinere InputOption :: VALUE_IS_ARRAY modus med InputOption :: VALUE_REQUIRED eller InputOption :: VALUE_OPTIONAL.

array ('rolle', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Roller av den nye brukeren', 'brukeren')

Bekreftelser og spørsmål

En annen spennende ny funksjon til Artisan er evnen til å be om bekreftelse, eller til og med spør brukeren et spørsmål. Dette gjør utviklingen av interaktive kommandoer så enkelt som mulig.

bekreftelser

Ved hjelp av bekrefte, Vi kan stille en bruker et spørsmål, og få dem til å bekrefte med enten "ja" eller "nei". La oss bekrefte at brukeren har angitt sin alder riktig.

// app / kommandoer / UserGenerateCommand.php linje ('Velkommen til brukergeneratoren.'); // Få navnet argumenter og aldersvalget fra inngangseksemplet. $ name = $ this-> argument ('navn'); $ alder = $ dette-> alternativ ('alder'); hvis ! $ this-> confirm ("Er du virkelig $ alder år gammel? [Ja | nei]", sant)) $ this-> kommentar ('Så hvorfor sa du at du var !?'); komme tilbake;  $ this-> comment ("$ name er $ alder år gammel.");  / ** * Få konsoll kommandoen argumenter. * * @return array * / beskyttet funksjon getArguments () return array (array ('navn', InputArgument :: REQUIRED, 'Navn på den nye brukeren'););  / ** * Få konsollkommandoalternativene. * * @return array * / beskyttet funksjon getOptions () return array (array ('alder', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Den første parameteren er spørsmålet du vil spørre, og det andre er standardverdien, hvis en bruker treffer, skriver inn uten å skrive noe.

spørsmål

Ved hjelp av spørre, Vi kan stille en bruker et spørsmål og forventer et svar fra dem. I stedet for å drepe vår kommando hvis brukeren oppgir at de har angitt sin alder feil, la oss i stedet be dem om å skrive inn den igjen.

// app / kommandoer / UserGenerateCommand.php linje ('Velkommen til brukergeneratoren.'); // Få navnet argumenter og aldersvalget fra inngangseksemplet. $ name = $ this-> argument ('navn'); $ alder = $ dette-> alternativ ('alder'); // Bekreft at brukeren skrev inn sin alder riktig, og hvis de ikke har det, vil vi / be dem om å skrive det inn igjen. hvis ! $ this-> confirm ("Er du virkelig $ alder år gammel? [Ja | nei]", sant)) $ alder = $ denne-> spørre ('Så hvor gammel er du da?') ;  $ this-> comment ("$ name er $ alder år gammel.");  / ** * Få konsoll kommandoen argumenter. * * @return array * / beskyttet funksjon getArguments () return array (array ('navn', InputArgument :: REQUIRED, 'Navn på den nye brukeren'););  / ** * Få konsollkommandoalternativene. * * @return array * / beskyttet funksjon getOptions () return array (array ('alder', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Kommandoavhengigheter

Dependensinjeksjon er et viktig skritt for å sikre at koden din er testbar og fremtidig bevis. La oss ta vår kommando et skritt videre ved å injisere en modelleksempel, slik at vi kan generere brukeren. Vi begynner med å lage et brukergrensesnitt og brukermodell.

// app / modeller / UserInterface.php   Våre Brukergrensesnitt Definerer egentlig ikke noen metodeimplementeringer, da dette bare er et eksempel. For en ekte verden applikasjon, ville du definere metodene du ville forvente på din modell.
 
 // app / modeller / User.php  Nå som vi har vår Bruker modell implementering av vår Brukergrensesnitt, Vi kan fortsette å sette opp vår avhengighet i vår kommando. Jeg skal legge til litt mer til vår generere kommando, og samhandle med Bruker modell som injiseres.
 // app / kommandoer / UserGenerateCommand.php bruker = $ bruker;  / ** * Utfør konsollkommandoen. * * @return void * / public function fire () $ this-> linje ('Velkommen til brukergeneratoren.'); // Få navnet argumenter og aldersvalget fra inngangseksemplet. $ this-> user-> name = $ this-> argument ('navn'); $ this-> user-> age = $ this-> alternativet ('alder'); // Bekreft at brukeren skrev inn sin alder riktig, og hvis de ikke har det, vil vi / be dem om å skrive det inn igjen. Vi fortsetter å spørre dem til de er // sikker på at de har gått inn i riktig alder. $ correctAge = false; mens ! $ correctAge if (! $ this-> confirm ("Er du virkelig $ this-> bruker-> alder år gammel? [ja | nei]", sant)) $ this-> > alder = $ dette-> spør ('Så hvor gammel er du da?');  ellers $ correctAge = true;  $ this-> user-> framework = $ this-> spør ('Hva er din favoritt rammeverk?', 'Laravel'); $ this-> user-> website = $ this-> spør ('Hva er din webadresse?'); // Lagre brukeren i databasen. $ Dette-> bruker-> Lagre (); // Rapporter at brukeren har blitt lagret. $ this-> info ("$ this-> user-> name har blitt generert og lagret.");  / ** * Få konsoll kommandoen argumenter. * * @return array * / beskyttet funksjon getArguments () return array (array ('navn', InputArgument :: REQUIRED, 'Navn på den nye brukeren'););  / ** * Få konsollkommandoalternativene. * * @return array * / beskyttet funksjon getOptions () return array (array ('alder', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null)); 
 Det første du bør legge merke til er at kommandoen nå har en konstruktør. Denne konstruktøren aksepterer en enkelt parameter og vi har typen antydet Brukergrensesnitt, så vi vet at klassen vi får implementerer metodene som er definert på grensesnittet. Kommandokonstruktører bør også ringe forelderkonstruktøren.
 I Brann Metode for kommandoen, vi tildeler eiendommene direkte på Bruker modelleksempel. Vi bruker også en sløyfe for å fortsette å spørre brukeren om de har angitt sin alder riktig. Til slutt blir brukeren lagret i databasen, og vi sender ut til konsollen som brukeren ble generert og lagret.
 Men vent! Før vi kan bruke kommandoen, må vi injisere en forekomst av vår Bruker modell.
 // app / start / artisan.php $ user = ny bruker; $ artisan-> add (ny UserGeneratorCommand ($ bruker));
 Hvis du har en databaseoppsett og konfigurert riktig, bør du nå kunne kjøre kommandoen og få en ny bruker lagret i databasen!
 
 Pakkekommandoer
 Hvis du utvikler en pakke i Laravel, vil du kanskje inkludere kommandoer. Registrering av kommandoer fra pakker er stort sett den samme prosessen, bortsett fra at du ikke (eller ikke kan) legge til kommandoen app / start / artisan.php. I stedet løsner du dem med håndtverker fra din pakkeleverandør.
 // path / to / your / PackageServiceProvider.php / ** * Registrer tjenesteleverandøren. (* app 'avhengighet']);); $ Dette-> kommandoer ( 'command.package.command'); 
 De kommandoer Metoden kan akseptere et hvilket som helst antall argumenter, og vil løse kommandoen ut av applikasjonsbeholderen når Artisan er startet.
 
 Konklusjon
 Når du sammenligner Artisan i Laravel 4 til sin Laravel 3 motpart, vil du raskt finne ut at forbedringene er monumentale. Kommandoer kan nå være bundet til IoC-beholderen og inkludere avhengighetsinjeksjon, gi farget ANSI-utgang, bruk argumenter og alternativer, og be om brukers interaksjon.
 Kraften til Artisan, takket være Symfony's Console-komponent, er utrolig. Kommandoer kommer til å spille en stor rolle, mens vi beveger oss fremover - så kom ombord tidlig!



		
			
	   
	




Kode