Teorya ng Bash

0. Indeks

1. Mga bagay na nangyayari sa karamihan ng mga tao
2. Istraktura ng isang iskrip
3. Mag-print sa screen
4. Basahin ang gumagamit INPUT
5. Mga kalkulasyon sa bash
6. Takda
7. Mga loop
8. Funciones
9. Gettops

1. Mga bagay na nangyayari sa karamihan ng mga tao

/ bin / bash o / bin / sh

Ang isa sa mga unang bagay na ginagawa ng makina kapag isinasagawa ang aming script ay tinitingnan kung aling shell ang dapat gawin ito. Sa karamihan ng mga kasalukuyang sistema ng linux / Bin / SH ay isang link sa / basahan / bash, ngunit hindi ito palaging ang kaso, halimbawa sa mga pamamahagi na ginagamit busybox nagdadala sila Sh at kadalasan nagdadala din sila Malakas na palo, ngunit kung gumamit ka / Bin / SH, hindi ito tatakbo kasama si Bash. Iyon ang dahilan kung bakit inirerekumenda kong palaging gamitin / basahan / bash.

Unicode kumpara sa ASCII

Naisip mo ba kung bakit hindi mo magagamit ang "¿" o "ñ" sa iyong mga script? O gumamit ng mga accent? Maaari itong maging lubos na nakakainis sa mga interactive na script. Iyon ay dahil ang default na pag-encode para sa Bash ay ASCII, o kung ano ang pareho, ang hanay ng character na Ingles. Upang baguhin ito, sasabihin lamang namin sa aming script na nais naming gamitin ang Unicode. Para doon kailangan mong magdagdag ng isang linya pagkatapos lamang ng interpreter ng utos:

# - * - ENCODING: UTF-8 - * -

Mag-ingat, mahalaga na ang linyang ito ay nasa simula ng script.

Gawing maipapatupad ang script

Nakakatawa kung gaano karaming mga tao ang nagpapatakbo ng mga script na may «$ bashscript.sh"sa halip na"$ ./script.sh'Pagkatapos ng lahat, iyon ang tinukoy namin ng isang shell.

Upang magdagdag ng mga pahintulot sa pagpapatupad, dapat kang magpatupad ng:

sudo + x script.sh

BIN = "folder kung saan mayroon kaming mga script na" PATH = "$ BIN $ PATH"

2. Istraktura ng isang iskrip

1. Headboard
2. Kahulugan ng mga variable na pandaigdigan
3. Tulong
4. Funciones
5. Pangunahing katawan

Ang header ay kung saan isinasaad namin kung aling shell ang nais naming gamitin at ang encoding. Ang bentahe ng mga pag-andar ay ang muling paggamit ng code na paulit-ulit sa pamamagitan ng pagsulat nito nang isang beses lamang at upang gawing mas madaling maunawaan ang script, para sa code na lumampas sa 100 mga linya na lubhang kapaki-pakinabang.

Upang magamit ang mga pagpapaandar, dapat itong tukuyin bago ang pangunahing katawan ng aming script. At kung nais naming gumamit ng mga variable sa pandaigdigang antas ng lahat ng aming script, kapwa sa pangunahing katawan at sa mga pagpapaandar, dapat nating tukuyin ang mga ito sa simula ng lahat, pagkatapos lamang ng header.

Panghuli, mahusay na kasanayan na magsulat ng isang function ng helper para sa kapag ang aming script ay tumatakbo nang masama o may masamang mga parameter. Malinaw na, sa mga kasong iyon nais naming lumabas kaagad sa script, nang hindi binabasa ang mga pagpapaandar. Maaari naming magamit ang para sa:

function help () {echo "" "Ang aming maayos na na-format na teksto ng tulong." "" exit kung [[-z $ 1 || $ 1 == "-h" || $ 1 == "--help"]]; pagkatapos tulungan fi

Kung idaragdag namin ang "exit" sa pag-andar ng tulong, lalabas kami sa script tuwing nagpapatakbo kami ng tulong, halimbawa pagkatapos ng mga mensahe ng error, atbp. Nagse-save kami ng ilang mga linya ng code.

Ipinapahiwatig ng kundisyon ang tulong sa pagpapakita sa screen at exit kung ang script ay pinatakbo nang walang mga parameter o kung -h / –tulong ay tinukoy. Kung titingnan mo ito, iyon ang pamantayan sa pag-uugali ng karamihan sa mga programa ng linux.

3. I-print sa screen

Mayroong 2 pangunahing utos para sa pag-print upang i-screen sa bash: «miss»At«printf«. Pareho silang kasing bilis at pareho ang bahagi ng bash. Ang pangunahing pagkakaiba para sa isang nagsisimula ay ang echo ay nagdaragdag ng isang bagong linya sa dulo, habang «printf"Ay hindi.

Napakaganda ng echo at ito ang ginagamit ng karamihan sa mga tao, subalit kapag binabasa ang INPUT ng gumagamit, o kung nais mong mag-print ng mga variable na kinuha mula sa mga file sa pamamagitan ng pagproseso ng salita, maaaring mangyari ang mga kakaibang bagay. Kadalasan madali silang malulutas, kasing dali ng pagbabago ng mga dobleng quote sa solong o kabaligtaran, o pagkuha ng mga variable na sanggunian mula sa mga quote. «alingawngaw»Ang mga kakaibang bagay ba ay nakasalalay din sa kung paano ito naipon, kung palagi kaming gumagamit ng Ubuntu o palaging Fedora, hindi ito nakakaapekto sa amin, ngunit kung babaguhin namin ang pamamahagi nito.

Iyon ang dahilan kung bakit gumagamit ako ng «printf«, Alin ang hindi nagbibigay sa akin ng sakit ng ulo at nag-uugali din ng mas katulad«printf»Mula sa C o ang«i-print»Ng Python, napakahalaga nito kung nais mong i-port ang iyong script sa isa pang wika ng programa.

4. Basahin ang gumagamit INPUT

Lahat ng isusulat namin pagkatapos ng pangalan ng aming script at bago ang pagpindot sa ENTER key ay awtomatikong nai-save sa mga espesyal na variable. Ang mga variable na ito ay uri ng $ X kung saan ang X ay isang numero.

«$0»Isinasaad ang pangalan ng aming script at mula sa«$1»To infinity everything that we have wrote later ay variable. Halimbawa:

pusa << EOF >> test.sh #! / bin / bash # - * - ENCODING: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n" EOF chmod + x script.sh ./script.sh aking file.txt

Lumilikha kami ng isang script ng pagsubok, ginagawa itong naisakatuparan, at pinapatakbo ito ng 2 mga parameter. Nakukuha namin ang output ng screen ng:

$ 0 = ./script.sh $ 1 = aking $ 2 = file.txt

Gamit ang mga quote maaari naming maipasa ang "aking file.txt" sa "$ 1".

Maaari din nating basahin ang INPUT ng isang gumagamit na may "basahin" na utos, na direktang ipinapahiwatig ang variable kung saan nais naming i-save ang parameter. Halimbawa:

printf "Ano ang iyong pangalan? \ n" basahin ang NAME printf "Hello, $ NAME. \ n"

5. Mga kalkulasyon sa Bash

Para doon maaari nating gamitin ang «ipahayag«Hangga't hindi namin kailangang gumawa ng mga kumplikadong kalkulasyon. Dalawang bagay ang dapat pansinin, ang una ay «ipahayag»Inaamin lamang ang buong mga numero, ang pangalawa ay ang pagbabahagi ay nagbabalik ng buong resulta, upang makita ang natitirang magagamit natin«%".

Karaniwan nais naming italaga ang resulta ng expr sa isang variable. Maaari nating gawin iyon sa dalawang paraan:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

Maaari mo ring laktawan «ipahayag»Paggamit ng doble na panaklong:

VAR2 = $ (($ VAR1 / 100))

6 Kundisyon

Nasulat na ito sa napakalawak na paraan tungkol sa «if«,«iba«,«elif»At mga kundisyon. Maaari mong basahin ang tungkol sa:

• Programming sa Bash: bahagi 1
• Bash: kung, kung gayon, iba pang mga kundisyon
• Suriin kung may isang file o folder na mayroon o hindi at higit pa gamit ang isang if loop
• Programming sa Bash: bahagi 2

Nais ko lamang i-highlight ang pagkakaiba sa pagitan ng paggamit ng mga simpleng square bracket, «[]«, At dobleng mga braket,«[[]]«, Para sa mga kundisyon. Sa mga dobleng braket maaari kaming gumamit ng mga karagdagang kundisyon:

• «&&»Para sa at
• «||»Para sa o

Upang magamit ang "&&»At«||»Sa simpleng mga square bracket, ang bawat bahagi ay dapat na ihiwalay sa magkakahiwalay na square bracket. Ang halimbawang ginamit para sa bahagi ng script na tinitingnan upang makita kung ang tulong ay kailangang maipatupad ay:

kung [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "--help"]]; pagkatapos tulungan fi

