La tua guida One-Stop ai comandi di Laravel

In questo giorno ed età, è abbastanza normale per uno sviluppatore avere una conoscenza delle console e come emettere i comandi di base. Ma se potessi codificare i tuoi comandi personalizzati per migliorare il tuo flusso di lavoro? Se guardiamo indietro a Laravel 3, potresti ricordare che ha offerto dei compiti. Le attività sono state estremamente utili, ma sono ancora venute meno per operazioni più complesse. Fortunatamente, Laravel 4 contiene un Artisan rinforzato che renderà la tua vita di programmatore molto più semplice!

Cos'è Artisan?

Artisan è l'utilità della riga di comando che è stata rilasciata in Laravel 3.

Se non hai familiarità con Laravel, allora potresti non essere a conoscenza di Artisan. Artisan è l'utilità della riga di comando rilasciata in Laravel 3. Se hai utilizzato altri framework, puoi confrontare Artisan con Oil in FuelPHP, ZFTool in Zend o la console in Symfony 2.

Artisan offre molti comandi utili che possono aiutarti a svolgere varie attività, come generare migrazioni o pubblicare le risorse di un pacchetto. Oltre ai comandi incorporati, puoi estendere Artisan con i tuoi comandi.

Fondamenti artigiani

È qui che l'artigiano trae il suo potere.

In Laravel 3, Artisan è stato scritto da zero da Taylor Otwell (il creatore di Laravel), quindi era piuttosto semplice (anche se ancora fantastico). Ora che Laravel 4 è basato su Composer, può utilizzare i pacchetti esistenti sviluppati da altri brillanti sviluppatori. Di conseguenza, Laravel 4 ora dipende da numerosi pacchetti del framework Symfony. Uno di questi pacchetti è l'eccellente componente della console.

Se diamo un'occhiata alla fonte dell'applicazione Artisan su Illuminare \ Console \ Application, possiamo vedere che la classe stessa si estende Symfony \ Component \ Console \ Application. È qui che l'artigiano trae il suo potere. Sebbene Artisan utilizzi il componente Console di Symfony, molti dei metodi più comuni hanno ricevuto alias più fluidi di Laravel. Quindi non preoccuparti, ti sembrerà ancora di sviluppare con Laravel!

Domande comuni

Solitamente vengono visualizzate due domande quando si tenta di sviluppare un nuovo comando.

Q Dove dovrei mettere i comandi?

Quando installi una copia di Laravel, troverai una directory predefinita su app / comandi. Questa directory è anche nel classmap del tuo composer.json per impostazione predefinita. Ciò significa che, una volta creato un comando, è necessario eseguire compositore dump-autoload per generare un file di caricamento automatico aggiornato. Se non lo fai, riceverai errori, lamentando che il tuo comando non può essere trovato.

Se stai sviluppando un pacchetto, dovrai creare una directory all'interno dei tuoi pacchetti src // directory per contenere i tuoi comandi. In tutta la base di codice di Laravel 4, questa directory è nominata consolle. Ricordarsi di assicurarsi che la directory sia caricata automaticamente nei pacchetti composer.json.

Q Come dovrei nominare i comandi?

In tutto il codice code di Laravel 4, tutti i comandi sono suffissi Comando, e prendono il nome dal compito che svolgono. Supponiamo, ad esempio, di avere un comando che cancella la cache. Potresti chiamare questo comando, CacheClearCommand.

Nozioni di base di un comando

Un comando dovrebbe eseguire una singola attività. Nel resto di questo articolo, svilupperemo un comando generatore utente. Esaminiamo le basi di un comando.

// app / commands / UserGeneratorCommand.php linea ('Benvenuto al generatore di utenti.');

Laravel è in grado di generare questo codice boilerplate per te! Basta eseguire:

$ php artisan command: make UserGeneratorCommand

