Ghidul dvs. unic pentru comenzile Laravel

În această zi și vârstă, este normal ca un dezvoltator să aibă o înțelegere a consolelor și cum să emită comenzi de bază. Dar dacă ați putea codifica propriile comenzi personalizate pentru a vă îmbunătăți fluxul de lucru? Dacă privim înapoi la Laravel 3, vă puteți aminti că a oferit sarcini. Sarcini au fost extrem de utile, dar totuși a venit scurt pentru operațiuni mai complexe. Din fericire, Laravel 4 împachetează un Artisan crescut, care vă va face viața dezvoltatorului mult mai ușor!

Ce este Artisan?

Artisan este utilitatea liniei de comandă lansată în Laravel 3.

Dacă nu sunteți familiarizat cu Laravel, atunci este posibil să nu fiți conștienți de Artisan. Artisan este utilitarul de linie de comandă care a fost lansat în Laravel 3. Dacă ați folosit alte cadre, puteți compara Artisan cu Ulei în FuelPHP, ZFTool în Zend sau Consola în Symfony 2.

Artisan oferă multe comenzi utile care vă pot ajuta să efectuați diferite sarcini, cum ar fi generarea de migrații sau publicarea activelor unui pachet. În plus față de comenzile încorporate, puteți extinde Artisan cu propriile comenzi.

Fundațiile lui Artisan

Aici Artisan isi desfasoara puterea.

În Laravel 3, Artisan a fost scris de la zero de Taylor Otwell (creatorul lui Laravel), deci a fost destul de bază (deși încă minunat). Acum, când Laravel 4 este bazat pe compozitori, poate folosi pachetele existente dezvoltate de alți dezvoltatori străluciți. Ca urmare, Laravel 4 depinde acum de numeroase pachete din cadrul Symfony. Unul dintre aceste pachete este reprezentat de Componenta Console excelentă.

Dacă aruncăm o privire la sursa aplicației Artisan la Illuminate \ Consola \ Application, putem vedea că clasa însăși se extinde Symfony \ Componenta \ Consola \ Application. Aici Artisan isi desfasoara puterea. Deși Artisan folosește componenta Symfony's Console, o mulțime de metode obișnuite au primit aliasuri mai largi de tip Laravel. Deci, nu-ți fă griji, va mai simți că te dezvolți cu Laravel!

Intrebari obisnuite

Două întrebări apar în mod obișnuit atunci când încercați să dezvoltați o nouă comandă.

Unde ar trebui să pun comenzi??

Când instalați o copie a lui Laravel, veți găsi un director predefinit la app / comenzi. Acest director este, de asemenea, în classmap de dumneavoastră composer.json în mod implicit. Aceasta înseamnă că, odată ce ați creat o comandă, va trebui să rulați compozitor dump-autoload pentru a genera un fișier autoload actualizat. Dacă nu, veți primi erori, plângând că comanda dvs. nu poate fi găsită.

Dacă dezvoltați un pachet, va trebui să creați un director în pachetele dvs. src // pentru a vă ține comenzile. De-a lungul codului Laravel 4, acest director este numit Consolă. Nu uitați să vă asigurați că directorul este autoloaded în pachetele dvs. composer.json.

Q Cum ar trebui să denumesc comenzi?

De-a lungul codului Laravel 4, toate comenzile sunt sufixate Comanda, și sunt numiți după sarcina pe care o îndeplinesc. Să spunem, de exemplu, că aveți o comandă care vă șterge memoria cache. S-ar putea să numiți această comandă, CacheClearCommand.

Elementele de bază ale unei comenzi

O comandă trebuie să efectueze o singură sarcină. În tot restul acestui articol, vom dezvolta o comandă a generatorului de utilizatori. Să revizuim elementele de bază ale unei comenzi.

// app / comenzi / UserGeneratorCommand.php line ("Bun venit la generatorul de utilizatori.");

Laravel poate genera acest cod de boilerplate pentru tine! Pur și simplu alerga:

$ php artisan command: face UserGeneratorCommand

Acest lucru va crea o comandă de schelet pentru modificarea dvs. cu toate acestea, în scopul acestui tutorial, vom trece prin procesul de construire a unei comenzi de la zero, astfel încât să putem învăța fiecare piesă a procesului.

