બાસ સિદ્ધાંત

0. અનુક્રમણિકા

1. જે બાબતો મોટાભાગના લોકોને થાય છે
2. સ્ક્રિપ્ટની રચના
3. સ્ક્રીન પર છાપો
4. વપરાશકર્તા INPUT વાંચો
5. બેશમાં ગણતરીઓ
6. શરતો
7. આંટીઓ
8. કાર્યો
9. ગેટોપ્સ

1. મોટાભાગના લોકોને થનારી બાબતો

/ બિન / બેશ અથવા / બિન / શ

મશીન અમારી સ્ક્રિપ્ટને એક્ઝિક્યુટ કરતી વખતે કરે છે તેમાંથી એક તે શોધી રહ્યું છે કે તેને કયા શેલ સાથે કરવું જોઈએ. મોટાભાગની વર્તમાન લિનક્સ સિસ્ટમ્સ પર / બિન / શ ની એક કડી છે / બિન / બેશ, પરંતુ હંમેશાં એવું થતું નથી, ઉદાહરણ તરીકે ઉપયોગમાં લેવાયેલા વિતરણોમાં વ્યસ્ત બૉક્સ લાવો Sh અને સામાન્ય રીતે તેઓ પણ લાવે છે બાસ, પરંતુ જો તમે ઉપયોગ કરો છો / બિન / શ, તે બશ સાથે ચાલશે નહીં. તેથી જ હું હંમેશાં ઉપયોગ કરવાની ભલામણ કરું છું / બિન / બેશ.

યુનિકોડ વિ ASCII

શું તમે ક્યારેય વિચાર્યું છે કે તમે શા માટે તમારા સ્ક્રિપ્ટોમાં "¿" અથવા "ñ" નો ઉપયોગ કરી શકતા નથી? અથવા ઉચ્ચારોનો ઉપયોગ કરો છો? ઇન્ટરેક્ટિવ સ્ક્રિપ્ટોમાં તે તદ્દન હેરાન કરી શકે છે. એટલા માટે કે બાશનું ડિફોલ્ટ એન્કોડિંગ એએસસીઆઈઆઈ છે, અથવા તે જ છે, અંગ્રેજી અક્ષરનો સમૂહ. તેને બદલવા માટે, આપણે ફક્ત આપણી સ્ક્રિપ્ટ કહેવાની છે કે આપણે યુનિકોડનો ઉપયોગ કરવા માંગીએ છીએ. તેના માટે તમારે આદેશ દુભાષિયો પછી જ એક લાઇન ઉમેરવી પડશે:

# - * - એન્કોડિંગ: UTF-8 - * -

સાવચેત રહો, તે મહત્વપૂર્ણ છે કે આ રેખા સ્ક્રિપ્ટના પ્રારંભમાં છે.

સ્ક્રિપ્ટને એક્ઝિક્યુટેબલ બનાવો

કેટલા લોકો with સાથે સ્ક્રિપ્ટો ચલાવે છે તે મજેદાર છેash bash સ્ક્રિપ્ટ.શ" ની બદલે "/ ./script.sh'છેવટે, આ જ માટે આપણે શેલ વ્યાખ્યાયિત કર્યા છે.

અમલની પરવાનગી ઉમેરવા માટે, તમારે ચલાવવું આવશ્યક છે:

sudo + xcript.sh

BIN = "ફોલ્ડર જ્યાં અમારી પાસે સ્ક્રિપ્ટો છે" PATH = "$ BIN $ PATH"

સ્ક્રિપ્ટની રચના

1. હેડબોર્ડ
2. વૈશ્વિક ચલોની વ્યાખ્યા
3. મદદ
4. કાર્યો
5. મુખ્ય શરીર

હેડર તે છે જ્યાં આપણે સૂચવીએ છીએ કે આપણે કયા શેલનો ઉપયોગ કરવો છે અને એન્કોડિંગ. કાર્યોનો ફાયદો એ છે કે કોડનો ફરીથી ઉપયોગ કરવો જે તેને ફક્ત એક જ વાર લખીને પુનરાવર્તિત કરવામાં આવે છે અને સ્ક્રિપ્ટને સમજવાનું સરળ બનાવે છે, તે કોડ માટે કે જે 100 લીટીઓ કરતા વધારે છે તે ખૂબ ઉપયોગી છે.

