Advertisement
  1. Code
  2. PHP

Panduan One-Stop untuk Laravel Command

Scroll to top
Read Time: 17 min

Indonesian (Bahasa Indonesia) translation by Ari Gustiawan (you can also view the original English article)

Di hari ini, normal untuk seorang developer untuk memiliki pemahaman konsol, dan bagaimana untuk mengeluarkan perintah basic. Tetapi bagaimana jika membuat custom command sendiri untuk meningkatkan alur kerja Anda? Jika kita melihat kembali ke Laravel 3, Anda mungkin ingat bahwa ia menawarkan tasks. Tasks sangat membantu, tapi masih belum bagus untuk operasi yang lebih kompleks. Syukurlah, Laravel 4 include Artisan yang akan membuat hidup Anda sebagai pengembang jadi lebih mudah!


Apa itu Artisan?

Artisan adalah utilitas command yang dirilis pada Laravel 3.

Jika Anda tidak akrab dengan Laravel, maka Anda mungkin tidak menyadari Artisan. Tukang adalah utilitas command line yang dirilis pada Laravel 3. Jika Anda telah menggunakan kerangka lainnya, Anda dapat membandingkan Artisan Oil di FuelPHP, ZFTool di Zend atau konsol di Symfony 2.

Tukang menawarkan banyak command yang berguna yang dapat membantu Anda melakukan berbagai tugas, seperti menghasilkan migration atau publish aset paket. Selain perintah built-in, Anda dapat extend Artisan dengan perintah Anda sendiri.


Artisan Foundation

Ini adalah dimana Artisan menarik kekuatannya.

Dalam Laravel 3, Artisan ditulis dari awal oleh Taylor Otwell (Laravel's creator), maka itu cukup dasar (meskipun masih awesome). Sekarang bahwa Laravel 4 adalah composer based, itu dapat menggunakan paket yang ada yang dikembangkan oleh pengembang lain yang brilian. Sebagai hasilnya, Laravel 4 sekarang tergantung pada berbagai paket dari Symfony framework. Salah satu paket ini adalah Console Component konsol yang sangat baik.

Jika kita mengambil melihat sumber aplikasi Artisan di Illuminate\Console\Application, kita dapat melihat bahwa kelas, itu sendiri, extend Symfony\Component\Console\Application. Ini adalah dimana Artisan menarik kekuatannya. Meskipun Artisan membuat penggunaan konsol di Symfony komponen, banyak metode yang umum telah diberikan lebih fluent seperti Laravel alias. Jadi jangan khawatir, itu masih akan merasa seperti Anda developing dengan Laravel!


Pertanyaan Umum

Dua pertanyaan biasanya muncul, ketika mencoba untuk mengembangkan perintah baru.

Q di mana sebaiknya saya Letakkan perintah?

Ketika Anda menginstal salinan Laravel, Anda akan menemukan direktori standar di app/commands. Direktori ini juga berada di classmap Anda composer.json secara default. Ini berarti bahwa, setelah Anda membuat perintah, Anda akan perlu menjalankan composer dump-autoload untuk generate sebuah file autoload yang diperbarui. Jika Anda tidak, Anda akan menerima kesalahan, mengeluh bahwa perintah Anda tidak dapat ditemukan.

Jika Anda mengembangkan sebuah paket, Anda akan perlu untuk menciptakan sebuah direktori dalam src/<vendor>/<package> direktori untuk menyimpan perintah Anda. Seluruh basis kode Laravel 4, direktori ini dinamai Console. Ingat untuk memastikan bahwa direktori autoloaded  di composer.json paket Anda.

Q bagaimana aku harus menamai perintah?

Seluruh basis kode Laravel 4, semua perintah di suffx dengan Command, dan diberi nama setelah tugas yang mereka lakukan. Katakanlah, misalnya, bahwa Anda memiliki perintah yang membersihkan cache Anda. Anda mungkin nama perintah ini, CacheClearCommand.


Dasar-dasar perintah

Perintah harus melakukan satu tugas. Sepanjang sisa artikel ini, kami akan mengembangkan pengguna generator perintah. Mari kita meninjau dasar-dasar perintah.

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 dapat menghasilkan kode boilerplate ini untuk Anda! Cukup menjalankan:

1
$ php artisan command:make UserGeneratorCommand

Ini akan membuat kerangka perintah bagi Anda untuk memodifikasi, namun, untuk tujuan dari tutorial ini, kita akan pergi melalui proses membangun perintah dari awal, sehingga kita dapat belajar setiap bagian dari proses.

Nama perintah

Semua perintah perlu memberikan nama. Nama ini digunakan untuk menjalankan perintah dari konsol, dan harus menggambarkan tugas yang melakukan perintah. Meskipun tidak ada Konvensi untuk bagaimana perintah Anda dinamakan, Anda mungkin mempertimbangkan salah satu dari berikut: namespace:group/command, namespace:command, atau hanya command.

Deskripsi perintah

Semua perintah perlu memberikan keterangan. Deskripsi digunakan ketika mengambil daftar perintah yang tersedia dari Artisan, dan ketika melihat docs bantuan untuk perintah. Deskripsi harus menjelaskan secara singkat tugas yang melakukan perintah.

Jika kita membuka konsol  dan mengambil daftar perintah yang tersedia, kami masih tidak akan mampu melihat perintah kita terdaftar.

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

Untuk mendaftar perintah baru kami, buka app/start/artisan.php dan memiliki cepat membaca melalui blok komentar default yang ada di sana. Ketika kita run Artisan dari konsol, file ini telah dimasukkan; kita akan menggunakannya untuk bootstrap perintah kami. Dalam file ini, kami memiliki akses ke variabel $artisan yang telah dinyatakan sebelum file yang disertakan. Ingat Artisan kelas aplikasi yang kami liat sebelumnya? Salah satu yang di extend dari konsol Symfony komponen? Yah, $artisan adalah instance dari kelas itu.

Mari kita tambahkan perintah kita untuk membuatnya tersedia di konsol.

1
$artisan->add(new UserGeneratorCommand);

Atau, jika Anda lebih suka sintaks statis:

1
Artisan::add(new UserGeneratorCommand);

add metode menerima command instansi Setelah perintah kita telah ditambahkan, kita dapat mengaksesnya dari konsol.

1
$ php artisan user:generate
2
Welcome to the user generator.

Perintah ini juga akan tercantum dalam perintah yang tersedia, serta informasi bantuan.

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.

Jika Anda menerima kesalahan, memastikan bahwa Anda menjalankan composer dump-autoload dari root aplikasi Anda, setelah membuat perintah.


Mewarnai Output

Keluaran teks berwarna ke konsol adalah mudah di Artisan. Ada empat metode penolong yang berbeda untuk echo berwarna ANSI output.

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.");

Option dan argumen

Sebuah fitur baru yang menarik untuk Artisan adalah kemampuan untuk memberikan perintah dengan pilihan dan argumen.

Argumen

Argumen adalah string yang Anda kirim melalui perintah. Mereka harus diberikan kepada perintah dalam urutan bahwa mereka didefinisikan. Pertimbangkan perintah berikut:

1
$ php artisan user:generate [name] [email]

name argumen harus ditentukan sebelum argumen email.

Argumen dapat didefinisikan sebagai opsional.

Option

Option selalu opsional, dan diawali dengan dua tanda hubung, ketika diberikan.

1
$ php artisan user:generate --admin

Selain digunakan sebagai boolean switch, pilihan dapat dikonfigurasi untuk menerima nilai atau array nilai.

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

Menentukan Option dan argumen

Sebelum kita mendefinisikan kami option dan argumen, terbaik untuk mengimpor kelas Symfony diperlukan (mereka panjang dan akan menjadi sakit untuk menulis sepanjang waktu). Dua kelas yang kita butuhkan adalah Symfony\Component\Console\Input\InputOption dan Symfony\Component\Console\Input\InputArgument.

Di atas Deklarasi kelas kami, kami akan mengimpor kelas kedua.

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
}