Questo creerà un comando skeleton che dovrai modificare, tuttavia, ai fini di questo tutorial, passeremo attraverso il processo di creazione di un comando da zero, in modo che possiamo imparare ogni parte del processo.

Nome comando

Tutti i comandi devono fornire un nome. Questo nome viene utilizzato per eseguire il comando dalla console e deve descrivere l'attività eseguita dal comando. Sebbene non vi sia alcuna convenzione per il modo in cui il tuo comando è denominato, potresti prendere in considerazione uno dei seguenti: namespace: Gruppo di comando /, namespace: Comando, o semplicemente comando.

Descrizione del comando

Tutti i comandi devono fornire una descrizione. La descrizione viene utilizzata quando si recupera un elenco di comandi disponibili da Artisan e quando si visualizzano i documenti di aiuto per un comando. Le descrizioni dovrebbero descrivere brevemente l'attività eseguita dal comando.

Se dovessimo aprire la nostra console e recuperare un elenco di comandi disponibili, non saremo ancora in grado di vedere il nostro comando elencato.

$ art lista php Laravel Framework versione 4.0.0 Uso: [opzioni] comando [argomenti] Opzioni: --help -h Visualizza questo messaggio di aiuto. --quiet -q Non visualizza alcun messaggio. --verbose -v Aumenta la verbosità dei messaggi. --version -V Mostra questa versione dell'applicazione. --ansi Force ANSI output. --no-ansi Disabilita uscita ANSI. --no-interaction -n Non fare alcuna domanda interattiva. --env L'ambiente in cui dovrebbe essere eseguito il comando. Comandi disponibili: help Visualizza la guida per un elenco di comandi Elenca i comandi esegui la migrazione Esegui le migrazioni del database servi Serve l'applicazione sul server di sviluppo PHP Tinker Interagisci con il workbench dell'applicazione Crea un nuovo asset del workbench del pacchetto: pubblica Pubblica le risorse di un pacchetto sull'autore della directory pubblica auth: promemoria Crea una migrazione per il comando di comando della tabella dei promemoria della password: make Crea un nuovo comando Artisan config config: pubblica Pubblica la configurazione di un pacchetto sul controller del controller dell'applicazione: crea un nuovo controller di risorse db db: seed Seed il database con la chiave dei record chiave: generare Impostare la chiave dell'applicazione migrare migrare: installare Creare migrare il repository di migrazione: make Eseguire la migrazione di un nuovo file di migrazione: aggiornare Reimposta e rieseguire tutte le migrazioni migrare: reimposta Ripristino migrazioni di tutti i database: rollback Rollback dell'ultima coda di coda di migrazione del database : ascolta Ascolta una coda in attesa: lavoro Elabora il lavoro successivo in una sessione in coda session: table Crea una migrazione per la tabella del database di sessione

Per registrare il nostro nuovo comando, apri app / inizio / artisan.php e avere una rapida lettura del blocco di commenti predefinito che è lì dentro. Quando eseguiamo Artisan dalla console, questo file è incluso; lo useremo per avviare i nostri comandi. In questo file, abbiamo accesso a un $ artigianale variabile che è stata dichiarata prima che il file sia incluso. Ricorda la classe di applicazione Artisan che abbiamo visto in precedenza? Quello che ha esteso il componente Symfony Console? Bene, $ artigianale è un'istanza di quella classe.

Aggiungiamo il nostro comando per renderlo disponibile nella console.

$ artigiano-> aggiungi (nuovo UserGeneratorCommand);

Oppure, se preferisci la sintassi statica:

Artisan :: add (nuovo UserGeneratorCommand);

Il Inserisci metodo accetta un'istanza di comando. Una volta aggiunto il comando, possiamo accedervi dalla console.

$ php artisan user: genera il benvenuto al generatore di utenti.

Il comando dovrebbe anche essere elencato nei comandi disponibili, così come le informazioni di aiuto.

$ lista di artigiani php