Numele comenzii

Toate comenzile trebuie să furnizeze un nume. Acest nume este folosit pentru a rula comanda de la consola și ar trebui să descrie sarcina efectuată de comandă. Deși nu există nicio convenție pentru cum este numită comanda dvs., puteți lua în considerare una dintre următoarele: Spațiu de nume: grup / comanda, Spațiu de nume: comanda, sau doar comanda.

Descrierea comenzii

Toate comenzile trebuie să furnizeze o descriere. Descrierea este utilizată la preluarea unei liste de comenzi disponibile de la Artisan și la vizualizarea documentelor de ajutor pentru o comandă. Descrierile ar trebui să descrie pe scurt sarcina efectuată de comandă.

Dacă ne-am deschide consola și vom aduce o listă de comenzi disponibile, tot nu vom putea vedea comanda noastră.

$ php artizan list Laravel Framework version 4.0.0 Utilizare: [opțiuni] comanda [argumente] Opțiuni: --help -h Afișează acest mesaj de ajutor. - quiet -q Nu scoateți niciun mesaj. --verbose -v Creșterea verbosității mesajelor. --versiune -V Afișați această versiune a aplicației. --ansi Forța de ieșire ANSI. --no-ansi Dezactivați ieșirea ANSI. --no-interacțiune -n Nu puneți nici o întrebare interactivă. --env Mediul în care comanda ar trebui să ruleze sub. Comenzi disponibile: help Afișează ajutor pentru o listă de comenzi Listează comenzi migrează Rulați serviciul de migrare a bazelor de date Servi aplicația de pe serverul de dezvoltare al PHP-ului Interacționați cu bancul de lucru al aplicației Creați un nou activ de activ al pachetului de lucru de lucru: publicați Publicați activele pachetului în directorul public auth: memento-uri Creeaza o migrare pentru comanda comenzii tabelului de comenzi pentru parola: make Creaza o noua comanda Artisan config config: publica Publica configuratia unui pachet la controlerul aplicatiei: make Creeaza un nou controler resourceb db db: seed Semnaliza baza de date cu tasta records cheie: generare Setați cheia aplicației migrați migrația: instalați Creați un depozit de migrare migrați: faceți Creați un nou fișier de migrare migrați: reîmprospătați Resetați și reluați toate migrările migrați: resetați Reveniți la toate migrările bazei de date migrați: rollback Returnați ultima coadă de așteptare pentru migrarea bazei de date : ascultați Ascultați o coadă de coadă: lucrați Procesați următoarea lucrare într-o sesiune de coadă sesiune: tabel Crearea unei migrări pentru tabela bazei de date a sesiunii

Pentru a înregistra noua comandă, deschideți-o app / start / artisan.php și au o citire rapidă prin blocul de comentarii implicit care este acolo. Când executăm Artisan din consola, acest fișier este inclus; o vom folosi pentru a lansa comenzile noastre. În acest fișier, avem acces la un $ artizan care a fost declarată înainte de includerea fișierului. Adu-ti aminte de clasa de aplicatii Artisan la care ne-am uitat mai devreme? Cel care a extins componenta Symfony Console? Bine, $ artizan este o instanță a acelei clase.

Să adăugăm comanda noastră pentru ao face disponibilă în consola.

$ artisan-> add (noul UserGeneratorCommand);

Sau, dacă preferați sintaxa statică:

Artisan :: add (nou UserGeneratorCommand);

adăuga metoda acceptă o instanță de comandă. Odată ce comanda noastră a fost adăugată, o putem accesa din consola.

$ php artisan user: generate Bun venit la generatorul de utilizatori.

De asemenea, comanda trebuie să fie listată în comenzile disponibile, precum și informațiile de ajutor.

$ php artizan list

$ php artisan user: generate --help Utilizare: user: generate Opțiuni: --help (-h) Afișează acest mesaj de ajutor. --quiet (-q) Nu transmiteți niciun mesaj. - verbose (-v) Creșterea verbosității mesajelor. --versiune (-V) Afișați această versiune a aplicației. --ansi Forța de ieșire ANSI. --no-ansi Dezactivați ieșirea ANSI. --no-interacțiune (-n) Nu întrebați nicio întrebare interactivă. --env Mediul în care comanda ar trebui să ruleze sub.

