Paano Magpatupad ng Mga Utos mula sa loob ng isang Shell Script

Sa bash, ang pagpapatupad ng mga utos mula sa isang shell script ay maaaring maging isang maliit na pananakot sa una at maaaring mangailangan ng isang paglukso ng pananampalataya. Pagkatapos ng lahat, ang mga utos na naisakatuparan sa loob ng isang bash script ay hindi interactive. Dito namin ilalagay ang pundasyon upang magpatupad ng mga utos mula sa loob ng isang shell script na sinasagot ang mga sumusunod na katanungan tungkol sa mga utos: Saan nagmula ito? Ano sila Paano natin magagamit ang mga ito sa isang iskrip?

Saan nagmula ang mga utos?

Ang mga utos sa bash ay nagmula sa alinman sa mga sumusunod na kategorya:

Bash mismo (tingnan ang mga builtin)

Ang Bash ay may sariling hanay ng mga utos upang payagan ang pag-access sa mga built-in na tampok tulad ng pagdedeklara ng mga array, mga linya ng pagbabasa mula sa isang file, at iba pang mga tampok na builtin sa bash. Tumawag kami ng mga utos ng kategoryang ito, bash builtin na mga utos, o maikling builtin para sa maikling salita.

Mapapatupad sa iyong kapaligiran (tingnan ang mga panlabas na utos)

Bilang default, magmamana ang bash ng ilang mga variable bilang default. Ito ay sinusunod sa kaso ng variable na PATH kabilang ang mga lokasyon para sa mga maipapatupad na isinangguni bilang panlabas na utos sa bash. Iyon ay, kung ang kulot Ang utos ay nasa iyong landas, maaari itong maipatupad mula sa loob ng isang bash script sa parehong paraan tulad ng sa interactive mode. Tumawag kami ng mga utos ng kategoryang ito, mga panlabas na utos, o utos para sa maikli.

Pag-andar na tinukoy ng gumagamit (tingnan ang mga pagpapaandar)

Bago ipatupad ang mga panlabas na utos at builtin, bash check kung ang isang pagpapaandar ay tinukoy. Kung ito ang pagpapaandar ay naisakatuparan bilang isang utos. Kung hindi, nagpapatuloy ito sa pagkakasunud-sunod para sa mga utos. Upang maipatupad ang pagpapaandar na tinukoy sa labas ng isang script, dapat itong ideklara na may katangiang -x; kung hindi man, maaari silang isama gamit ang. Utos. Tinatawagan namin ang mga utos ng kategoryang ito ng mga pagpapaandar na tinukoy ng gumagamit para sa maikling.

Ano ang mga utos

Ang isang utos ay anumang salita na dapat tratuhin bilang isang solong punto ng pagpasok ng isang programa sa loob ng kapaligiran ng shell. Sa kaso na ang utos ay naisakatuparan, ang utos mismo at ang mga opsyonal na argumento ay ipinapasa bilang mga posisyonal na parameter, $ {0}, $ {1}, $ {2},… Ang zeroth posisyonal na parameter ($ {0}) ay tumutukoy sa utos mismo at hindi nagbabago sa konteksto. Iyon ay, hindi katulad ng mga posisyong parameter sa mga pag-andar, $ {1}, $ {2},… na maaaring magbago depende sa konteksto, ang $ {0} ay hindi nagbabago sa pagitan ng mga tawag sa pag-andar.

Sinusuportahan ang mga utos depende sa lokasyon ng deklarasyon at mga katangian na itinalaga bilang pandaigdigan, built-in na bash, o lokal sa iyong bash program.

Narito ang isang listahan ng mga uri ng utos upang malaman.

Mga utos ng Builtin

Ito ang mga unang-mamamayan ng bash uniberso, kabilang ang mga character tulad ng '.' ':' '[' ']' At nakareserba na mga salita tulad ng ideklara sa bash. Inaasahan mo ang mga utos na ito, na nilalaman sa listahan ng mga bash builtin na utos, na magagamit upang magamit sa loob ng iyong bash script.

Nakasalalay sa pagtatalaga at numero ng bersyon ng iyong bash interpreter ilang mga utos ay maaaring hindi magagamit.

Panlabas na utos

Ang mga panlabas na utos ay maipapatupad na naa-access sa labas ng isang bash script tulad ng curl. Hindi tulad ng mga pagpapaandar, ang mga panlabas na utos ay hindi naiimbak bilang mga variable.

Ang mas mababang pag-una ng isang uri ng utos, sa paglaon ang utos ay maaaring bigyang kahulugan. Ang mga panlabas na utos ay may pinakamababang pagkakasunud-sunod ng pag-una sa bash. Iyon ay bago magpatakbo ng isang panlabas na utos, ang interpreter bash, ay maghahanap ng mga pagpapaandar, pagkatapos ay i-builtin, at sa wakas ay subukan upang makita kung ang isang utos ay umiiral sa panlabas. Kung hindi, dapat mong makita ang sumusunod na error.

bash: hindi alam-utos:utoshindi mahanap

