() translation by (you can also view the original English article)
आज के समय में, डेवलपर्स के लिए यह बहुत ही नॉर्मल है कि उन्हें कंसोल की जानकारी हो, और बेसिक कमांड्स को कैसे बनाएं यह भी पता हो. लेकिन तब क्या हो जब आप अपने खुद के कस्टम कमांड बना सकते हो ताकि आपके वर्कफ्लो को इंप्रूव किया जा सके? अगर हम Laravel 3 की ओर देखते हैं, तो आपको याद आएगा कि यह हमें Tasks ऑफर करता है. Tasks बहुत ही मददगार होते हैं, लेकिन इनमें कार्य करना बहुत ही कठिन होता है. शुक्र है, Laravel 4 Artisan के साथ पैक होकर आता है जिससे की एक डेवलपर के तौर पर आपकी लाइफ आसान होती है.
Artisan क्या होता है?
Artisan एक कमांड लाइन यूटिलिटी है जिसे Laravel 3 के अंदर रिलीज किया गया था.
यदि आपको Laravel की जानकारी नहीं है, तो आपको Artisan के बारे में भी नहीं पता होगा. Artisan एक कमांड लाइन यूटिलिटी है जिसे Laravel 3 के साथ रिलीज किया गया था. यदि आपने अन्य फ्रेमवर्क का प्रयोग किया है, तो आप Artisan को FuewlPHP में Oil की तरह, Zend में ZFTool की तरह या Symfony 2 में Console की तरह मान सकते हैं.
Artisan कई तरह के उपयोगी कमांड्स को देता है जो आपकी मदद करेंगे अलग-अलग प्रकार के टास्क करने में, जैसे कि माइग्रेशन को जनरेट करना या पैकेज के ऐसेट को पब्लिश करना. बिल्ट-इन कमांड के अलावा, आप Artisan को अपनी खुद की कमांड्स के लिए एक्सटेंड कर सकते हैं.
Artisan की फाउंडेशन
यह वह जगह है जहां Artisan अपनी शक्ति को दिखाता है.
Laravel 3 में, Artisan को Taylor Otwell (Laravel का क्रिएटर) द्वारा scratch से लिखा गया था, इस प्रकार यह बहुत ही बेसिक था (फिर भी बहुत बढ़िया). अब जबकि Laravel 4 Composer पर आधारित है, यह अन्य बेहतरीन डेवेलपर्स द्वारा पहले से ही लिखे गए पैकजों का प्रयोग कर सकता है. इसके परिणाम स्वरूप, Laravel 4 अब Symfony फ्रेमवर्क में मौजूद असंख्य पैकजों पर निर्भर है. इन पैकजों में से एक बेहतरीन पैकेज Console Component है.
यदि हम Artisan एप्लीकेशन पर Illuminate\Console\Application में सोर्स पर एक नजर डालें, हम देख सकते हैं की क्लास, खुद ही, Symfony\Component\Console\Application को एक्सटेंड करती है. यह वह जगह है जहां Artisan अपनी शक्ति दिखाता है. हालांकि Artisan Symfony के Console कॉम्पोनेंट का प्रयोग करता है, बहुत से Laravel के इलियास की तरह कॉमन मेथड्स इसमें दिए गए हैं. इसलिए चिंता ना करें, आपको अब भी यही लगेगा कि आप Laravel को ही डेवलप कर रहे हैं!
सामान्य प्रश्न
जब कभी भी हम एक नई कमांड बनाते हैं तो, दो प्रश्न आम तौर पर सामने आते हैं.
Q मुझे कमांड्स को कहां रखना चाहिए?
जब आप Laravel की एक कॉपी को इंस्टॉल करते हैं, तो आप एक पहले से ही डिफाइन की गयी डायरेक्टरी app/commands में देखेंगे. यह डायरेक्टरी डिफ़ॉल्ट रूप से आपके composer.json के classmap में भी होती है. इसका अर्थ है कि, एक बार जब आप कमांड बना लेते हैं, आप को composer dump-autoload को चलाना होगा ताकि एक अपडेट की हुई ऑटो लोड फाइल जनरेट हो सके. यदि आप ऐसा नहीं करते हैं, तो आपको एक एरर प्राप्त होगा, जो यह बताएगा कि आप की कमांड नहीं मिल सकती है.
यदि आप पैकेज बना रहे होते हैं, तो आपको अपने src/<vendor>/<package> पैकेज डायरेक्टरी में कमांड्स को रखने के लिए एक नई डायरेक्टरी बनाने की जरूरत होगी. पूरे Laravel 4 कोड बेस में, इस डायरेक्टरी का नाम होगा Console. यह पक्का करने की यह डायरेक्टरी composer.json पैकेजेस में ऑटोलोड होती है.
Q मुझे कमांड्स को नाम कैसे देना चाहिए?
पूरे Laravel 4 कोड बेस में, सभी कमांड Command के साथ सफिक्स होती हैं, और इसके बाद उस टास्क का नाम होता है जिसे यह करती है. चलिए मानते हैं, उदाहरण के लिए, कि आपके पास एक कमांड है जो आपके कैश को साफ करती हैं. आप इस कमांड को इस प्रकार नाम देंगे, CacheClearCommand.
कमांड के बेसिक
एक कमांड को सिंगल टास्क करना चाहिए. इस पूरे आर्टिकल के बचे हुए हिस्से में, हम एक यूजर जनरेटर कमांड को डिवेलप करेंगे. आइए कमांड के बेसिक को रिव्यू करें.
1 |
// app/commands/UserGeneratorCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
|
7 |
class UserGeneratorCommand extends Command { |
8 |
|
9 |
/**
|
10 |
* The console command name.
|
11 |
*
|
12 |
* @var string
|
13 |
*/
|
14 |
protected $name = 'user:generate'; |
15 |
|
16 |
/**
|
17 |
* The console command description.
|
18 |
*
|
19 |
* @var string
|
20 |
*/
|
21 |
protected $description = "Generate a new user"; |
22 |
|
23 |
/**
|
24 |
* Execute the console command.
|
25 |
*
|
26 |
* @return void
|
27 |
*/
|
28 |
public function fire() |
29 |
{
|
30 |
$this->line('Welcome to the user generator.'); |
31 |
}
|
32 |
|
33 |
}
|
Laravel इस boilerplate कोड को आपके लिए जनरेट कर सकता है! सिर्फ इसे चलाएं:
1 |
$ php artisan command:make UserGeneratorCommand |
यह आपके लिए एक स्केलेटन कमांड बनाएगा ताकि आप इसे मॉडिफाई कर सके, हालांकि, इस ट्यूटोरियल के उद्देश्यों के लिए, हम कमांड को स्क्रैच से बनाने के प्रोसेस से गुजरेंगे, ताकि हम प्रोसेस के हर हिस्से को सीख सकें.
कमांड का नाम
सभी कमांड को नाम दिए जाने की आवश्यकता होती है. यह नाम कंसोल में कमांड को चलाए जाते समय प्रयोग किया जाता है, और इसमें उस टास्क को डिस्क्राइब करना चाहिए जो यह कमांड करती है. हालांकि ऐसा कोई भी कन्वेंशन नहीं है कि आप अपनी कमांड को कैसे नाम दें, पर आप निम्न में से किसी एक के बारे में सोच सकते हैं: namespace:group/command, namespace:command, या सिर्फ command.
कमांड की डिस्क्रिप्शन
सभी कमांड्स को डिस्क्रिप्शन दिए जाने की आवश्यकता है. डिस्क्रिप्शन की आवश्यकता तब होती है जब हम Artisan में सभी मौजूद कमांड की लिस्ट को देखते हैं, और जब हम हेल्प डॉक्स को कमांड के लिए देखते हैं. डिस्क्रिप्शन उस टास्क को ब्रीफ में डिस्क्राइब करता हो जो कमांड करती है.
यदि हम अपने कंसोल को खोलने जा रहे हो और मौजूद सभी कमांड की लिस्ट प्राप्त करना चाहे, तो हमें अभी भी अपनी कमांड इस लिस्ट में नजर नहीं आएगी.
1 |
$ php artisan list
|
2 |
Laravel Framework version 4.0.0 |
3 |
|
4 |
Usage: |
5 |
[options] command [arguments] |
6 |
|
7 |
Options: |
8 |
--help -h Display this help message. |
9 |
--quiet -q Do not output any message. |
10 |
--verbose -v Increase verbosity of messages. |
11 |
--version -V Display this application version. |
12 |
--ansi Force ANSI output.
|
13 |
--no-ansi Disable ANSI output.
|
14 |
--no-interaction -n Do not ask any interactive question. |
15 |
--env The environment the command should run under. |
16 |
|
17 |
Available commands: |
18 |
help Displays help for a command |
19 |
list Lists commands
|
20 |
migrate Run the database migrations |
21 |
serve Serve the application on the PHP development server |
22 |
tinker Interact with your application |
23 |
workbench Create a new package workbench |
24 |
asset |
25 |
asset:publish Publish a package's assets to the public directory
|
26 |
auth
|
27 |
auth:reminders Create a migration for the password reminders table
|
28 |
command
|
29 |
command:make Create a new Artisan command
|
30 |
config
|
31 |
config:publish Publish a package's configuration to the application
|
32 |
controller |
33 |
controller:make Create a new resourceful controller |
34 |
db |
35 |
db:seed Seed the database with records |
36 |
key |
37 |
key:generate Set the application key |
38 |
migrate |
39 |
migrate:install Create the migration repository |
40 |
migrate:make Create a new migration file |
41 |
migrate:refresh Reset and re-run all migrations |
42 |
migrate:reset Rollback all database migrations |
43 |
migrate:rollback Rollback the last database migration |
44 |
queue |
45 |
queue:listen Listen to a given queue |
46 |
queue:work Process the next job on a queue |
47 |
session |
48 |
session:table Create a migration for the session database table
|
हमारी नई कमांड को रजिस्टर करने के लिए, app/start/artisan.php को खोलें और वहां पर मौजूद कमेंट ब्लॉक को जल्दी से पढ़े. जब हम Artisan कमांड को कंसोल में चलाते हैं, यह फाइल शामिल होती है; इसे हम अपनी कमांड को बूटस्ट्रैप करने के लिए प्रयोग करेंगे. इस फाइल में, हमारी पहुंच $artisan वेरिएबल तक होती है जिसे फाइल को शामिल करने से भी पहले डिक्लेअर किया गया. Artisan एप्लीकेशन क्लास याद है जिसे हमने पहले देखा था? वह वाली जो Symfony Console कॉम्पोनेंट को एक्सटेंड करती थी? वेल, $artisan उस क्लास का एक इंस्टेंस है.
आइए अपनी कमांड को जोड़ें ताकि यह कंसोल में उपलब्ध हो.
1 |
$artisan->add(new UserGeneratorCommand); |
या, यदि आप स्टैटिक सिंटेक्स को पसंद करते हैं:
1 |
Artisan::add(new UserGeneratorCommand); |
add मेथड कमांड के इंस्टेंस को एक्सेप्ट करता है. एक बार जब हमारी कमांड ऐड हो जाती है, हम इसे कंसोल में प्राप्त कर सकते हैं.
1 |
$ php artisan user:generate
|
2 |
Welcome to the user generator. |
कमांड को उपलब्ध कमांड की लिस्ट में भी होना चाहिए, साथ ही साथ हेल्प इंफॉर्मेशन में भी.
1 |
$ php artisan list
|
1 |
$ php artisan user:generate --help |
2 |
Usage: |
3 |
user:generate |
4 |
|
5 |
Options: |
6 |
--help (-h) Display this help message. |
7 |
--quiet (-q) Do not output any message. |
8 |
--verbose (-v) Increase verbosity of messages. |
9 |
--version (-V) Display this application version. |
10 |
--ansi Force ANSI output.
|
11 |
--no-ansi Disable ANSI output.
|
12 |
--no-interaction (-n) Do not ask any interactive question. |
13 |
--env The environment the command should run under. |
यदि आपको कोई एरर मिलता है, तो यह पक्का करें कि आपने
composer dump-autoloadको अपनी एप्लीकेशन के रूट से चलाया हो, इस कमांड को बनाने के बाद.
रंगो वाला आउटपुट
रंगो वाले टेक्स्ट को कंसोल में आउटपुट करना Artisan का एक प्रभाव है. चार अलग-अलग तरह के हेल्पर मेथड होते हैं जिससे हम ANSI आउटपुट को रंगों के साथ echo कर सकते हैं.
1 |
$this->info("This is some information."); |
2 |
|
3 |
$this->comment("This is a comment."); |
4 |
|
5 |
$this->question("This is a question."); |
6 |
|
7 |
$this->error("This is an error."); |
ऑप्शन और अरगुमेंट
Artisan का एक एक्साइटिंग नया फीचर है ऑप्शंस और अरगुमेंट्स के साथ कमांड को उपलब्ध कराने की योग्यता.
आर्ग्यूमेंट्स
अरगुमेंट्स वो स्ट्रिंग होती है जिसे आप कमांड के जरिए भेजते हैं. उन्हें उसी ऑर्डर में कमांड को दिया जाना चाहिए जिनमें वे डिफाइन किये गए है. नीचे दी गई कमांड पर ध्यान दीजिए:
1 |
$ php artisan user:generate [name] [email] |
name अरगुमेंट को email अरगुमेंट से पहले दिया जाना चाहिए.
आर्गुमेंट को ऑप्शनल के रूप में डिफाइन किया जा सकता है.
ऑप्शंस
ऑप्शंस हमेशा ऑप्शनल ही होते हैं, और दो डैश के साथ प्रीफिक्स होते हैं, जब उन्हें दिया जाता है.
1 |
$ php artisan user:generate --admin |
बुलियन स्विच के रूप में उपयोग किए जाने के अलावा, एक ऑप्शन को वैल्यू या वैल्यू के ऐरे स्वीकार करने के लिए कॉन्फ़िगर किया जा सकता है.
1 |
$ php artisan user:generate --name=Jason |
2 |
$ php artisan user:generate --role=user --role=editor |
ऑप्शंस और अरगुमेंट्स को डिफाइन करना
इससे पहले कि हम ऑप्शंस और आर्ग्यूमेंट्स को डिफाइन करें, यह बेहतर रहेगा कि हम Symfony की आवश्यक क्लासेस को इंपोर्ट करें (वे लंबी होती है और उन्हें लिखने में हमेशा एक दर्द महसूस होता है). वे दो क्लासेस जिनकी हमें आवश्यकता है Symfony\Component\Console\Input\InputOption और Symfony\Component\Console\Input\InputArgument है.
अपनी क्लास के डिक्लेरेशन से पहले, हम दोनों क्लासेज को इंपोर्ट करेंगे.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
}
|
34 |
|
35 |
}
|
ऑप्शंस और आर्ग्यूमेंट्स को डिफाइन करने के लिए, आपको दो नए मेथड बनाने की आवश्यकता होगी: getArguments और getOptions. यह दोनों मेथड आर्ग्यूमेंट्स या ऑप्शंस के ऐरे को रीटर्न करते हैं. चलिए हमारी कमांड को name अरगुमेंट एक्सेप्ट करने वाला बनाएं, और एक age ऑप्शन वाला भी.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
$this->line("{$name} is {$age} years old."); |
40 |
}
|
41 |
|
42 |
/**
|
43 |
* Get the console command arguments.
|
44 |
*
|
45 |
* @return array
|
46 |
*/
|
47 |
protected function getArguments() |
48 |
{
|
49 |
return array( |
50 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
51 |
);
|
52 |
}
|
53 |
|
54 |
/**
|
55 |
* Get the console command options.
|
56 |
*
|
57 |
* @return array
|
58 |
*/
|
59 |
protected function getOptions() |
60 |
{
|
61 |
return array( |
62 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user') |
63 |
);
|
64 |
}
|
65 |
|
66 |
}
|
याद रखें: Laravel यह सभी boilerplate कोड को आपके लिए जनरेट कर सकता है. हम इसे मैनुअली कर रहे हैं इस उद्देश्य से कि हम क्लास की सभी लाइनों को रिव्यू कर सकें.
अब, हम एक name अरगुमेंट और एक age ऑप्शन को हमारे कंसोल से उपलब्ध करा सकते हैं.
1 |
$ php artisan user:generate Jason --age=22 |
2 |
Jason is 22 years old. |
दोनों आर्ग्यूमेंट्स और ऑप्शंस एक मल्टी-डाइमेंशनल ऐरे के रूप में डिफाइन है. आइए इन दोनों की डेफिनेशन पर नजदीक से एक नजर डालते हैं.
अरगुमेंट की डेफिनेशन
अरगुमेंट के लिए ऐरे डेफिनेशन चार keys को एक्सेप्ट करता है, जिनमें से सिर्फ पहली वाली (अरगुमेंट का नाम) रिक्वायर्ड होती है. दूसरी key अरगुमेंट का मोड है और इसे InputArgument::OPTIONAL या InputArgument::REQUIRED होना चाहिए. तीसरी एक डिस्क्रिप्शन है, और चौथी key एक डिफॉल्ट वैल्यू है, यदि मोड InputArgument::OPTIONAL पर सेट है.
यहां एक अरगुमेंट है जो इन सभी ऐरे keys का प्रयोग कर रहा है.
1 |
array('name', InputArgument::OPTIONAL, 'Name of the new user', 'Jason') |
ऑप्शन की डेफिनेशन
ऑप्शन के लिए ऐरे डेफिनेशन पांच keys को एक्सेप्ट करता है जिनमें से सिर्फ पहली (नाम का ऑप्शन) ही रिक्वायर्ड है. दूसरी key ऑक्शन के लिए एक शॉर्टकट है (उदाहरण के लिए -a). तीसरी ऑप्शन का मोड है और दी गई वैल्यूज में से एक हो सकती है: InputOption::VALUE_NONE, InputOption::VALUE_REQUIRED, InputOption::VALUE_OPTIONAL, या InputOption::VALUE_IS_ARRAY. चौथी key ऑप्शंस की डिस्क्रिप्शन है, और पांचवी key एक डिफॉल्ट वैल्यू है, यदि मोड InputOption::VALUE_NONE या InputOption::VALUE_REQUIRED नहीं है.
यहां एक ऑप्शन है, जो सभी ऐरे keys का प्रयोग कर रहा है.
1 |
array('age', 'a', InputOption::VALUE_OPTIONAL, 'Age of the new user', 22) |
आप साथ ही साथ InputOption::VALUE_IS_ARRAY मोड को InputOption::VALUE_REQUIRED या InputOption::VALUE_OPTIONAL के साथ कंबाइन कर सकते हैं.
1 |
array('role', 'r', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, 'Roles of the new user', 'user') |
कन्फर्मेशन और प्रश्न
Artisan का एक और नया एक्साइटिंग भरा फीचर है इसकी रिक्वेस्ट कन्फर्मेशन की योग्यता, यह यूजर से प्रश्न भी पूछ सकता है. यह इंटरएक्टिव कमांड को डेवलप करना जितना हो सके उतना आसान बनाता है.
कंफर्मेशन
confirm का प्रयोग करके, हम यूजर से एक प्रश्न पूछ सकते हैं, और उससे “yes” या “no” कंफर्म करा सकते हैं. आइए कंफर्म करें कि यूज़र ने अपनी उम्र एकदम सही डाली है.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
if ( ! $this->confirm("Are you really {$age} years old? [yes|no]", true)) |
40 |
{
|
41 |
$this->comment('Then why did you say you were!?'); |
42 |
|
43 |
return; |
44 |
}
|
45 |
|
46 |
$this->comment("{$name} is {$age} years old."); |
47 |
}
|
48 |
|
49 |
/**
|
50 |
* Get the console command arguments.
|
51 |
*
|
52 |
* @return array
|
53 |
*/
|
54 |
protected function getArguments() |
55 |
{
|
56 |
return array( |
57 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
58 |
);
|
59 |
}
|
60 |
|
61 |
/**
|
62 |
* Get the console command options.
|
63 |
*
|
64 |
* @return array
|
65 |
*/
|
66 |
protected function getOptions() |
67 |
{
|
68 |
return array( |
69 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
70 |
);
|
71 |
}
|
72 |
|
73 |
}
|
पहला पैरामीटर एक प्रश्न है जो आप पूछना चाहते हैं, और दूसरा एक डिफॉल्ट वैल्यू है, यदि यूजर बिना कुछ लिखे एंटर मारता है.
प्रश्न
ask का प्रयोग करके, हम यूजर से एक प्रश्न पूछ सकते हैं और उससे रिस्पांस की उम्मीद रख सकते हैं. हमारी कमांड को किल करने के बजाय यदि यूज़र यह बताता है की डाली गई उम्र सही नहीं है, तो उससे फिर से डालने के लिए पूछें.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
// Confirm the user entered their age correctly and if they haven't we'll
|
40 |
// ask them to enter it again.
|
41 |
if ( ! $this->confirm("Are you really {$age} years old? [yes|no]", true)) |
42 |
{
|
43 |
$age = $this->ask('So how old are you then?'); |
44 |
}
|
45 |
|
46 |
$this->comment("{$name} is {$age} years old."); |
47 |
}
|
48 |
|
49 |
/**
|
50 |
* Get the console command arguments.
|
51 |
*
|
52 |
* @return array
|
53 |
*/
|
54 |
protected function getArguments() |
55 |
{
|
56 |
return array( |
57 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
58 |
);
|
59 |
}
|
60 |
|
61 |
/**
|
62 |
* Get the console command options.
|
63 |
*
|
64 |
* @return array
|
65 |
*/
|
66 |
protected function getOptions() |
67 |
{
|
68 |
return array( |
69 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
70 |
);
|
71 |
}
|
72 |
|
73 |
}
|
कमांड की डिपेंडेंसीज
डिपेंडेंसी इंजेक्शन यह पता लगाने के लिए कि आपका कोड टेस्ट करने योग्य और फ्यूचर प्रूफ है बहुत महत्वपूर्ण कदम है. आइए अपनी कमांड को एक मॉडल इंस्टेंस को इंजेक्ट करके एक कदम आगे बढ़ाते हैं, ताकि हम यूजर को जनरेट कर सके. हम एक यूजर इंटरफेस और यूजर मॉडल को बनाकर शुरुआत करेंगे.
1 |
// app/models/UserInterface.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
interface UserInterface { |
6 |
|
7 |
}
|
हमारा
UserInterfaceकोई भी मेथड इंप्लीमेंटेशन को असल में डिफाइन नहीं करता, क्योंकि यह सिर्फ एक उदाहरण है. असली दुनिया की एप्लीकेशन, के लिए आप अपने मॉडल के लिए जिस मेथड की उम्मीद करते हैं उसे बनाएं.
1 |
// app/models/User.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
class User extends Eloquent implements UserInterface { |
6 |
|
7 |
/**
|
8 |
* The database table used by the model.
|
9 |
*
|
10 |
* @var string
|
11 |
*/
|
12 |
protected $table = 'users'; |
13 |
|
14 |
}
|
अब जबकि हमारा User मॉडल हमारे UserInterface को इंप्लीमेंट कर रहा है, हम हमारी डिपेंडेंसी को हमारी कमांड में सेटअप करने के लिए बढ़ सकते हैं. मैं हमारी जनरेट कमांड में थोड़ा सा और जोड़ूंगा, और इंजेक्ट किए गए User मॉडल से इंटरेक्ट करूंगा.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* User model instance.
|
27 |
*
|
28 |
* @var UserInterface
|
29 |
*/
|
30 |
protected $user; |
31 |
|
32 |
/**
|
33 |
* Create a new UserGeneratorCommand instance.
|
34 |
*
|
35 |
* @param UserInterface $user
|
36 |
* @return void
|
37 |
*/
|
38 |
public function __construct(UserInterface $user) |
39 |
{
|
40 |
$this->user = $user; |
41 |
}
|
42 |
|
43 |
/**
|
44 |
* Execute the console command.
|
45 |
*
|
46 |
* @return void
|
47 |
*/
|
48 |
public function fire() |
49 |
{
|
50 |
$this->line('Welcome to the user generator.'); |
51 |
|
52 |
// Get the name arguments and the age option from the input instance.
|
53 |
$this->user->name = $this->argument('name'); |
54 |
|
55 |
$this->user->age = $this->option('age'); |
56 |
|
57 |
// Confirm the user entered their age correctly and if they haven't we'll
|
58 |
// ask them to enter it again. We'll continue asking them until they are
|
59 |
// sure they've entered the right age.
|
60 |
$correctAge = false; |
61 |
|
62 |
while ( ! $correctAge) |
63 |
{
|
64 |
if ( ! $this->confirm("Are you really {$this->user->age} years old? [yes|no]", true)) |
65 |
{
|
66 |
$this->user->age = $this->ask('So how old are you then?'); |
67 |
}
|
68 |
else
|
69 |
{
|
70 |
$correctAge = true; |
71 |
}
|
72 |
}
|
73 |
|
74 |
$this->user->framework = $this->ask('What is your favorite framework?', 'Laravel'); |
75 |
|
76 |
$this->user->website = $this->ask('What is your website address?'); |
77 |
|
78 |
// Save the user to the database.
|
79 |
$this->user->save(); |
80 |
|
81 |
// Report that the user has been saved.
|
82 |
$this->info("{$this->user->name} has been generated and saved."); |
83 |
}
|
84 |
|
85 |
/**
|
86 |
* Get the console command arguments.
|
87 |
*
|
88 |
* @return array
|
89 |
*/
|
90 |
protected function getArguments() |
91 |
{
|
92 |
return array( |
93 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
94 |
);
|
95 |
}
|
96 |
|
97 |
/**
|
98 |
* Get the console command options.
|
99 |
*
|
100 |
* @return array
|
101 |
*/
|
102 |
protected function getOptions() |
103 |
{
|
104 |
return array( |
105 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
106 |
);
|
107 |
}
|
108 |
|
109 |
}
|
पहली चीज जिस पर आपको ध्यान देना चाहिए वह है की कमांड में अब एक कंस्ट्रक्टर है. यह कंस्ट्रक्टर एक सिंगल पैरामीटर एक्सेप्ट करता है और हमने UserInterface को हिंट किया है, तो हम जानते हैं कि क्लास जिसमे हमने मेथड को इंप्लीमेंट किया है इंटरफ़ेस में डिफाइन है. कमांड के कंस्ट्रक्टर को पेरेंट्स के कंस्ट्रक्टर को भी कॉल करना चाहिए.
कमांड के fire मेथड में, हम User मॉडल के इंस्टेंस पर सीधे-सीधे प्रॉपर्टीज को असाइन कर रहे हैं. हम साथ ही साथ loop का भी प्रयोग कर रहे हैं यूजर से लगातार यह पूछने के लिए की क्या उन्होंने अपनी उम्र सही डाली है. अंत में, यूजर को डाटाबेस में सेव कर दिया जाता है और हम कंसोल में आउटपुट देते हैं कि यूजर को जनरेट और सेव कर दिया गया है.
लेकिन रुको! इससे पहले कि हम कमांड का प्रयोग करें, हमें अपने User मॉडल के एक इंस्टेंस को इंजेक्ट करने की जरूरत है.
1 |
// app/start/artisan.php
|
2 |
|
3 |
$user = new User; |
4 |
|
5 |
$artisan->add(new UserGeneratorCommand($user)); |
यदि आपने डेटाबेस को सही ढंग से सेटअप और कॉन्फ़िगर कर लिया है, तो आपको अब कमांड चलाने योग्य होना चाहिए और आपके डेटाबेस में एक नया यूजर होना चाहिए!
पैकेज की कमांड्स
यदि आप Laravel में एक पैकेज बना रहे हैं, तो शायद आप कमांड को इंक्लूड करना चाहे. पैकेज से कमांड को रजिस्टर करना एक इसी प्रकार का प्रोसेस है, सिवाय इसके कि आप app/start/artisan.php मैं कमांड को ऐड नहीं करते (या कर सकते). इसकी बजाय, आप इन्हें अपने पैकेज सर्विस प्रोवाइडर से Artisan के साथ सही करते हैं.
1 |
// path/to/your/PackageServiceProvider.php
|
2 |
|
3 |
/**
|
4 |
* Register the service provider.
|
5 |
*
|
6 |
* @return void
|
7 |
*/
|
8 |
public function register() |
9 |
{
|
10 |
$this->app['command.package.command'] = $this->app->share(function($app) |
11 |
{
|
12 |
return new PackageCommand($app['dependency']); |
13 |
});
|
14 |
|
15 |
$this->commands('command.package.command'); |
16 |
}
|
commands मेथड कितने भी अरगुमेंट्स को एक्सेप्ट कर सकता है, और जब Artisan को शुरू किया जाता है तो एप्लीकेशन कंटेनर से कमांड को सही करता है.
सारांश
जब हम Laravel 4 के Artisan की इसके काउंटरपार्ट Laravel 3 से तुलना करते हैं, आपको जल्द ही पता चल जाएगा कि इंप्रूवमेंट बहुत बड़े हैं. कमांड अब IoC कंटेनर से बाउंड किए जा सकते हैं और डिपेंडेंसी इंजेक्शन को इंक्लूड कर सकते हैं, रंगीन ANSI आउटपुट को प्रोवाइड कर सकते हैं, अरगुमेंट्स और ऑप्शंस का प्रयोग कर सकते हैं, और यूज़र इंटरेक्शन की रिक्वेस्ट कर सकते हैं.
Artisan की शक्ति, Symfony के Console कॉम्पोनेंट का धन्यवाद, अविश्वसनीय है. जब हम आगे बढ़ते हैं तो कमांड एक बड़ी भूमिका निभाते हैं - तो जितनी जल्दी हो सके बोर्ड पर आ जाओ!