Dacă primiți erori, asigurați-vă că rulați compozitor dump-autoload din root-ul aplicațiilor dvs., după crearea comenzii.

Ieșire colorată

Rezultatul textului colorat pe consola este un cinch în Artisan. Există patru metode diferite de ajutor pentru ieșirea ANSI echo colorată.

$ this-> info ("Aceasta este o informație."); $ this-> comment ("Acesta este un comentariu."); $ this-> question ("Aceasta este o întrebare."); $ this-> error ("Aceasta este o eroare.");

Opțiuni și argumente

O caracteristică extraordinară pentru Artisan este abilitatea de a oferi o comandă cu opțiuni și argumente.

Argumente

Argumentele sunt șiruri pe care le trimiteți la o comandă. Acestea trebuie să fie date unei comenzi în ordinea în care sunt definite. Luați în considerare următoarea comandă:

Utilizator $ php artizan: genera [nume] [email]

Nume argumentul trebuie specificat înainte de e-mail argument.

Argumentele pot fi definite ca opționale.

Opțiuni

Opțiunile sunt mereu opțional și sunt prefixate cu două liniuțe, atunci când acestea sunt furnizate.

$ php utilizator artizan: generate --admin

În afară de a fi folosite ca comutatoare booleene, o opțiune poate fi configurată să accepte o valoare sau o serie de valori.

$ php utilizator artizan: generate --name = Jason $ php utilizator artizan: generate --role = user --role = editor

Definirea opțiunilor și a argumentelor

Înainte de a ne defini opțiunile și argumentele, este mai bine să importați clasele Simmfony necesare (acestea sunt lungi și ar fi o durere pentru a scrie tot timpul). Cele două clase de care avem nevoie sunt Symfony \ Componenta \ Console \ de intrare \ InputOption și Symfony \ Componenta \ Console \ de intrare \ InputArgument.

Deasupra declarației noastre de clasă, vom importa ambele clase.

// app / comenzi / UserGenerateCommand.php line ("Bun venit la generatorul de utilizatori.");

Pentru a defini opțiunile și argumentele, trebuie să creați două metode noi: getArguments și getOptions. Ambele metode returnează o serie de argumente sau opțiuni. Să facem comanda noastră să accepte a Nume argument, și un vârstă opțiune.

// app / comenzi / UserGenerateCommand.php line ("Bun venit la generatorul de utilizatori."); // Obțineți argumentele de nume și opțiunea de vârstă din instanța de intrare. $ name = $ this-> argument ('nume'); $ age = $ this-> opțiune ("vârstă"); $ this-> line ("$ name este $ age ani.");  / ** * Obțineți argumentele comenzii consolei. * * @return array * / funcția protejată getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Numele noului utilizator'),);  / ** * Obțineți opțiunile comenzii consolei. * * @return array * / funcția protejată getOptions () array return (array ('vârstă', null, InputOption :: VALUE_REQUIRED, 'vârsta noului utilizator'));

Amintiți-vă: Laravel poate genera întregul cod de boilerplate pentru dvs. Pur și simplu o facem manual în scopul revizuirii fiecărei linii din clasă.

Acum, putem oferi o Nume argument și un vârstă opțiune din consola noastră.

$ php artizan user: generate Jason --age = 22 Jason are 22 de ani.

Atât argumentele, cât și opțiunile sunt definite ca matrice multidimensionale. Să aruncăm o privire mai atentă asupra definițiilor fiecăruia.

Argumente Definiții

Definiția matricei pentru un argument acceptă patru chei, cu doar primul (numele argumentelor) fiind necesar. A doua cheie este modul de argumente și ar trebui să fie fie InputArgument :: OPȚIONAL sau InputArgument :: OBLIGATORIU. A treia este descrierea, iar a patra cheie este o valoare implicită, dacă modul este setat la InputArgument :: OPȚIONAL.

Iată un argument folosind toate cheile de matrice.

array ('name', InputArgument :: OPTIONAL, 'Numele noului utilizator', 'Jason')

Opțiuni Definiții