વિધેયોનો ઉપયોગ કરવા માટે, તે અમારી સ્ક્રિપ્ટના મુખ્ય ભાગ પહેલાં તેની સાથે હોવું જોઈએ. અને જો આપણે આપણી બધી સ્ક્રિપ્ટના વૈશ્વિક સ્તરે, મુખ્ય શરીરમાં અને વિધેયોમાં ચલોનો ઉપયોગ કરવા માંગીએ છીએ, તો આપણે તેમને દરેક વસ્તુની શરૂઆતમાં, હેડર પછી જ વ્યાખ્યાયિત કરવી આવશ્યક છે.

છેલ્લે, જ્યારે આપણી સ્ક્રિપ્ટ ખરાબ અથવા ખરાબ પરિમાણો સાથે ચાલે છે ત્યારે માટે સહાયક કાર્ય લખવાનું સારું પ્રથા છે. દેખીતી રીતે, તે કિસ્સાઓમાં આપણે કાર્યો વાંચ્યા વિના, તરત જ સ્ક્રિપ્ટમાંથી બહાર નીકળવા માગીએ છીએ. તે માટે આપણે વાપરી શકીએ છીએ:

ફંક્શન સહાય () {ઇકો "" "અમારું સારી રીતે ફોર્મેટ કરેલું સહાય લખાણ." "" જો [[-z $ 1 || $ 1 == "-એચ" || $ 1 == "--હેલ્પ"]]; પછી મદદ ફાઇ

જો આપણે સહાય કાર્યમાં "એક્ઝિટ" ઉમેરીએ છીએ, ત્યારે જ્યારે પણ સહાય ચલાવીશું ત્યારે સ્ક્રિપ્ટમાંથી બહાર નીકળીશું, ઉદાહરણ તરીકે ભૂલ સંદેશાઓ પછી, વગેરે. અમે કોડની કેટલીક લાઈનો સાચવીએ છીએ.

આ સ્થિતિ સ્ક્રીન પર પ્રદર્શન સહાય સૂચવે છે અને બહાર નીકળો જો સ્ક્રિપ્ટ પરિમાણો વગર ચલાવવામાં આવે છે અથવા જો -h / lpહેલ્પ સ્પષ્ટ થયેલ હોય. જો તમે તેને જુઓ, તો તે મોટાભાગના લિનક્સ પ્રોગ્રામ્સનું માનક વર્તન છે.

3. સ્ક્રીન પર છાપો

બેશમાં સ્ક્રીન પર છાપવા માટે 2 મુખ્ય આદેશો છે: «ઇકો»અને«printf«. તે બંને એટલા જ ઝડપી છે અને બંને બેશનો ભાગ છે. શિખાઉ માણસ માટેનો મુખ્ય તફાવત એ છે કે પડઘો એ અંતે નવી લાઇનનો ઉમેરો કરે છે, જ્યારે «printf"ન કરે.

ઇકો ખૂબ જ સારો છે અને જેનો ઉપયોગ મોટાભાગના લોકો કરે છે, જો કે વપરાશકર્તાના ઇનપુટને વાંચતી વખતે અથવા જ્યારે તમે વર્ડ પ્રોસેસિંગ દ્વારા ફાઇલોમાંથી લીધેલા ચલોને છાપવા માંગતા હો, ત્યારે વિચિત્ર વસ્તુઓ થઈ શકે છે. તેઓ સામાન્ય રીતે સહેલાઇથી હલ કરવામાં આવે છે, જેટલા સરળ ડબલ અવતરણોને એક અથવા તેનાથી વિરુદ્ધમાં બદલવા માટે, અથવા અવતરણ સંદર્ભોને ચલચિત્રોમાંથી બહાર કા takingવા જેટલું સરળ છે. «ઇકોStrange શું વિચિત્ર વસ્તુઓ તે કેવી રીતે સંકલિત કરવામાં આવે છે તેના આધારે પણ છે, જો આપણે હંમેશા ઉબુન્ટુ અથવા હંમેશાં ફેડોરાનો ઉપયોગ કરીએ છીએ, તો તે આપણને અસર કરતું નથી, પરંતુ જો આપણે તેનું વિતરણ બદલીએ તો.

તેથી જ હું useprintf«, જે મને માથાનો દુખાવો આપતું નથી અને તે પણ વધુ વર્તે છે«printfC સી અથવા »પ્રિન્ટPy પાયથોનનું, આ ખૂબ જ મહત્વપૂર્ણ છે જો તમે ક્યારેય તમારી સ્ક્રિપ્ટને બીજી પ્રોગ્રામિંગ ભાષામાં પોર્ટ કરવા માંગતા હો.

4. વપરાશકર્તા ઇનપુટ વાંચો

આપણે આપણી સ્ક્રિપ્ટના નામ પછી અને ENTER કી દબાવતા પહેલા જે કંઇ લખીએ છીએ તે આપમેળે ખાસ ચલોમાં સાચવવામાં આવે છે. આ ચલો $ X પ્રકારના હોય છે જ્યાં X એ સંખ્યા હોય છે.

«$0Script અમારી સ્ક્રિપ્ટનું નામ સૂચવે છે અને from$1Later આપણે પછીથી જે લખ્યું છે તે દરેક વસ્તુને અનંત બનાવવું તે ચલ છે. દાખ્લા તરીકે:

બિલાડી << ઇઓએફ >> પરીક્ષણ. #! / બિન / બેશ # - * - એન્કોડિંગ: યુટીએફ -8 - * - પ્રિન્ટફ "\ $ 0 = $ 0 \ n" પ્રિન્ટફ "\ $ 1 = $ 1 \ n" પ્રિન્ટફ "\ $ 2 = $ 2 \ n "ઇઓએફ chmod + x સ્ક્રિપ્ટ .sh ./script.sh મારી file.txt

અમે એક પરીક્ષણ સ્ક્રિપ્ટ બનાવીએ છીએ, તેને એક્ઝેક્યુટેબલ બનાવીએ છીએ અને તેને 2 પરિમાણોથી ચલાવીએ છીએ. અમે તેનું સ્ક્રીન આઉટપુટ મેળવીએ છીએ:

. 0 = ./script.sh $ 1 = મારા $ 2 = file.txt

અવતરણોનો ઉપયોગ કરીને આપણે "my file.txt" ને "$ 1" પર પસાર કરી શકીએ છીએ.

આપણે "રીડ" આદેશ સાથે વપરાશકર્તાના ઇનપુટને પણ વાંચી શકીએ છીએ, સીધા તે ચલને સૂચવીએ છીએ જ્યાં આપણે પરિમાણને સંગ્રહિત કરવું છે. દાખ્લા તરીકે:

printf "તમારું નામ શું છે? NAME n" વાંચો NAME પ્રિન્ટફ "હેલો, $ NAME." n "

5. બાશમાં ગણતરીઓ

તેના માટે આપણે «એક્સપ્રેસઅને, જ્યાં સુધી અમને જટિલ ગણતરીઓ કરવાની જરૂર નથી. બે બાબતોની નોંધ લેવી જોઈએ, પ્રથમ તે «એક્સપ્રેસWhole ફક્ત આખા નંબરોની કબૂલાત કરે છે, બીજું એ કે ડિવિઝન આખું પરિણામ પાછું આપે છે, બાકીના જોવા માટે આપણે વાપરી શકીએ છીએ to%".

સામાન્ય રીતે આપણે એક્સપ્રેસનું પરિણામ વેરીએબલને સોંપીશું. અમે તે બે રીતે કરી શકીએ:

VAR2 = `સમાપ્તિ $ VAR1 / 10` VAR2 = $ (એક્સપ્રેસ $ VAR1 / 100)

તમે પણ અવગણી શકો છો «એક્સપ્રેસDouble ડબલ કૌંસનો ઉપયોગ:

VAR2 = $ ((AR VAR1 / 100))

6. શરતો

તે વિશે પહેલાથી જ ખૂબ વિસ્તૃત રીતે લખવામાં આવ્યું છે «if«,«બીજું«,«Elif»અને શરતો. તમે તે વિશે વાંચી શકો છો:

• બેશમાં પ્રોગ્રામિંગ: ભાગ 1
• બાસ: જો, તો, અન્ય શરતો
• ફાઇલ અથવા ફોલ્ડર અસ્તિત્વમાં છે કે નહીં અને જો લૂપ સાથે વધુ છે તે તપાસો
• બેશમાં પ્રોગ્રામિંગ: ભાગ 2

હું ફક્ત સરળ ચોરસ કૌંસના ઉપયોગ વચ્ચેના તફાવતને પ્રકાશિત કરવા માંગું છું, «[]«, અને ડબલ કૌંસ,«[[]]અને, શરતો માટે. ડબલ કૌંસ સાથે આપણે વધારાની શરતોનો ઉપયોગ કરી શકીએ છીએ.

• «&&»માટે અને
• «||Or માટે અથવા

વાપરવા માટે "&&»અને«||Simple સરળ ચોરસ કૌંસ સાથે, દરેક ભાગને અલગ ચોરસ કૌંસમાં અલગ પાડવો જોઈએ. સ્ક્રિપ્ટના ભાગ માટે વપરાયેલ ઉદાહરણ કે જે જોવા માટે લાગે છે કે સહાય ચલાવવાની જરૂર છે કે નહીં:

જો [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "- સહાય"]]; પછી મદદ ફાઇ