Untuk menentukan Option dan argumen, Anda perlu membuat dua metode baru: getArguments dan getOptions. Kedua metode ini mengembalikan array argumen atau option. Mari kita membuat perintah kita menerima argumen name, dan opsi 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
}

Ingat: Laravel dapat menghasilkan semua kode boilerplate ini untuk Anda. Kami hanya melakukan itu secara manual untuk keperluan meninjau setiap baris di kelas.

Sekarang, kami dapat memberikan argumen name dan age pilihan dari konsol.

1
$ php artisan user:generate Jason --age=22
2
Jason is 22 years old.

Argumen dan pilihan didefinisikan sebagai multi-dimensi array. Mari kita melihat lebih dekat pada definisi untuk masing-masing.

Argumen definisi

Definisi array argumen menerima empat kunci, dengan hanya yang pertama satu (name argumen) yang diperlukan. Tombol kedua mode argumen dan harus InputArgument::OPTIONAL atau InputArgument::REQUIRED. Yang ketiga adalah deskripsi, dan kunci keempat adalah nilai default, jika mode diset ke InputArgument::OPTIONAL.

Berikut adalah sebuah argumen yang menggunakan semua kunci array.

1
array('name', InputArgument::OPTIONAL, 'Name of the new user', 'Jason')

Definisi Option

Definisi array pilihan menerima lima kunci-kunci dengan hanya yang pertama (name option) yang diperlukan. Kunci kedua adalah cara pintas untuk pilihan (-a misalnya). Ketiga adalah mode pilihan dan dapat menjadi salah satu nilai berikut: InputOption::VALUE_NONE, InputOption::VALUE_REQUIRED, InputOption::VALUE_OPTIONAL, atau InputOption::VALUE_IS_ARRAY. Kunci keempat adalah Deskripsi pilihan, dan kunci kelima adalah nilai default, jika mode adalah tidak InputOption::VALUE_NONE atau InputOption::VALUE_REQUIRED.