Definiția matricei pentru o opțiune acceptă cinci chei, cu doar primul (numele opțiunilor) care este necesar. A doua cheie este o comandă rapidă pentru opțiune (-A de exemplu). Al treilea este modul opțiuni și poate fi una dintre următoarele valori: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, sau InputOption :: VALUE_IS_ARRAY. A patra cheie este descrierea opțiunilor, iar a cincea cheie este o valoare implicită, dacă modul nu este InputOption :: VALUE_NONE sau InputOption :: VALUE_REQUIRED.

Iată o opțiune, folosind toate cheile de matrice.

array ('age', 'a', InputOption :: VALUE_OPTIONAL, 'Vârsta noului utilizator', 22)

De asemenea, puteți combina funcția InputOption :: VALUE_IS_ARRAY mod cu InputOption :: VALUE_REQUIRED sau InputOption :: VALUE_OPTIONAL.

array ('rol', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Rolurile noului utilizator', 'utilizator')

Confirmări și întrebări

O altă caracteristică extraordinară pentru Artisan este abilitatea de a solicita o confirmare sau chiar de a pune întrebarea utilizatorului. Acest lucru face ca dezvoltarea comenzilor interactive să fie cât se poate de simplă.

Confirmări

Utilizarea a confirma, putem pune o întrebare unui utilizator și le putem confirma cu "da" sau "nu". Să confirmăm că utilizatorul a intrat corect în vârstă.

// app / comenzi / UserGenerateCommand.php line ("Bun venit la generatorul de utilizatori."); // Obțineți argumentele de nume și opțiunea de vârstă din instanța de intrare. $ name = $ this-> argument ('nume'); $ age = $ this-> opțiune ("vârstă"); dacă ! $ this-> confirmă ("Ești cu adevărat $ age ani? [yes | no]", adevărat)) $ this-> comment ('De ce ai spus că ai fost? întoarcere;  $ this-> comment ("$ name este $ age ani.");  / ** * Obțineți argumentele comenzii consolei. * * @return array * / funcția protejată getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Numele noului utilizator'),);  / ** * Obțineți opțiunile comenzii consolei. * * @return array * / funcția protejată getOptions () retur array (array ('vârstă', null, InputOption :: VALUE_REQUIRED, 'vârsta noului utilizator', null));

Primul parametru este întrebarea pe care doriți să o întrebați, iar a doua este valoarea implicită, dacă un utilizator accesează intrarea fără a scrie nimic.

Întrebări

Utilizarea cere, putem cere unui utilizator o întrebare și așteptăm un răspuns de la ei. În loc să ucizi comanda noastră dacă utilizatorul specifică faptul că au intrat în vârstă incorectă, să le cerem să le introducă din nou.

// app / comenzi / UserGenerateCommand.php line ("Bun venit la generatorul de utilizatori."); // Obțineți argumentele de nume și opțiunea de vârstă din instanța de intrare. $ name = $ this-> argument ('nume'); $ age = $ this-> opțiune ("vârstă"); // Confirmați utilizatorul corect introdus în funcție de vârstă și, dacă nu l-am primit, îi vom cere să-l introducă din nou. dacă ! $ this-> confirmă ("Ești cu adevărat $ age ani? [yes | no]", adevărat)) $ age = $ this-> ask (" ;  $ this-> comment ("$ name este $ age ani.");  / ** * Obțineți argumentele comenzii consolei. * * @return array * / funcția protejată getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Numele noului utilizator'),);  / ** * Obțineți opțiunile comenzii consolei. * * @return array * / funcția protejată getOptions () retur array (array ('vârstă', null, InputOption :: VALUE_REQUIRED, 'vârsta noului utilizator', null));

Command Dependencies

Injecția de dependență este un pas important pentru a vă asigura că codul dvs. este testabil și dovedit în viitor. Să luăm comanda noastră cu un pas înainte prin injectarea unui exemplu de model, astfel încât să putem genera utilizatorul. Vom începe prin crearea unei interfețe de utilizator și a unui model de utilizator.

// app / models / UserInterface.php   Al nostru Interfața cu utilizatorul nu definesc de fapt nici o implementare a metodei, deoarece acesta este doar un exemplu. Pentru o aplicație din lumea reală, ați defini metodele pe care le-ați aștepta la modelul dvs..
 
 // app / models / User.php  Acum că avem pe noi Utilizator implementarea modelului nostru Interfața cu utilizatorul, putem continua să ne stabilim dependența de comanda noastră. Voi adăuga un pic mai mult comenzii noastre de generare și vom interacționa cu Utilizator modelul care a fost injectat.
 // app / comenzi / UserGenerateCommand.php user = $ user;  / ** * Executați comanda consolei. * * @return void * / fire public function () $ this-> line ('Bun venit la generatorul de utilizatori.'); // Obțineți argumentele de nume și opțiunea de vârstă din instanța de intrare. $ this-> user-> name = $ this-> argument ("nume"); $ this-> user-> age = $ this-> opțiune ("vârstă"); // Confirmați utilizatorul corect introdus în funcție de vârstă și, dacă nu l-am primit, îi vom cere să-l introducă din nou. Vom continua să le cerem până vor fi siguri că au intrat la vârsta potrivită. $ correctAge = false; în timp ce ($ $ correctAge) if (! $ this-> confirm ("Ești într-adevăr $ this-> user-> age > age = $ this-> ask ("Deci, cât de vechi sunteți?");  altceva $ correctAge = true;  $ this-> user-> framework = $ this-> ask ("Care este cadrul dvs. preferat?", "Laravel"); $ this-> user-> website = $ this-> ask ('Care este adresa dvs. de site?'); // Salvați utilizatorul la baza de date. $ This-> user-> Salvare (); // Raportați că utilizatorul a fost salvat. $ this-> info ("$ this-> user-> name a fost generat și salvat.");  / ** * Obțineți argumentele comenzii consolei. * * @return array * / funcția protejată getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Numele noului utilizator'),);  / ** * Obțineți opțiunile comenzii consolei. * * @return array * / funcția protejată getOptions () retur array (array ('vârstă', null, InputOption :: VALUE_REQUIRED, 'vârsta noului utilizator', null)); 
 Primul lucru pe care trebuie să-l observați este că comanda are acum un constructor. Acest constructor acceptă un singur parametru și l-am tipărit Interfața cu utilizatorul, astfel încât știm că clasa pe care o obținem implementează metodele definite pe interfață. Constructorii de comandă ar trebui să apeleze și constructorul părinte.
 În foc metoda de comandă, atribuim direct proprietățile pe Utilizator exemplu de model. De asemenea, folosim o buclă pentru a continua să solicităm utilizatorului dacă au introdus corect vârsta. În cele din urmă, utilizatorul este salvat în baza de date și ieșim la consola pe care utilizatorul a fost generată și salvată.
 Dar asteapta! Înainte de a putea folosi comanda, trebuie să injectăm o instanță a noastră Utilizator model.
 // app / start / artisan.php $ user = utilizator nou; $ artisan-> add (noul UserGeneratorCommand ($ user));
 Dacă aveți o configurare a bazei de date și ați configurat corect, acum ar trebui să puteți rula comanda și să aveți un nou utilizator salvat în baza de date!
 
 Comenzi pentru pachete
 Dacă dezvoltați un pachet în Laravel, este posibil să doriți să includeți și comenzi. Înregistrarea comenzilor din pachete este în mare parte același proces, cu excepția faptului că nu adăugați (sau nu puteți) comanda în app / start / artisan.php. În schimb, le rezolvați cu Artisan din cadrul furnizorului dvs. de servicii pentru pachete.
 // path / to / your / PackageServiceProvider.php / ** * Înregistrați furnizorul de servicii. * * @return void * / registrul funcțiilor publice () $ this-> app ['command.package.command'] = $ this-> app-> share (funcția ($ app) "dependență"]);); $ This-> comenzi ( 'command.package.command'); 
  comenzi metoda poate accepta orice număr de argumente și va rezolva comanda din containerul aplicației când Artisan este pornit.
 
 Concluzie
 Când comparați Artisan în Laravel 4 cu omologul său Laravel 3, veți găsi rapid că îmbunătățirile sunt monumentale. Comenzile pot fi acum legate de containerul IoC și includ injecția de dependență, oferă ieșire ANSI colorată, utilizează argumente și opțiuni și solicită interacțiunea cu utilizatorul.
 Puterea lui Artisan, datorită componentei Consolei Symfony, este de necrezut. Comenzile vor juca un rol imens, pe masura ce mergem mai departe - asa ca intrati la bord devreme!



		
			
	   
	




Cod