ભૂલો અટકાવવા માટે અવતરણમાં ચલ નામો લખવાનું આપણને બચાવે છે. દાખ્લા તરીકે:

જો [$ 1 = 1]; પછી printf "પરિમાણ 1 ની બરાબર છે."; ફાઇ જો ["$ 1" = 1]; પછી printf "પરિમાણ 1 ની બરાબર છે."; ફાઇ જો [[$ 1 = 1]]; પછી printf "પરિમાણ 1 ની બરાબર છે."; ફાઈ

જો સ્ક્રિપ્ટ.શ any કોઈપણ પરિમાણો વિના ચલાવવામાં આવે છે, તો પ્રથમ કેસ ભૂલ આપે છે:

bash: [: =: unary ઓપરેટર અપેક્ષિત છે

જેની વાત થઈ નથી તે છે «કેસ«, જેનો ઉપયોગ સરળ બનાવવા માટે થાય છે«if«. ચાલો શરૂઆતમાં શરૂ કરીએ, જ્યારે આપણી પાસે કોઈ «if»તમામ કોડ અમલમાં મૂકવામાં આવશે. જો આપણે કોઈ શરત ઉમેરીશું «if»અમારી પાસે બે કેસ હશે, એક જેમાં કોડનો બ્લોક જે અંદર છે«ifThe અને બીજો કેસ જ્યાં આ બ્લોક ચલાવવામાં આવતો નથી.

જો આપણે «બીજું«અમારી પાસે પણ બે કેસ હશે, પરંતુ આ બે કેસ અગાઉના કેસ કરતા જુદા છે. કારણ કે હવે ત્યાં બે શરતી કોડ બ્લોક્સ, એ અને બી, અને સી બ્લોક હશે, જે બાકીનો પ્રોગ્રામ છે. એ અથવા બી ચલાવવામાં આવશે, અને સી અગાઉના કિસ્સામાં તે એ અને સી અથવા ફક્ત સી હતું.

લેખનની શરતો ટાળવા માટે «જો બીજુ"અંદર"બીજું»અને કોડના વાંચનને સરળ બનાવવા માટે, તે બનાવવામાં આવ્યું હતું«Elif«. જ્યારે આપણી પાસે ઘણી શરતો હોય છે જે પહેલાની સ્થિતિ પર આધારિત હોય છે, ઉદાહરણ તરીકે સંખ્યાઓની શ્રેણી અથવા પ્રકાર:

VAR1 = $ 1 જો [[$ VAR1 = 1]]; પછી "1 \ n" એલિફ પ્રિન્ટફ [[$ VAR1 = 2]]; પછી પ્રિન્ટફ "2 \ n" એલિફ [[$ VAR1 = 3]]; પછી "3 \ n" પ્રિન્ટફ "બીજું પ્રિન્ટફ" કંઈ નહીં. n "ફાઇ

છેલ્લા કિસ્સામાં «Elif»ઘણી શરતો વાંચવામાં આવશે. કિસ્સામાં આ પ્રક્રિયા સુવ્યવસ્થિત છે:

VAR1 = $ 1 કેસ $ VAR માં 1) પ્રિન્ટફ "1 \ n" ;; 2) પ્રિન્ટફ "2 \ n" ;; 3 | 4) પ્રિન્ટએફ "3 અથવા 4, તે depends n" પર નિર્ભર છે ;; *) પ્રિન્ટફ "કંઈ નહીં \ n" ;; કે સી

