Pengenalan kepada Ekspansi Parameter Shell Bash

Shell adalah bahagian penting dari sistem operasi berasaskan Unix dan merupakan antara muka utama yang boleh kita gunakan untuk berinteraksi dengan sistem itu sendiri. Bash adalah tanpa keraguan shell yang paling banyak digunakan pada majoriti pengagihan Linux: ia dilahirkan sebagai pengganti perisian bebas untuk Bourne Shell (Bash adalah akronim untuk bourne-aliin shell) di dalam projek GNU. Dalam tutorial ini, kita akan mengetahui bagaimana beberapa pengembangan bash yang paling berguna berfungsi.

Sekiranya anda belum biasa dengan Bash, atau anda hanya perlu menyegarkan ingatan anda, maka anda disyorkan untuk melawat tutorial skrip bash kami untuk pemula, sebelum anda menyelam ke dalam konsep pengembangan bash shell di bawah.

Dalam tutorial ini anda akan belajar:

• Cara Menggunakan Pelbagai Ekspansi Parameter Bash

Keperluan perisian dan konvensyen yang digunakan

Pengembangan yang paling mudah

Sintaks pengembangan parameter yang paling mudah adalah seperti berikut:

$ parameter

Apabila kita menggunakan sintaks ini, parameter digantikan dengan nilainya. Mari lihat contoh:

$ site = "linuxconfig.org "$ echo" $ site "linuxconfig.org

Kami mencipta tapak pemboleh ubah dan diberikan "Linuxconfig.org " rentetan kepadanya. Kami kemudian menggunakan echo perintah untuk memaparkan hasil pengembangan pembolehubah. Menjadi ini pengembangan asas, ia akan berfungsi walaupun tanpa menggunakan pendakap keriting sekitar nama pembolehubah:

$ echo "$ site" linuxconfig.org

Mengapa kita menggunakan pendakap keriting kemudian? Pendakap keriting, ketika melakukan ekspansi parameter, digunakan untuk membatasi nama pembolehubah:

$ echo "Anda sedang membaca artikel ini pada $ site_!"Anda membaca artikel ini di

Apa yang berlaku? Oleh kerana nama berubah tidak dibatasi, _ watak dianggap sebagai sebahagian daripadanya. Shell cuba mengembangkan thenon-wujud $ site_ berubah -ubah, oleh itu tidak ada yang dikembalikan. Membungkus pembolehubah dengan pendakap keriting menyelesaikan masalah ini:

$ echo "Anda sedang membaca artikel ini di $ site _!"Anda membaca artikel ini di linuxconfig_!

Walaupun penggunaan pendakap keriting tidak selalu diperlukan dengan pengembangan parameter asas, adalah wajib untuk melaksanakan semua pengembangan lain yang akan kita lihat dalam artikel ini.

Sebelum meneruskan, izinkan saya memberi anda satu tip. Dalam contoh di atas shell cuba mengembangkan pemboleh ubah yang tidak sedia ada, menghasilkan hasil kosong. Ini boleh menjadi sangat berbahaya, terutama ketika bekerja dengan nama jalan, oleh itu, ketika menulis skrip, selalu disyorkan untuk menggunakan kata nama Pilihan yang menyebabkan shell keluar dengan ralat apabila pembolehubah yang tidak ada dirujuk:

$ SET -O NOUNSET $ ECHO "Anda sedang membaca artikel ini pada $ site_!"Bash: site_: pemboleh ubah yang tidak terikat

Bekerja dengan ketidakpuasan

Penggunaan $ !parameter sintaks, menambah tahap pengindeksan kepada pengembangan parameter kami. Apakah maksudnya? Parameter yang akan dicoba oleh shell tidak parameter ; sebaliknya ia akan cuba menggunakan nilai parameter sebagai nama pemboleh ubah yang akan diperluas. Mari kita jelaskan ini dengan contoh. Kita semua tahu Rumah Pembolehubah mengembang di jalan direktori rumah pengguna dalam sistem, betul?

$ echo "$ home" /home /egdoc