Sine-save din kami mula sa pagkakaroon ng pagsusulat ng mga variable na pangalan sa mga quote upang maiwasan ang mga pagkakamali. Halimbawa:

kung [$ 1 = 1]; pagkatapos printf "Ang parameter ay katumbas ng 1."; fi kung ["$ 1" = 1]; pagkatapos printf "Ang parameter ay katumbas ng 1."; fi kung [[$ 1 = 1]]; pagkatapos printf "Ang parameter ay katumbas ng 1."; fi

Kung ang script.sh ay pinatakbo nang walang anumang mga parameter, ang unang kaso ay magbibigay ng isang error:

bash: [: =: inaasahan ang unary operator

Ang hindi pa napagusapan ay «kaso«, Ginamit upang gawing simple«if«. Magsimula tayo sa simula, kung wala tayo «if»Lahat ng code ay papatayin. Kung magdagdag kami ng isang kundisyon «if»Magkakaroon kami ng dalawang kaso, isa kung saan ang bloke ng code na nasa loob ng«if»At ang iba pang kaso kung saan ang blokeng ito ay hindi naisakatuparan.

Kung magdagdag kami ng isang «iba«Magkakaroon din kami ng dalawang kaso, ngunit ang dalawang kaso na ito ay naiiba kaysa sa mga nauna. Dahil ngayon magkakaroon ng dalawang mga kondisyunal na code bloke, A at B, at isang C block, na kung saan ay ang natitirang programa. Ang A o B ay papatayin, at C. Sa dating kaso ito ay A at C o C. lamang.

Upang maiwasan ang mga kondisyon sa pagsusulat «kung hindi" sa loob ng "iba»At upang gawing simple ang pagbabasa ng code, nilikha ito«elif«. Kapag marami kaming mga kundisyon na nakasalalay sa nakaraang isa, halimbawa saklaw ng mga numero o ang uri:

VAR1 = $ 1 kung [[$ VAR1 = 1]]; pagkatapos ay i-print ang "1 \ n" elif [[$ VAR1 = 2]]; pagkatapos ay i-print ang "2 \ n" elif [[$ VAR1 = 3]]; pagkatapos printf "3 \ n" iba printf "wala \ n" fi

Sa kaso ng huling «elif»Maraming mga kondisyon ang babasahin. Sa kaso ang prosesong ito ay streamline:

VAR1 = $ 1 kaso $ VAR sa 1) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 o 4, depende ito \ n" ;; *) printf "none \ n" ;; na C

Mababasa ang isang variable, sa kasong ito VAR1, at makikita ito kung katumbas ito sa anuman sa mga kaso, kung hindi, ang default na kaso na "*" ay naisasagawa. Ang mga dobleng semicolon ay katumbas ng «masira", Sinabi nila"kaso»Iyon ay dapat magtapos.

7. Mga loop

Napakakaunting mga loop ay kilala sa anumang wika ng programa. Sa Bash sila ay «habang«,«hanggang»At«para«. Nasulat na sa blog ang tungkol sa mga ito:

• Programming sa Bash: bahagi 1
• Programming sa Bash: bahagi2

Mayroong dalawang uri ng mga loop «para«, Yaong mga nasa uri«$ para sa VAR sa LOQUESEA»At ano ang uri ng C«$ para sa ((I = 0; I <= 10; I ++))«. Ang pangalawang uri ng mga loop «para»Napaka kapaki-pakinabang, mayroon itong 3 bahagi sa simula ng loop:

• Pagdeklara at pagsisimula ng mga variable (Sa kasong ito ang isang auxiliary variable na "I = 0").
• Kundisyon ng pagpapatupad (hanggang sa mas mababa ako sa o katumbas ng 10).
• Pagtaas ng auxiliary variable

Sa palagay ko ito ang pinakamakapangyarihang loop ng lahat. Isang halimbawa, na naglilimbag ng lahat ng mga numero mula 0 hanggang 10, kasamang:

#! / bin / bash para sa ((I = 0; I <= 10; I ++)); tapos na ang printf "$ I \ n"

8. Pag-andar

Mayroong ilang mga bagay na hindi pinapayagan ng Bash na gawin natin, tama ba? Sa isang unang tingin, ang mga pag-andar ng bash ay pumipigil sa iyo mula sa paggawa ng 3 mga bagay: pagdedeklara ng mga lokal na variable sa mga pag-andar, pagpasa ng mga parameter sa mga pagpapaandar, at pagbabalik ng mga parameter. Lahat may solusyon.

Huwag gumawa tulad ng:

#! / bin / bash VAR = 1 printc "$ VAR \ n" function hello () {VAR = 2 printf "$ VAR \ n"} hello printf "$ VAR \ n"

Ito ay naka-print sa screen 1, 2 at 2.

Upang ideklara ang mga lokal na variable, idagdag ang «lokal»Kapag nagpapahayag:

#! / bin / bash VAR = 1 printf "$ VAR1 \ n" function foo () {local VAR1 = 2 printf "$ VAR1 \ n"} printf "$ VAR1 \ n" foo printf "$ VAR1 \ n"

Ito ang naglilimbag ng 1, 1, 2, 1 sa screen.

Paano mo ipapasa ang mga parameter sa isang pagpapaandar?

#! / bin / bash # - * - ENCODING: UTF-8 - * - function hello () {printf "Hello $ 1 \ n"}

printf "Ano ang iyong pangalan? \ n"
basahin ang VAR1
hello $ VAR1

Paano ibabalik ang mga parameter?

#! / bin / bash # - * - ENCODING: UTF-8 - * - function hello () {printf "Hello holita"} printf "Ano ang iyong pangalan? \ n" basahin ang VAR1 VAR1 = $ (hello) # DITO ITO printf "$ VAR1 $ VAR2 \ n"

Tulad ng nakikita mo, mayroon itong dalawang mga drawbacks, maaari mo lamang ibalik ang isang parameter, na maaaring isang vector 😀, at kung nais mong ibalik ang isang parameter, hindi mo na mai-print ang screen mula sa pagpapaandar na iyon.

9. Gettops

Ang isa sa mga huling bagay na kailangan mong malaman tungkol sa Bash upang lumikha ng mga kumplikadong script ay «getops«. Ginagamit ito upang maipasa ang mga pagpipilian sa script anuman ang pagkakasunud-sunod. Ang tanging downside ay nakakaapekto lamang ito sa mga maikling pagpipilian:

#! / bin / bash # - * - ENCODING: UTF-8 - * - VARC = 0 help help () {printf "Help message \ n" exit} kung [[-z $ 1]]; pagkatapos ay tulungan fi habang getopts: ha: b: c OPT; gawin kaso $ OPT sa h) tulong ;; :) tulong ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) tulong ;; tapos na ang # Pangunahing bloke ng script na # ay gumagawa ng mga bagay sa VARA, VARB at VARC

«Gettopts»Binabasa ang mga pagpipilian nang isa-isa, kaya kailangan ng isang loop.

Mayroong 2 uri ng mga pagpipilian na maaaring maipasa gamit ang «mga getopts":

• Ang mga parameter ay tinatawag na mga watawat, sa kasong ito -c o -h. Tinukoy ang mga ito kasama ang liham na nais naming gamitin. Ang mga ito ay tulad ng mga variable ng Boolean, «totoo»(Ay) o«hindi totoo"(Wala sila dito).
• Mga Parameter na may nauugnay na mga argumento, isang anuman, -b kahit ano. Tinukoy ang mga ito kasama ang liham na nais namin sa isang colon sa ibaba. Ang pagtatalo ay nakaimbak sa OPTARG (ang pangalan na ito ay hindi mababago).

Ano ang ginagawa ng script na ito?

Ipinapakita ang mensahe ng tulong kapag walang pagpipilian na naipasa, kapag ang parameter na "-h" ay naipasa, kapag ang isang hindi wastong parameter ay naipasa (halimbawa "-x", ginagawa ito ng "\?") O kapag ang isang wastong parameter na walang pagtatalo (":"). Sa natitirang kaso ay nai-save nito ang pagkakaroon ng "-c" bilang isang 1 sa VARC, at ang mga halagang ipinasa sa "-a" at "-b" sa VARA at VARB.