એક ચલ વાંચવામાં આવશે, આ કિસ્સામાં VAR1, અને તે તપાસ કરવામાં આવશે કે તે કોઈપણ કેસો સાથે સમાન છે, જો નહીં, તો ડિફ defaultલ્ટ કેસ ચલાવવામાં આવશે. ડબલ અર્ધવિરામ «ની બરાબર છેવિરામ«, તેઓ કહે છે«કેસ»તેનો અંત કરવો પડશે.

7. આંટીઓ

કોઈપણ પ્રોગ્રામિંગ ભાષામાં ખૂબ ઓછા આંટીઓ ઓળખાય છે. બાસમાં તેઓ «જ્યારે«,«ત્યાં સુધી»અને«માટે«. તે વિશે આ વિશે બ્લોગમાં પહેલેથી જ લખવામાં આવ્યું છે:

• બેશમાં પ્રોગ્રામિંગ: ભાગ 1
• બ Bashશમાં પ્રોગ્રામિંગ: ભાગ 2

ત્યાં બે પ્રકારનાં આંટીઓ છે «માટે«, તે પ્રકારનાં છે«O LOQUESEA માં VAR માટે»અને સી પ્રકારનાં શું છે«$ માટે ((હું = 0; હું <= 10; હું ++))«. લૂપ્સનો બીજો પ્રકારમાટેVery ખૂબ ઉપયોગી છે, લૂપની શરૂઆતમાં તેના 3 ભાગો છે:

• ચલોની ઘોષણા અને દીક્ષા (આ કિસ્સામાં સહાયક ચલ "I = 0").
• એક્ઝેક્યુશનની સ્થિતિ (જ્યાં સુધી હું 10 કરતા ઓછી અથવા તેની બરાબર નથી).
• સહાયક ચલનો વધારો

મારા મતે તે સૌથી શક્તિશાળી લૂપ છે. એક ઉદાહરણ, જે 0 થી 10 સુધીના તમામ નંબરોને છાપે છે, સમાવિષ્ટ:

#! / બિન / બેશ માટે ((હું = 0; હું <= 10; હું ++)); પ્રિંટફ કરો "$ I print n" થઈ ગયું

8. કાર્યો

કેટલીક વસ્તુઓ છે જે બાશ અમને કરવાની મંજૂરી આપતી નથી, ખરું? પ્રથમ નજરમાં, બેશ ફંક્શન્સ તમને 3 વસ્તુઓ કરવાથી અટકાવે છે: ફંક્શન્સમાં સ્થાનિક ચલો જાહેર કરવા, ફંક્શન્સમાં પરિમાણો પસાર કરવા અને પરિમાણો પરત આપવું. દરેક વસ્તુનો સમાધાન હોય છે.

કંઇક ન કરો:

#! / બિન / બેશ VAR = 1 પ્રિંટક "$ VAR \ n" ફંક્શન હેલો () {VAR = 2 printf "$ VAR \ n"} હેલો પ્રિન્ટફ "$ VAR \ n"

આ સ્ક્રીન 1, 2 અને 2 પર છાપે છે.

સ્થાનિક ચલો જાહેર કરવા માટે, addસ્થાનિક»જ્યારે ઘોષણા કરો છો:

#! / બિન / બેશ VAR = 1 પ્રિંટફ "$ VAR1 \ n" ફંક્શન ફૂ () {સ્થાનિક VAR1 = 2 પ્રિંટફ "$ VAR1 \ n"} પ્રિન્ટફ "$ VAR1 \ n" ફૂ પ્રિન્ટફ "AR VAR1 \ n"

આ સ્ક્રીન પર 1, 1, 2, 1 છાપે છે.

ફંક્શનમાં તમે પરિમાણો કેવી રીતે પસાર કરો છો?

#! / બિન / બેશ # - * - એન્કોડિંગ: UTF-8 - * - કાર્ય હેલો () {પ્રિન્ટફ "હેલો $ 1 \ n"}