Berikut adalah suatu pilihan, menggunakan semua kunci array.

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

Anda juga dapat menggabungkan modus InputOption::VALUE_IS_ARRAY dengan InputOption::VALUE_REQUIRED atau InputOption::VALUE_OPTIONAL.

1
array('role', 'r', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, 'Roles of the new user', 'user')

Konfirmasi dan pertanyaan

Namun lain fitur baru yang menarik untuk Artisan adalah kemampuannya untuk meminta konfirmasi, atau bahkan bertanya pengguna. Hal ini membuat mengembangkan interaktif perintah sesederhana mungkin.

Konfirmasi

Menggunakan confirm, kita bertanya pengguna, dan membuat mereka mengkonfirmasi dengan "yes" atau "no." Mari kita memastikan bahwa pengguna telah memasukkan usia mereka dengan benar.

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
}

Parameter pertama adalah pertanyaan yang Anda ingin bertanya, dan yang kedua adalah nilai default, jika pengguna hits masuk tanpa mengetik apa pun.

Pertanyaan

Menggunakan ask, kami dapat meminta pengguna pertanyaan dan mengharapkan tanggapan dari mereka. Daripada membunuh perintah kami jika pengguna menentukan bahwa mereka memasuki usia mereka salah, mari kita sebaliknya meminta mereka untuk kembali.

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
}

Perintah dependensi

Dependecy injection adalah langkah penting untuk memastikan bahwa kode Anda adalah bukti diuji dan masa depan. Mari kita perintah langkah lebih jauh dengan menyuntikkan model instance, sehingga kita dapat menghasilkan pengguna. Kita akan mulai dengan menciptakan sebuah antarmuka pengguna dan user model.

1
// app/models/UserInterface.php
2
3
<?php
4
5
interface UserInterface {
6
7
}

UserInterface kami tidak benar-benar mendefinisikan implementasi metode apapun, karena ini adalah hanya sebuah contoh. Untuk aplikasi dunia nyata, Anda akan menentukan cara-cara yang Anda harapkan pada model Anda.

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
}

Sekarang bahwa kita memiliki model User kami mengimplementasikan UserInterface kami, kita dapat melanjutkan untuk men-setup dependency kita pada perintah kami. Aku akan menambahkan sedikit lebih ke kami menghasilkan perintah, dan berinteraksi dengan User model yang di-inject.

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
}

Hal pertama yang harus Anda perhatikan adalah bahwa perintah sekarang memiliki konstruktor. Konstruktor ini menerima parameter tunggal dan kami telah jenis mengisyaratkan UserInterface, jadi kita tahu bahwa kita mendapatkan kelas mengimplementasikan metode didefinisikan pada antarmuka. Perintah konstruktor juga harus memanggil constructor induk.

Dalam metode fire perintah, kita langsung menetapkan properti di User model instance. Kami juga menggunakan loop terus meminta pengguna jika mereka telah memasuki usia mereka dengan benar. Terakhir, pengguna disimpan ke database dan kita output ke konsol bahwa pengguna dibuat dan disimpan.

Tapi tunggu! Sebelum kita dapat menggunakan perintah, kita perlu inject instance model User kami.

1
// app/start/artisan.php

2
3
$user = new User;
4
5
$artisan->add(new UserGeneratorCommand($user));

Jika Anda memiliki database setup dan dikonfigurasi dengan benar, Anda sekarang harus mampu jalankan perintah dan memiliki pengguna baru disimpan ke database!


Paket perintah

Jika Anda mengembangkan sebuah paket di Laravel, Anda mungkin ingin untuk memasukkan perintah. Mendaftar perintah dari paket adalah sebagian besar proses yang sama, kecuali Anda tidak (atau tidak) menambahkan perintah di app/start/artisan.php. Sebaliknya, Anda menyelesaikan mereka dengan Artisan dari dalam package service provider.

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
}

Metode commands dapat menerima sejumlah argumen, dan akan menyelesaikan perintah dari wadah aplikasi saat Artisan dimulai.


Kesimpulan

Ketika Anda membandingkan Artisan dalam Laravel 4 dan Laravel 3, Anda akan segera menemukan bahwa perbaikan monumental. Perintah dapat sekarang terikat ke wadah IoC dan meliputi injeksi ketergantungan, memberikan berwarna ANSI output, menggunakan argumen dan pilihan, dan meminta interaksi pengguna.

Kekuatan Artisan, berkat Symfony di konsol komponen, luar biasa. Perintah akan memainkan peran besar, seperti yang kita bergerak maju - sehingga mendapatkan di awal!

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.