Sa isang bash script, ang mga pagpapaandar ay maaaring mag-override ng panlabas na pag-uugali ng utos kung pagbabahagi ng parehong pangalan tulad ng nakita natin dati sa mga halimbawa ng curl bash. Ang isang halimbawa ng isang pasadyang panlabas na utos na gumagamit ng isang function ay sumusunod.

kulot() {
utos $ {FUNCNAME}...
}

Gumagana ito dahil ang mga pag-andar ay may mas mataas na precedence kaysa sa mga panlabas na utos at kahit na ang mga built-in na bash. Ang limitasyon ay pinapayagan ang mga character sa isang pangalan ng pag-andar.

Tandaan na ang halimbawa sa itaas ay maaaring magawa gamit ang isang alias tulad ng sumusunod.

alyas kulot= ’
{
kulot ...
}
'

Sa kaso ng mga alias, ang uri ng utos ay maaaring magkakaiba depende sa konteksto sa pagpapatupad, samantalang sa kaso ng pasadyang panlabas na mga utos na gumagamit ng paraan ng pag-andar, ang puntong entry ay palaging isang pagpapaandar.

Mga pagpapaandar

Ang mga pagpapaandar na panuntunan sa bash. Bago tingnan ang mga builtin at panlabas na utos, bash check kung ang isang pagpapaandar na tinukoy ng isang pangalan ng pag-andar ng kandidato, ang unang salitang lumilitaw sa isang linya o pagkatapos ng; pagtatalaga ng character sa pagtatapos ng isang linya ng utos. Ang tanging pagbubukod ay ang mga bash variable na nakasulat sa lahat ng mga cap tulad ng $ {FUNCNAME}.

alyas() { FUNCNAME= asdf;itinapon $ {@ ,,};}
alyas kulot='TEST CURL ALIAS' #?

Mga simpleng utos

Ang mga simpleng utos ay tinukoy sa mga pahina ng bash man bilang isang salita na sinusundan ng mga opsyonal na argumento. Sa konteksto, ang isang simpleng utos ay maaaring alinman sa isang builtin, panlabas na utos, o pag-andar.

Paano magpatupad ng mga utos mula sa loob ng isang bash script

Ngayong alam na natin kung anong mga uri ng mga utos ang magagamit, maaari kaming mapalawak sa kung paano gamitin ang mga ito sa iyong mga script. Una, kakailanganin nating malaman kung paano gumagana ang precedence ng utos sa bash.

Narito ang ilang mga paraan upang makontrol ang precedence sa isang bash script.

Hayaan bash magpasya

command_name

Para sa pinaka-bahagi, lalo na sa simula, hinayaan lang namin ang bash na magpasya kung aling utos ang gagamitin. Gayunpaman, may mga kaso kung ang iyong hangarin ay maaaring hindi maipaliwanag nang tama sa pamamagitan ng bash. Ganoon ang kaso kapag ang mga pangalan ng pag-andar at panlabas na mga utos o builtins ay nagsasapawan.

Isagawa ang isang panlabas na utos

utoscommand_name

Ipagpalagay na mayroong isang panlabas na command_name na magagamit sa interactive mode at nais mong gamitin ito sa isang bash script. Malinaw naming masasabi sa bash na ang command_name ay isang panlabas na utos na gumagamit ng built-in na utos.

Mga halimbawa ng panloob na utos

Ang mga panlabas na halimbawa ng utos na ipinapalagay na ang mga sumusunod ay naka-install:

file
punta ka na
bukol

Halimbawa: Kumuha ng uri ng file at impormasyon

{ # makakuha ng uri ng file at impormasyon
file $ {infile} # (1,2)
}
# (1) utos, file
# (2) infile = {Path to file}

Halimbawa: Nabago ang yugto at mga bagong file sa git

{ # yugto ng mga file sa git
git idagdag.# (1)
}
# (1) utos, git

Halimbawa: Lumikha ng Alexa art gamit ang figlet

{ # lumikha ng arte ng ascii
bukol$ {mensahe} # (1,2)
}
# (1) utos, tula
# (2) mensahe = {Mensahe upang ipakita bilang Alexa art}

Isagawa ang isang builtin na utos

builtincommand_name

Ipagpalagay na ang command_name ay isa sa mga utos na tinukoy bilang isang builtin in bash. Upang ipaalam sa bash na nais naming patakbuhin ang command_name bilang isang builtin ginagamit namin ang builtin builtin.

Mga halimbawa ng utos na naka-built

Halimbawa: Ilan ang mga builtin?

builtin{,}{,,}{,,,} # ilan builtin?

Halimbawa: Ipinahayag ng multo

{
magpahayag() { itinaponoops!;}
magpahayag–Xfmagpahayag #?
}

Konklusyon

Ito ay medyo madali upang magpatupad ng isang utos mula sa loob ng isang bash shell script. Mayroong tatlong pangunahing uri ng utos. Ang pag-alam kung paano binibigyang diin ang simpleng mga utos sa bash ay maaaring humantong sa pinabuting kontrol sa kung anong uri ng utos ang naisakatuparan sa runtime.