printf "તમારું નામ શું છે? \ n"
વીએઆર 1 વાંચો
હેલો $ VAR1

પરિમાણો કેવી રીતે પાછા આવે છે?

#! / બિન / બેશ # - * - એન્કોડિંગ: યુટીએફ -8 - * - ફંક્શન હેલો () {પ્રિન્ટફ "હેલો હોલિતા" f પ્રિન્ટફ "તમારું નામ શું છે?" n "વાંચો VAR1 VAR1 = $ (હેલો) # અહીં છે printf "$ VAR1 $ VAR2 \ n"

જેમ તમે જોઈ શકો છો, આમાં બે ખામીઓ છે, તમે ફક્ત એક પરિમાણ જ પરત કરી શકો છો, જે વેક્ટર હોઈ શકે છે and, અને જો તમે કોઈ પરિમાણ પાછું કરવા માંગતા હોય, તો તમે તે કાર્યથી હવે સ્ક્રીન પર છાપી શકતા નથી.

9. ગેટોપ્સ

જટિલ સ્ક્રિપ્ટો બનાવવા માટે બાશ વિશે તમારે છેલ્લામાંની એક જાણવાની જરૂર છે «ગેપ્સ«. તે theર્ડરને ધ્યાનમાં લીધા વિના સ્ક્રિપ્ટમાં વિકલ્પો પસાર કરવા માટે વપરાય છે. એકમાત્ર નુકસાન એ છે કે તે ફક્ત ટૂંકા વિકલ્પોને અસર કરે છે:

#! / બિન / બેશ # - * - એન્કોડિંગ: UTF-8 - * - VARC = 0 ફંક્શન સહાય () {printf "સહાય સંદેશ exit n" બહાર નીકળો} જો [[-z $ 1]]; પછી ગેટપ્ટ્સમાં મદદ કરો: હા: બી: સી ઓપીટી; do કેસ h ઓપીટી એચ) સહાય ;; :) સહાય ;; a) VARA = $ Tપ્ટાર્જ ;; બી) VARB = $ Tપ્ટ્રેજ ;; સી) વીએઆરસી = 1 ;; \?) સહાય ;; એસએસીએક કર્યું # સ્ક્રિપ્ટનો મુખ્ય બ્લોક જે # વરા, વીએઆરબી અને વીએઆરસી સાથે વસ્તુઓ કરે છે

«ગેટોપ્ટ્સOne એક પછી એક વિકલ્પો વાંચે છે, તેથી લૂપ જરૂરી છે.

ત્યાં 2 પ્રકારનાં વિકલ્પો છે જેનો ઉપયોગ કરીને પસાર કરી શકાય છે «getopts":

• આ કેસમાં -c અથવા -h ધ્વજ તરીકે ઓળખાતા પરિમાણો. અમે જે અક્ષરનો ઉપયોગ કરવા માંગીએ છીએ તે સાથે તેઓ સ્પષ્ટ થયેલ છે. તે બુલિયન ચલો જેવા છે, «સાચુંAre (છે) અથવા «ખોટું"(તેઓ અહીં નથી).
• સંકળાયેલ દલીલોવાળા પરિમાણો, -પણ કંઈપણ, -બી કંઈપણ. તેઓ નીચે આપેલા કોલોન સાથે અમે ઇચ્છતા પત્ર સાથે સ્પષ્ટ થયેલ છે. દલીલ OPTARG માં સંગ્રહિત છે (આ નામ બદલી ન શકાય તેવું છે).

આ સ્ક્રિપ્ટ શું કરે છે?

જ્યારે કોઈ વિકલ્પ પસાર ન થાય ત્યારે સહાય સંદેશ પ્રદર્શિત કરે છે, જ્યારે "-h" પરિમાણ પસાર થાય છે, જ્યારે કોઈ અમાન્ય પરિમાણ પસાર થાય છે (ઉદાહરણ તરીકે "-x", આ "\?" દ્વારા કરવામાં આવે છે) અથવા જ્યારે કોઈ સાથે માન્ય પરિમાણ નથી દલીલ (":"). બાકીના કેસોમાં તે VARC માં 1 તરીકે "-c" ની હાજરીને બચાવે છે, અને VARA અને VARB માં "-a" અને "-b" સાથેના મૂલ્યો પસાર થયા છે.