Salah satu alat terpenting bagi sebagian besar sysadmin adalah otomatisasi. Kami menulis dan memelihara skrip untuk mengotomatiskan tugas umum dan sering yang harus kami lakukan.
Saya memiliki lusinan skrip—pendek dan panjang—yang telah saya tulis dan modifikasi selama bertahun-tahun. Beberapa skrip saya yang paling berguna adalah melakukan pencadangan rutin setiap pagi, menginstal paket perangkat lunak yang diperbarui dengan perbaikan dan penyempurnaan, dan meningkatkan dari satu versi Fedora ke versi berikutnya. Saya baru saja memutakhirkan semua host dan server pribadi saya ke Fedora 34 beberapa hari yang lalu menggunakan skrip yang cukup sederhana.
[ Anda mungkin juga menyukai: Trik Bash yang lebih bodoh:Variabel, temukan, deskriptor file, dan operasi jarak jauh ]
Dua hal paling umum yang saya lakukan untuk semua skrip saya adalah membuat fungsi bantuan dan fungsi yang menampilkan pernyataan lisensi GPL3. Saya suka memasukkan mode verbose atau uji untuk membantu dalam penentuan masalah dalam skrip saya. Dalam beberapa skrip, saya juga memberikan nilai seperti nama pengguna, versi Fedora yang akan ditingkatkan, nama file, dan lainnya.
Kemampuan untuk menggunakan parameter posisi—atau dikenal sebagai argumen—untuk menentukan data yang akan digunakan sebagai nilai untuk variabel dalam skrip adalah salah satu metode untuk mencapai hal ini. Lain adalah penggunaan opsi dan argumen opsi. Artikel ini membahas dua metode ini untuk memasukkan data ke dalam skrip dan mengontrol jalur eksekusi skrip.
Parameter posisi
Bash menggunakan alat yang disebut parameter posisi untuk menyediakan sarana memasukkan data ke dalam program Bash ketika dipanggil dari baris perintah. Ada sepuluh parameter posisi yang dijalankan dari $0 melalui $9 , meskipun ada cara untuk mengatasi batas tersebut.
Dimulai dengan skrip sederhana yang menampilkan nama yang dimasukkan di layar. Buat file bernama script1.sh dengan konten berikut dan membuatnya dapat dieksekusi.
#!/bin/bash
echo $0
Saya menempatkan skrip ini di ~/bin directory saya , tempat file pribadi yang dapat dieksekusi seperti skrip dimaksudkan untuk disimpan. Lihat $PATH . Anda variabel, yang berisi /home/username/bin sebagai salah satu komponen. Jika ~/bin direktori tidak ada, Anda dapat membuatnya. Atau Anda bisa meletakkan file ini di mana pun Anda mau dan menggunakannya dari sana.
Kemudian jalankan skrip tanpa parameter.
[student@testvm1 ~]$ script1.sh
/home/dboth/bin/script1.sh
[student@testvm1 ~]$ Output dari script ini adalah nama script. $0 parameter dicadangkan dan ditentukan sebelumnya sebagai nama skrip yang berjalan dan tidak dapat digunakan untuk tujuan lain apa pun. Ini dapat berguna di dalam skrip karena Anda tidak perlu meneruskan skrip dengan namanya sendiri jika diperlukan.
Jadi ubah skrip untuk menggunakan $1 untuk variabel posisi, dan jalankan lagi:
#!/bin/bash
echo $1 Jalankan lagi, kali ini menggunakan satu parameter:
[student@testvm1 ~]$ script1.sh help
help
[student@testvm1 ~]$ Apa yang terjadi jika parameternya terdiri dari dua kata?
[student@testvm1 ~]$ script1.sh help me
help
[student@testvm1 ~]$ Itu sebenarnya dua parameter, tetapi Anda dapat memperbaikinya dengan tanda kutip, seperti yang terlihat di sini:
[student@testvm1 ~]$ script1.sh "help me"
help me
[student@testvm1 ~]$ Ini dapat membantu jika inputnya berupa alamat jalan atau sesuatu dengan banyak kata, seperti ini:
[student@testvm1 ~]$ script1.sh "80486 Intel St."
80486 Intel St.
[student@testvm1 ~]$ Namun ada kalanya Anda memerlukan beberapa parameter, seperti dengan nama atau alamat lengkap.
Ubah programnya menjadi seperti ini:
#!/bin/bash
echo "Name: $1"
echo "Street: $2"
echo "City: $3"
echo "State/Province/Territory: $4"
echo "Zip/Postal code: $5" Dan jalankan menggunakan parameter seperti yang ditunjukkan:
[student@testvm1 ~]$ script1.sh "David Both" "80486 Intel St." Raleigh NC XXXXX
Name: David Both
Street: 80486 Intel St.
City: Raleigh
State/Province/Territory: NC
Zip/Postal code: XXXXX Tentu saja, ada banyak cara untuk menggunakan parameter posisi setelah nilai ditetapkan, tetapi program kecil ini memudahkan untuk melihat apa yang terjadi. Ini juga memudahkan eksperimen dengan cara yang aman.
Coba letakkan parameter dalam urutan yang berbeda untuk melihat cara kerjanya. Parameter ini bersifat posisional, dan itu adalah pertimbangan utama. Anda harus mempertimbangkan berapa banyak parameter yang diperlukan, bagaimana pengguna mengingatnya, dan urutan penempatannya.
Anda memerlukan cara untuk membuat urutan parameter tidak relevan dan masih memerlukan cara untuk mengubah jalur eksekusi.
Opsi
Anda dapat melakukan dua hal tersebut menggunakan opsi baris perintah.
Saya menemukan bahwa bahkan program Bash sederhana harus memiliki semacam fasilitas bantuan, meskipun itu cukup sederhana. Banyak program shell Bash yang saya tulis cukup jarang digunakan sehingga saya mungkin lupa sintaks persis dari perintah yang perlu saya keluarkan. Beberapa sangat rumit sehingga saya perlu meninjau opsi dan argumen yang diperlukan meskipun saya sering menggunakannya.
Memiliki fungsi bantuan bawaan memungkinkan Anda untuk melihat hal-hal tersebut tanpa harus memeriksa kode itu sendiri. Fasilitas bantuan yang baik dan lengkap juga merupakan salah satu bagian dari dokumentasi program.
Tentang fungsi
Fungsi shell adalah daftar pernyataan program Bash yang disimpan di lingkungan shell dan dapat dijalankan seperti perintah lainnya dengan mengetikkan namanya di baris perintah. Fungsi shell mungkin juga dikenal sebagai prosedur atau subrutin, tergantung pada bahasa pemrograman lain yang mungkin Anda gunakan.
Fungsi dipanggil dalam skrip Anda atau dari CLI dengan menggunakan namanya, seperti yang Anda lakukan untuk perintah lainnya. Dalam program atau skrip CLI, perintah dalam fungsi dijalankan saat dipanggil. Kemudian urutan aliran program kembali ke entitas pemanggil, dan rangkaian pernyataan program berikutnya di entitas tersebut dieksekusi.
Sintaks suatu fungsi adalah:
NamaFungsi(){pernyataan program}
Buat fungsi sederhana di CLI. Fungsi tersebut disimpan di lingkungan shell untuk instance shell di mana ia dibuat. Anda akan membuat fungsi bernama hw , yang merupakan singkatan dari Halo dunia . Masukkan kode berikut di CLI dan tekan Enter . Kemudian masukkan hw seperti yang Anda lakukan pada perintah shell lainnya.
[student@testvm1 ~]$ hw(){ echo "Hi there kiddo"; }
[student@testvm1 ~]$ hw
Hi there kiddo
[student@testvm1 ~]$ Oke, jadi saya sedikit bosan dengan standar "Halo dunia!" Saya biasanya memulai dengan. Sekarang daftarkan semua fungsi yang saat ini ditentukan. Ada banyak sekali, jadi saya hanya menunjukkan hw . yang baru fungsi. Ketika dipanggil dari baris perintah atau dalam suatu program, suatu fungsi melakukan tugas terprogramnya. Kemudian keluar, mengembalikan kontrol ke entitas panggilan, baris perintah, atau pernyataan program Bash berikutnya dalam skrip setelah pernyataan panggilan.
[student@testvm1 ~]$ declare -f | less
<snip>
hw ()
{
echo "Hi there kiddo"
}
<snip>
Sekarang hapus fungsi itu karena Anda tidak membutuhkannya lagi. Anda dapat melakukannya dengan unset perintah, seperti ini:
[student@testvm1 ~]$ unset -f hw ; hw
bash: hw: command not found
[student@testvm1 ~]$ Skrip hello.sh
Buat skrip shell Bash baru, ~/bin/hello.sh , dan membuatnya dapat dieksekusi. Tambahkan konten berikut, jaga agar tetap dasar untuk memulai:
#!/bin/bash
echo "hello world!" Jalankan untuk memverifikasi bahwa itu mencetak "hello world!".
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$ Saya tahu—saya tidak bisa menahan diri, jadi saya kembali ke "hello world!".
Membuat fungsi bantuan
Tambahkan bantuan fungsi yang ditunjukkan di bawah ini untuk kode program hello. Tempatkan bantuan fungsi antara dua pernyataan yang sudah Anda miliki. bantuan . ini fungsi akan menampilkan deskripsi singkat tentang program, diagram sintaks, dan deskripsi singkat dari setiap opsi yang tersedia. Anda juga menambahkan panggilan ke bantuan fungsi untuk mengujinya dan beberapa baris komentar yang memberikan demarkasi visual antara fungsi dan bagian utama program.
Programnya sekarang terlihat seperti ini.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
Help
echo "Hello world!" Opsi yang dijelaskan dalam bantuan . ini fungsi mungkin khas dalam program yang saya tulis, meskipun belum ada yang ada dalam kode. Jalankan program untuk mengujinya.
[student@testvm1 ~]$ hello.sh
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.
Hello world!
[student@testvm1 ~]$
Karena Anda belum menambahkan logika apa pun untuk menampilkan bantuan saat Anda menginginkannya, program akan selalu menampilkan bantuan. Namun, Anda tahu bahwa fungsi tersebut berfungsi dengan benar, sehingga Anda dapat menambahkan beberapa logika hanya untuk menampilkan bantuan saat Anda menggunakan -h pilihan pada permintaan baris perintah program.
Opsi penanganan
Kemampuan skrip Bash untuk menangani opsi baris perintah seperti -h untuk menampilkan bantuan memberi Anda beberapa kemampuan yang kuat untuk mengarahkan program dan memodifikasi apa yang dilakukannya. Dalam hal -h . Anda opsi, Anda ingin program mencetak teks bantuan ke sesi terminal, lalu keluar tanpa menjalankan sisa program. Kemampuan untuk memproses opsi yang dimasukkan pada baris perintah dapat ditambahkan ke skrip Bash menggunakan while perintah dalam hubungannya dengan getops dan case perintah.
getops perintah membaca setiap dan semua opsi yang ditentukan pada baris perintah dan membuat daftar opsi tersebut. while perintah loop melalui daftar opsi dengan menyetel variabel $options untuk masing-masing kode di bawah ini. case pernyataan digunakan untuk mengevaluasi setiap opsi secara bergantian dan mengeksekusi pernyataan dalam bait yang sesuai. while pernyataan akan terus menilai daftar opsi sampai semuanya diproses atau pernyataan keluar ditemukan, yang menghentikan program.
Pastikan untuk menghapus bantuan panggilan fungsi tepat sebelum gema "Halo dunia!" pernyataan sehingga bagian utama program sekarang terlihat seperti ini.
############################################################
############################################################
# Main program #
############################################################
############################################################
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
esac
done
echo "Hello world!"
Perhatikan titik koma ganda di akhir pernyataan keluar dalam opsi kasus untuk -h . Ini diperlukan untuk setiap opsi. Tambahkan ke pernyataan kasus ini untuk menggambarkan akhir setiap opsi.
Pengujian sekarang sedikit lebih kompleks. Anda perlu menguji program Anda dengan beberapa opsi berbeda—dan tanpa opsi—untuk melihat bagaimana responsnya. Pertama, periksa untuk memastikan bahwa tanpa opsi yang dicetak "Hello world!" sebagaimana mestinya.
[student@testvm1 ~]$ hello.sh
Hello world! Itu berhasil, jadi sekarang uji logika yang menampilkan teks bantuan.
[student@testvm1 ~]$ hello.sh -h
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|t|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit. Itu berfungsi seperti yang diharapkan, jadi sekarang coba beberapa pengujian untuk melihat apa yang terjadi saat Anda memasukkan beberapa opsi yang tidak terduga.
[student@testvm1 ~]$ hello.sh -x
Hello world!
[student@testvm1 ~]$ hello.sh -q
Hello world!
[student@testvm1 ~]$ hello.sh -lkjsahdf
Add a description of the script functions here.
Syntax: scriptTemplate [-g|h|t|v|V]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.
[student@testvm1 ~]$ Menangani opsi yang tidak valid
Program mengabaikan opsi yang belum Anda buat tanggapan spesifiknya tanpa menghasilkan kesalahan apa pun. Meskipun di entri terakhir dengan -lkjsahdf pilihan, karena ada "h" dalam daftar, program mengenalinya dan mencetak teks bantuan. Pengujian telah menunjukkan bahwa satu hal yang hilang adalah kemampuan untuk menangani input yang salah dan menghentikan program jika ada yang terdeteksi.
Anda dapat menambahkan bait kasus lain ke pernyataan kasus yang akan cocok dengan opsi apa pun yang tidak ada kecocokannya secara eksplisit. Kasus umum ini akan cocok dengan apa pun yang belum Anda berikan kecocokan khusus. kasus pernyataan sekarang terlihat seperti ini.
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done Sedikit kode ini layak mendapatkan penjelasan tentang cara kerjanya. Tampaknya rumit tetapi cukup mudah dipahami. sementara – selesai struktur mendefinisikan loop yang dijalankan sekali untuk setiap opsi di getopts – opsi struktur. ":h" string —yang memerlukan tanda kutip—mencantumkan kemungkinan opsi input yang akan dievaluasi oleh case – esac struktur. Setiap opsi yang terdaftar harus memiliki bait yang sesuai dalam pernyataan kasus. Dalam hal ini, ada dua. Salah satunya adalah h) bait yang memanggil prosedur Bantuan. Setelah prosedur Bantuan selesai, eksekusi kembali ke pernyataan program berikutnya, exit;; yang keluar dari program tanpa mengeksekusi kode lagi meskipun ada beberapa kode. Loop pemrosesan opsi juga dihentikan, jadi tidak ada opsi tambahan yang akan diperiksa.
Perhatikan pertandingan menangkap semua \? sebagai bait terakhir dalam pernyataan kasus. Jika ada opsi yang dimasukkan yang tidak dikenali, bait ini mencetak pesan kesalahan singkat dan keluar dari program.
Kasus khusus tambahan apa pun harus mendahului penampung-semua akhir. Saya suka menempatkan bait kasus dalam urutan abjad, tetapi akan ada keadaan di mana Anda ingin memastikan bahwa kasus tertentu diproses sebelum kasus tertentu lainnya. Pernyataan kasus peka terhadap urutan, jadi berhati-hatilah saat menyusunnya.
Pernyataan terakhir setiap bait dalam konstruk kasus harus diakhiri dengan titik koma ganda (;; ), yang digunakan untuk menandai akhir setiap bait secara eksplisit. Hal ini memungkinkan programmer yang suka menggunakan titik koma eksplisit untuk akhir setiap pernyataan alih-alih yang implisit untuk terus melakukannya untuk setiap pernyataan dalam setiap bait kasus.
Uji kembali program menggunakan opsi yang sama seperti sebelumnya dan lihat cara kerjanya sekarang.
Skrip Bash sekarang terlihat seperti ini.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done
echo "hello world!"
Pastikan untuk menguji versi program Anda ini dengan sangat teliti. Gunakan input acak dan lihat apa yang terjadi. Anda juga harus mencoba menguji opsi yang valid dan tidak valid tanpa menggunakan tanda hubung (- ) di depan.
Menggunakan opsi untuk memasukkan data
Pertama, tambahkan variabel dan inisialisasi. Tambahkan dua baris yang ditunjukkan dalam huruf tebal di segmen program yang ditunjukkan di bawah ini. Ini menginisialisasi $Name variabel ke "dunia" sebagai default.
<snip>
############################################################
############################################################
# Main program #
############################################################
############################################################
# Set variables
Name="world"
############################################################
# Process the input options. Add options as needed. #
<snip>
Ubah baris terakhir program, echo perintah, untuk ini.
echo "hello $Name!" Tambahkan logika untuk memasukkan nama dalam beberapa saat tetapi pertama-tama uji program lagi. Hasilnya harus sama persis seperti sebelumnya.
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$
# Get the options
while getopts ":hn:" option; do
case $option in
h) # display Help
Help
exit;;
n) # Enter a name
Name=$OPTARG;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done $OPTARG selalu merupakan nama variabel yang digunakan untuk setiap argumen opsi baru, berapa pun jumlahnya. Anda harus menetapkan nilai di $OPTARG ke nama variabel yang akan digunakan di sisa program. Bait baru ini tidak memiliki pernyataan keluar. Ini mengubah alur program sehingga setelah memproses semua opsi yang valid dalam pernyataan kasus, eksekusi berpindah ke pernyataan berikutnya setelah konstruksi kasus.
Uji program yang direvisi.
[dboth@david ~]$ hello.sh
hello world!
[dboth@david ~]$ hello.sh -n LinuxGeek46
hello LinuxGeek46!
[dboth@david ~]$ hello.sh -n "David Both"
hello David Both!
[dboth@david ~]$ Program yang telah selesai terlihat seperti ini.
#!/bin/bash
############################################################
# Help #
############################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
############################################################
############################################################
# Main program #
############################################################
############################################################
# Set variables
Name="world"
############################################################
# Process the input options. Add options as needed. #
############################################################
# Get the options
while getopts ":hn:" option; do
case $option in
h) # display Help
Help
exit;;
n) # Enter a name
Name=$OPTARG;;
\?) # Invalid option
echo "Error: Invalid option"
exit;;
esac
done
echo "hello $Name!" Pastikan untuk menguji fasilitas bantuan dan bagaimana program bereaksi terhadap input yang tidak valid untuk memverifikasi bahwa kemampuannya untuk memproses input tersebut tidak terganggu. Jika semuanya berfungsi sebagaimana mestinya, maka Anda telah berhasil mempelajari cara menggunakan opsi dan argumen opsi.
[ Dapatkan ebook gratis ini:Mengelola kluster Kubernetes Anda untuk boneka. ]
Menutup
Dalam artikel ini, Anda telah menggunakan parameter posisi untuk memasukkan data ke dalam program Bash selama pemanggilan dari baris perintah dan menggunakan opsi untuk mengarahkan aliran program serta memasukkan data ke dalam program. Anda menambahkan fungsi bantuan dan kemampuan untuk memproses opsi baris perintah untuk menampilkan bantuan secara selektif. Dan Anda menambahkan argumen opsional yang memungkinkan memasukkan nama di baris perintah.
Program pengujian kecil ini dirancang sederhana, sehingga Anda dapat dengan mudah bereksperimen sendiri untuk menguji metode masukan ini sendiri. Sebagai latihan, revisi program untuk mengambil nama depan dan nama belakang. Coba masukkan opsi untuk nama depan dan belakang dalam urutan terbalik untuk melihat apa yang terjadi.
Sumber daya
- Cara memprogram dengan Bash:Sintaks dan alat
- Cara memprogram dengan Bash:Operator logika dan ekspansi shell
- Cara memprogram dengan Bash:Loop