Sangat baik, jika sekarang kita menetapkan rentetan "rumah", kepada pemboleh ubah lain, dan gunakan jenis pengembangan ini, kami memperoleh:

$ variable_to_inspect = "home" $ ​​echo "$ !variable_to_inspect " /home /egdoc

Seperti yang anda dapat lihat dalam contoh di atas, bukannya mendapatkan "rumah" sebagai hasilnya, kerana ia akan berlaku jika kita melakukan pengembangan yang mudah, shell menggunakan nilai variable_to_inspect Sebagai nama pembolehubah untuk berkembang, itulah sebabnya kita bercakap mengenai tahap ketidakhadiran.

Pengembangan pengubahsuaian kes

Sintaks pengembangan parameter ini Mari kita ubah kes aksara abjad di dalam rentetan yang terhasil daripada pengembangan parameter. Katakan kita mempunyai pemboleh ubah yang dipanggil nama; untuk memanfaatkan teks yang dikembalikan oleh pengembangan pembolehubah kami akan menggunakan $ parameter^ sintaks:

$ name = "egidio" $ echo "$ name^" egidio

Bagaimana jika kita mahu mengikat keseluruhan rentetan, bukannya memanfaatkannya? Mudah! Kami menggunakan $ parameter ^^ sintaks:

$ echo "$ name ^^" egidio

Begitu juga, untuk mengurangkan huruf pertama rentetan, kami menggunakan $ parameter, sintaks pengembangan:

$ name = "egidio" $ echo "$ name," egidio

Untuk mengundurkan keseluruhan rentetan, sebaliknya, kami menggunakan $ parameter ,, sintaks:

$ name = "egidio" $ echo "$ name ,," egidio

Dalam semua kes a corak untuk memadankan satu watak juga boleh disediakan. Apabila corak disediakan, operasi hanya digunakan untuk bahagian -bahagian rentetan asal yang sesuai dengannya:

$ name = "egidio" $ echo "$ name ,, [dio]" egidio

Dalam contoh di atas, kami melampirkan watak -watak dalam kurungan persegi: ini menyebabkan sesiapa dari mereka dipadankan sebagai corak.

Apabila menggunakan ekspansi yang kami jelaskan dalam perenggan ini dan parameter adalah array yang dilanggan oleh @ atau *, Operasi ini digunakan untuk semua elemen yang terkandung di dalamnya:

$ my_array = (satu dua tiga) $ echo "$ my_array [@] ^^" satu dua tiga

Apabila indeks unsur tertentu dalam array dirujuk, sebaliknya, operasi hanya digunakan untuknya:

$ my_array = (satu dua tiga) $ echo "$ my_array [2] ^^" Tiga

Penyingkiran substring

Sintaks seterusnya yang akan kami periksa membolehkan kami mengeluarkan a corak Dari awal atau dari akhir rentetan yang terhasil daripada pengembangan parameter.

Keluarkan corak sepadan dari awal tali

Sintaks seterusnya yang akan kita periksa, $ parameter#corak, membolehkan kita mengeluarkan a corak daripada permulaan daripada
rentetan yang dihasilkan dari parameter pengembangan:

$ name = "egidio" $ echo "$ name#egi" Dio

Hasil yang sama dapat diperoleh dengan menggunakan "$ parameter ## corak" sintaks, tetapi dengan satu perbezaan penting: bertentangan dengan yang kita gunakan dalam contoh di atas, yang menghilangkan Corak sepadan terpendek Dari awal rentetan, ia menghilangkan terpanjang satu. Perbezaannya kelihatan jelas apabila menggunakan * watak dalam corak:

$ name = "Egidio Dine" $ echo "$ name#*i" Dio Juil

Dalam contoh di atas kami menggunakan * sebagai sebahagian daripada corak yang harus dikeluarkan dari rentetan yang dihasilkan oleh pengembangan nama pembolehubah. Ini kad liar sepadan dengan mana -mana watak, jadi corak itu sendiri diterjemahkan dalam watak "saya 'dan segala -galanya sebelum itu". Seperti yang telah kita katakan, ketika kita menggunakan $ parameter#corak sintaks, corak sepadan terpendek dikeluarkan, dalam kes ini ia adalah "egi". Mari lihat apa yang berlaku apabila kita menggunakan "$ parameter ## corak" sintaks sebaliknya:

$ name = "Egidio Dine" $ echo "$ name ##*i" le

Kali ini corak pemadanan terpanjang dikeluarkan ("Egidio Doci"): Perlawanan paling lama mungkin termasuk 'I' ketiga dan segala -galanya sebelum itu. Hasil pengembangan hanyalah "le".

Keluarkan corak sepadan dari hujung tali

Sintaks yang kita lihat di atas mengeluarkan corak sepadan terpendek atau terpanjang dari awal rentetan. Sekiranya kita mahu corak dikeluarkan dari akhir rentetan, sebaliknya, kita mesti menggunakan $ Parameter%corak atau $ parameter %% corak Ekspansi, untuk menghapuskan, masing -masing, perlawanan terpendek dan terpanjang dari hujung rentetan:

$ name = "Egidio Dine" $ echo "$ name%i*" egidio doc

Dalam contoh ini corak yang kami berikan secara kasar diterjemahkan dalam watak "'I' dan segala -galanya selepas ia bermula dari akhir rentetan". Perlawanan terpendek ialah "Ile", jadi apa yang dikembalikan ialah "Egidio Doc". Jika kita mencuba contoh yang sama tetapi kita menggunakan sintaks yang menghilangkan perlawanan terpanjang yang kita perolehi:

$ name = "Egidio Dine" $ echo "$ name %% I*" Eg

Dalam kes ini, sekali perlawanan terpanjang dikeluarkan, apa yang dikembalikan adalah "misalnya".

Dalam semua ekspansi yang kita lihat di atas, jika parameter adalah array dan ia dilanggan dengan * atau @, Penyingkiran corak yang sepadan digunakan untuk semua elemennya:

$ my_array = (satu dua tiga) $ echo "$ my_array [@]#*o" ne tiga

Cari dan ganti corak

Kami menggunakan sintaks sebelumnya untuk mengeluarkan corak yang sepadan dari awal atau dari akhir rentetan yang terhasil daripada pengembangan parameter. Bagaimana jika kita mahu menggantikan corak dengan sesuatu yang lain? Kita boleh menggunakan $ parameter/corak/string atau $ parameter // corak/string sintaks. Yang pertama hanya menggantikan kejadian pertama corak, yang terakhir semua kejadian:

$ frasa = "kuning adalah matahari dan kuning adalah lemon" $ echo "$ frasa/kuning/merah" merah adalah matahari dan kuning adalah lemon

The parameter (frasa) diperluas, dan perlawanan terpanjang dari corak (kuning) dipadankan terhadapnya. Perlawanan kemudian digantikan oleh yang disediakan tali (Merah). Kerana anda hanya dapat melihat kejadian pertama diganti, jadi lemon tetap kuning! Sekiranya kita mahu mengubah semua kejadian corak, kita mesti awalan dengan / watak:

$ frasa = "kuning adalah matahari dan kuning adalah lemon" $ echo "$ frasa // kuning/merah" merah adalah matahari dan merah adalah lemon

Kali ini semua kejadian "kuning" telah digantikan oleh "merah". Seperti yang anda lihat corak dipadankan di mana sahaja ia terdapat dalam rentetan yang terhasil daripada pengembangan parameter. Sekiranya kita mahu menyatakan bahawa ia mesti dipadankan hanya pada awal atau pada akhir rentetan, kita mesti awalan masing -masing dengan # atau % watak.

Sama seperti dalam kes sebelumnya, jika parameter adalah array yang dilanggan oleh sama ada * atau @, Penggantian berlaku dalam setiap elemennya:

$ my_array = (satu dua tiga) $ echo "$ my_array [@]/o/u" une twu tiga

Pengembangan substring

The $ parameter: offset dan $ parameter: offset: panjang Ekspansi membolehkan kita mengembangkan hanya sebahagian daripada parameter, mengembalikan substring bermula pada yang ditentukan mengimbangi dan panjang watak panjang. Sekiranya panjangnya tidak ditentukan hasil pengembangan sehingga akhir rentetan asal. Jenis pengembangan ini dipanggil pengembangan substring:

$ name = "Egidio Dine" $ echo "$ name: 3" Dio Jucuk

Dalam contoh di atas kami menyediakan hanya mengimbangi, tanpa menentukan panjang, Oleh itu, hasil pengembangan adalah substring yang diperolehi dengan memulakan watak yang ditentukan oleh offset (3).

Sekiranya kita menentukan panjang, substring akan bermula pada mengimbangi dan akan menjadi panjang watak panjang:

$ echo "$ name: 3: 3" Dio 

Jika mengimbangi adalah negatif, ia dikira dari hujung rentetan. Dalam kes ini ruang tambahan mesti ditambah selepas : Jika tidak, cangkang akan menganggapnya sebagai jenis pengembangan lain yang dikenal pasti oleh :- yang digunakan untuk memberikan nilai lalai jika parameter diperluas tidak wujud (kami bercakap mengenainya dalam artikel mengenai menguruskan pengembangan pembolehubah bash kosong atau tidak jelas):

$ echo "$ name: -6" jinak

Jika yang disediakan panjang adalah negatif, bukannya ditafsirkan sebagai jumlah aksara rentetan yang dihasilkan harus panjang, ia dianggap sebagai offset untuk dikira dari akhir rentetan. Oleh itu, hasil pengembangan itu akan menjadi substring bermula pada mengimbangi dan berakhir di panjang Watak dari akhir rentetan asal:

$ echo "$ name: 7: -3" Doc 

Semasa menggunakan pengembangan ini dan parameter adalah array yang diindeks yang dilanggan oleh * atau @, The mengimbangi adalah relatif terhadap indeks unsur array. Sebagai contoh:

$ my_array = (satu dua tiga) $ echo "$ my_array [@]: 0: 2" satu dua $ echo "$ my_array [@]: -2" dua tiga

Negatif panjang , Sebaliknya, menghasilkan ralat pengembangan:

$ echo "$ my_array [@]: 0: -2" bash: -2: ungkapan substring < 0 

Pengembangan "panjang"

Apabila menggunakan $ #parameter pengembangan, hasil pengembangan bukanlah nilai parameter, dengan panjangnya:

$ name = "egidio" $ echo "$ #name" 6

Bila parameter adalah pelbagai, dan ia dilanggan * atau @, Bilangan elemen yang terkandung di dalamnya dikembalikan:

$ my_array = (satu dua tiga) echo "$ #my_array [@]" 3

Apabila elemen spesifik array dirujuk, panjangnya dikembalikan sebaliknya:

$ echo "$ #my_array [2]" 5

Meletakkan semua bersama

Dalam artikel ini kita melihat banyak sintaks ekspansi. Kami melihat bagaimana huruf kecil atau huruf besar huruf pertama rentet Buat parameter diperluas dalam panjang nilainya, bukan nilainya sendiri.

Ini bukan senarai lengkap semua ekspansi yang mungkin kita lakukan dengan Bash: Rujuk dokumentasi GNU jika anda ingin mengetahui lebih lanjut. Dalam artikel yang kami sebutkan juga array bash: Untuk mengetahui lebih lanjut mengenai mereka, anda boleh membaca artikel Bash Arrays kami yang berdedikasi.

Tutorial Linux Berkaitan:

• Perkara yang hendak dipasang di Ubuntu 20.04
• Perkara yang perlu dilakukan setelah memasang ubuntu 20.04 Focal Fossa Linux
• Sistem Hung Linux? Cara melarikan diri ke baris arahan dan ..
• Pengenalan kepada Automasi, Alat dan Teknik Linux
• Perkara yang perlu dilakukan setelah memasang Ubuntu 22.04 Jur -ubur Jammy ..
• Mint 20: Lebih baik daripada Ubuntu dan Microsoft Windows?
• Ubuntu 20.04 Panduan
• Perkara yang perlu dipasang di Ubuntu 22.04
• Pasang Arch Linux di Workstation VMware
• Muat turun linux