$ php artisan user: generate --help Usage: user: generate Opzioni: --help (-h) Visualizza questo messaggio di aiuto. --quiet (-q) Non emette alcun messaggio. --verbose (-v) Aumenta la verbosità dei messaggi. --version (-V) Mostra questa versione dell'applicazione. --ansi Force ANSI output. --no-ansi Disabilita uscita ANSI. --no-interaction (-n) Non fare alcuna domanda interattiva. --env L'ambiente in cui dovrebbe essere eseguito il comando.

Se ricevi errori, assicurati di correre compositore dump-autoload dalla root delle applicazioni, dopo aver creato il comando.

Uscita colorata

L'emissione di testo colorato sulla console è un gioco da ragazzi in Artisan. Esistono quattro diversi metodi di supporto per riprodurre l'output ANSI colorato.

$ this-> info ("Questa è una informazione."); $ this-> comment ("Questo è un commento."); $ this-> question ("Questa è una domanda."); $ this-> error ("Questo è un errore.");

Opzioni e argomenti

Una nuova eccitante caratteristica di Artisan è la possibilità di fornire un comando con opzioni e argomenti.

argomenti

Gli argomenti sono stringhe che invii a un comando. Devono essere assegnati a un comando nell'ordine in cui sono definiti. Considera il seguente comando:

$ php artisan user: generare [nome] [email]

Il nome argomento deve essere specificato prima del e-mail discussione.

Gli argomenti possono essere definiti come facoltativi.

Opzioni

Le opzioni sono sempre opzionale, e sono preceduti da due trattini, se forniti.

$ php artisan user: genera --admin

Oltre ad essere usato come switch booleani, un'opzione può essere configurata per accettare un valore o una matrice di valori.

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

Definizione di opzioni e argomenti

Prima di definire le nostre opzioni e argomenti, è meglio importare le classi richieste di Symfony (sono lunghe e sarebbe difficile scrivere tutto il tempo). Le due classi di cui abbiamo bisogno sono Symfony \ Component \ Console \ Input \ InputOption e Symfony \ Component \ Console \ Input \ InputArgument.

Sopra la nostra dichiarazione di classe, importeremo entrambe le classi.

// app / commands / UserGenerateCommand.php linea ('Benvenuto al generatore di utenti.');

Per definire le opzioni e gli argomenti, è necessario creare due nuovi metodi: getArguments e GetOptions. Entrambi questi metodi restituiscono una matrice di argomenti o opzioni. Facciamo in modo che il nostro comando accetti a nome argomento, e un età opzione.

// app / commands / UserGenerateCommand.php linea ('Benvenuto al generatore di utenti.'); // Ottieni gli argomenti nome e l'opzione age dall'istanza di input. $ nome = $ questo-> argomento ('nome'); $ age = $ this-> option ('age'); $ this-> line ("$ name ha $ età anni.");  / ** * Ottieni gli argomenti del comando della console. * * array @return * / funzione protetta getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nome del nuovo utente'),);  / ** * Ottieni le opzioni di comando della console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user'));

Ricorda: Laravel può generare tutto questo codice standard per te. Lo stiamo semplicemente facendo manualmente allo scopo di rivedere ogni riga della classe.

Ora possiamo fornire un nome argomento e an età opzione dalla nostra console.

$ php artisan user: genera Jason --age = 22 Jason ha 22 anni.

Sia gli argomenti che le opzioni sono definiti come array multidimensionali. Diamo un'occhiata più da vicino alle definizioni per ognuno di essi.

Definizioni degli argomenti

La definizione dell'array per un argomento accetta quattro chiavi, con solo il primo (il nome degli argomenti) richiesto. La seconda chiave è la modalità argomenti e dovrebbe essere o InputArgument :: OPTIONAL o InputArgument :: RICHIESTO. Il terzo è la descrizione e la quarta chiave è un valore predefinito, se la modalità è impostata su InputArgument :: OPTIONAL.

Ecco un argomento usando tutti i tasti dell'array.

array ('name', InputArgument :: OPTIONAL, 'Nome del nuovo utente', 'Jason')

Definizioni di opzione

La definizione di matrice per un'opzione accetta cinque chiavi con solo il primo (il nome di opzioni) richiesto. La seconda chiave è una scorciatoia per l'opzione (-un per esempio). Il terzo è la modalità opzioni e può essere uno dei seguenti valori: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, o InputOption :: VALUE_IS_ARRAY. La quarta chiave è la descrizione delle opzioni e la quinta è un valore predefinito, se la modalità non lo è InputOption :: VALUE_NONE o InputOption :: VALUE_REQUIRED.

Ecco un'opzione, utilizzando tutti i tasti dell'array.

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

Puoi anche combinare il InputOption :: VALUE_IS_ARRAY modalità con InputOption :: VALUE_REQUIRED o InputOption :: VALUE_OPTIONAL.

array ('role', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Ruoli del nuovo utente', 'utente')

Conferme e domande

Un'altra novità entusiasmante per Artisan è la sua capacità di richiedere la conferma o anche di porre all'utente una domanda. Ciò rende lo sviluppo di comandi interattivi il più semplice possibile.

conferme

utilizzando Confermare, possiamo porre una domanda a un utente e farle confermare con "sì" o "no". Confermiamo che l'utente ha inserito correttamente la loro età.

// app / commands / UserGenerateCommand.php linea ('Benvenuto al generatore di utenti.'); // Ottieni gli argomenti nome e l'opzione age dall'istanza di input. $ nome = $ questo-> argomento ('nome'); $ age = $ this-> option ('age'); if (! $ this-> confirm ("Sei veramente $ age anni [yes | no]", vero)) $ this-> comment ('Allora perché hai detto che eri !?'); ritorno;  $ this-> comment ("$ name ha $ età anni.");  / ** * Ottieni gli argomenti del comando della console. * * array @return * / funzione protetta getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nome del nuovo utente'),);  / ** * Ottieni le opzioni di comando della console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Il primo parametro è la domanda che vorresti porre, e il secondo è il valore predefinito, se un utente tocca entra senza digitare nulla.

Domande

utilizzando Chiedere, possiamo chiedere ad un utente una domanda e aspettarci una risposta da loro. Invece di uccidere il nostro comando se l'utente specifica di aver inserito la loro età in modo errato, chiediamo invece di inserirlo nuovamente.

// app / commands / UserGenerateCommand.php linea ('Benvenuto al generatore di utenti.'); // Ottieni gli argomenti nome e l'opzione age dall'istanza di input. $ nome = $ questo-> argomento ('nome'); $ age = $ this-> option ('age'); // Conferma che l'utente abbia inserito correttamente la loro età e, in caso contrario, ti chiederemo // di inserirli di nuovo. se (! $ this-> confirm ("Sei davvero $ età anni [sì | no]", vero)) $ età = $ questo-> chiedi ('Quanti anni hai?') ;  $ this-> comment ("$ name ha $ età anni.");  / ** * Ottieni gli argomenti del comando della console. * * array @return * / funzione protetta getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nome del nuovo utente'),);  / ** * Ottieni le opzioni di comando della console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Dipendenze dei comandi

L'iniezione di dipendenza è un passo importante per garantire che il codice sia verificabile e a prova di futuro. Prendiamo il nostro comando un ulteriore passo iniettando un'istanza di modello, in modo che possiamo generare l'utente. Inizieremo creando un'interfaccia utente e un modello utente.

// app / models / UserInterface.php   Nostro Interfaccia utente in realtà non definisce alcuna implementazione del metodo, in quanto questo è solo un esempio. Per un'applicazione reale, definirai i metodi che ti aspetteresti sul tuo modello.
 
 // app / models / User.php  Ora che abbiamo il nostro Utente modello che implementa il nostro Interfaccia utente, possiamo continuare a impostare la nostra dipendenza dal nostro comando. Aggiungerò un po 'di più al comando di generazione e interagirò con Utente modello iniettato.
 // app / commands / UserGenerateCommand.php utente = $ utente;  / ** * Esegue il comando della console. * * @return void * / public function fire () $ this-> line ('Benvenuto al generatore di utenti.'); // Ottieni gli argomenti nome e l'opzione age dall'istanza di input. $ this-> user-> name = $ this-> argument ('name'); $ this-> user-> age = $ this-> option ('age'); // Conferma che l'utente abbia inserito correttamente la loro età e, in caso contrario, ti chiederemo // di inserirli di nuovo. Continueremo a chiedere loro finché non saranno sicuri di aver inserito l'età giusta. $ correctAge = false; while (! $ correctAge) if (! $ this-> confirm ("Sei veramente $ this-> user-> age anni? [yes | no]", vero)) $ this-> user- > età = $ questo-> chiedi ('Quanti anni hai allora?');  else $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('Qual è il tuo framework preferito?', 'Laravel'); $ this-> user-> website = $ this-> ask ('Qual è l'indirizzo del tuo sito web?'); // Salva l'utente nel database. $ This-> user-> save (); // Segnala che l'utente è stato salvato. $ this-> info ("$ this-> user-> name è stato generato e salvato.");  / ** * Ottieni gli argomenti del comando della console. * * array @return * / funzione protetta getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nome del nuovo utente'),);  / ** * Ottieni le opzioni di comando della console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null)); 
 La prima cosa che dovresti notare è che il comando ora ha un costruttore. Questo costruttore accetta un singolo parametro e abbiamo accennato al tipo Interfaccia utente, quindi sappiamo che la classe che implementiamo implementa i metodi definiti nell'interfaccia. I costruttori di comandi dovrebbero anche chiamare il costruttore genitore.
 Nel fuoco metodo del comando, stiamo assegnando direttamente le proprietà sul Utente esempio di modello. Stiamo anche utilizzando un ciclo per continuare a chiedere all'utente se ha inserito correttamente la loro età. Infine, l'utente viene salvato nel database e viene inviato alla console che l'utente è stato generato e salvato.
 Ma aspetta! Prima di poter usare il comando, dobbiamo iniettare un'istanza del nostro Utente modello.
 // app / start / artisan.php $ user = new User; $ artisan-> add (new UserGeneratorCommand ($ user));
 Se si dispone di una configurazione del database e configurata correttamente, è ora possibile eseguire il comando e salvare un nuovo utente nel database!
 
 Comandi del pacchetto
 Se stai sviluppando un pacchetto in Laravel, potresti voler includere dei comandi. La registrazione dei comandi dai pacchetti è per lo più la stessa procedura, tranne che non si (o non si può) aggiungere il comando app / inizio / artisan.php. Invece, li risolvi con Artisan dal tuo fornitore di servizi di pacchetti.
 // percorso / to / tuo / PackageServiceProvider.php / ** * Registrare il fornitore di servizi. * * @return void * / public function register () $ this-> app ['command.package.command'] = $ this-> app-> share (function ($ app) return new PackageCommand ($ app [ 'dipendenza']);); $ This-> comandi ( 'command.package.command'); 
 Il comandi il metodo può accettare qualsiasi numero di argomenti e risolverà il comando dal contenitore dell'applicazione quando viene avviato Artisan.
 
 Conclusione
 Quando confronti Artisan in Laravel 4 con la sua omonima Laravel 3, scoprirai subito che i miglioramenti sono monumentali. I comandi ora possono essere associati al contenitore IoC e includere l'iniezione delle dipendenze, fornire un output ANSI colorato, utilizzare argomenti e opzioni e richiedere l'interazione dell'utente.
 Il potere di Artisan, grazie alla componente Console di Symfony, è incredibile. I comandi giocheranno un ruolo enorme, mentre andiamo avanti - quindi sali presto!



		
			
	   
	




Codice