Պարզ bash scripting օրինակներ: Կեղևի սցենարների ընտրություն բոլոր առիթների համար: Թվաբանական գործողություններ, ցիկլեր ըստ անգամների քանակի

Համար գրել պարզ bash սցենարմենք պետք է կատարենք հետևյալ պարզ քայլերը.

Ինչպես է ամեն ինչ աշխատում.

Մեր սկրիպտի առաջին տողը #!/bin/bash էական նշանակություն ունի մեր սցենարի հաջող աշխատանքի համար:

երկրորդ տողը՝ mkdir testdir, ստեղծում է testdir գրացուցակը

երրորդ տողի cd testdir-ը թույլ է տալիս փոխել ստեղծված գրացուցակը testdir

թիմը հպումհաջորդ տողում հպեք file1 file2 file3-ը ստեղծում է երեք ֆայլ

իսկ մեր սցենարի տողում ls -al վերջին հրամանը թույլ է տալիս ցուցադրել ընթացիկ գրացուցակի բովանդակությունը, որում նախորդ տողի շնորհիվ հայտնվել են երեք դատարկ ֆայլեր։

Ինչպես տեսնում ենք, մեր պարզ սցենարբոլոր հրամանները սկսվում են նոր տողից: Յուրաքանչյուր տող, երբ գործարկվում է սցենարը, հաջորդաբար կատարում է իր աշխատանքը՝ կատարելով որոշակի գործողություններ։

Եթե դուք գործարկում եք մի քանի նույնական հրամանների շղթա (հաստատուն պարամետրերով) Linux-ում ամեն օր, ապա ձեզ համար կարող է իմաստալից գրել նույնը: պարզ bash սցենար, որը թույլ կտա խնայել ձեր ժամանակը և ավտոմատացնել աշխատանքը։

Հրամանի տողը և այն աներևակայելի բաները, որոնք դուք կարող եք անել դրա հետ, UNIX-ի և նրա բոլոր ժառանգների նշանն է: Եվ որտեղ կա հրամանի տող, այնտեղ կան սցենարներ: Եվ այսօր... ոչ, մենք չենք սովորի, թե ինչպես գրել սկրիպտներ, մենք կդիտարկենք դրանցից ամենաօգտակարները, որոնք կարող եք օգտագործել ամեն օր՝ լուծելու բազմաթիվ խնդիրներ՝ սկսած եղանակային հաշվետվություններից և վեբ սերվերից։ մեկ տող դեպի բոտ twitter-ի համար տասը տողով և սցենար համար Ավտոմատ մեկնարկցանկացած torrent հաճախորդ:

Անմիջապես վերապահում կանեմ, որ ես ամենևին էլ շամանիզմի կողմնակից չեմ և ոչ մի դեպքում չեմ հորդորում նստել կանաչ-սև վահանակի մեջ և տպել մի փունջ տառեր, որպեսզի կատարեք գործողություններ, որոնց համար դա նախատեսված է: բավական է մկնիկը սավառնել գրաֆիկական ինտերֆեյսի ցանկալի տարրի վրա: Այնուամենայնիվ, ես համոզված եմ, որ վահանակը և սցենարները շատ ավելի հարմար են բազմաթիվ խնդիրների լուծման համար, քան գրաֆիկական ինտերֆեյսը, և, հետևաբար, դրանք չեն կարող անտեսվել: Ավելին, ցանկացած DE թույլ է տալիս ստեղծել սկրիպտի պատկերակ, այնպես որ այն գործարկելու համար նույնիսկ կարիք չկա բացել վահանակը:

Պարզ օրինակներ

Այսպիսով, առանց հավելյալ երկարաձգելու, եկեք անմիջապես անցնենք օրինակներին.

$ curl ifconfig.com

Սա պարզ հրամանձեզ ցույց կտա արտաքին IP-ն՝ իդեալական, եթե ցանց եք մտնում երթուղիչի միջոցով: Այն ընդամենը զանգում է ifconfig.co սերվերին, որը վերադարձնում է IP հասցեն մեկ տողով՝ ամբողջական վեբ էջի փոխարեն:

Եվ այո, սա ամենևին էլ սցենար չէ, դա պարզապես հրաման է, բայց հրամանը սցենարի վերածելու համար պարզապես տեղադրեք այն տեքստային ֆայլիսկ առաջին տողում ավելացրեք, այսպես կոչված, shebang, այսինքն՝ #! նիշերը, որին հաջորդում է հրամանի թարգմանչի անունը.

$ chmod +x ~/bin/myip.sh

Այժմ այն կարելի է զանգահարել հրամանի տող myip.sh հրամանը.

#!/bin/sh curl -4 wttr.in/Moscow

Այս սցենարը թույլ է տալիս չորս օրվա եղանակի մասին հաշվետվություն ստանալ: Այստեղ սկզբունքը նույնն է, ինչ ifconfig.co-ի դեպքում։

Վահանակի եղանակի ամփոփագիր #!/bin/sh dig +short txt $1.wp.dg.cx

Եվ այսպես, դուք կարող եք ստանալ Կարճ նկարագրությունՎիքիպեդիայում ցանկացած բան և վեբ սերվերի փոխարեն DNS հարցումով: Ի դեպ, շատ հեշտ է նաև վեբ սերվեր ստեղծել հրամանի տողի միջոցով.

#!/bin/sh իսկ (nc -l 80< file.html >:) ; անել: կատարած

Այս սցենարը հիմնված է netcat կոմունալ(nc), որը կոչվում է շվեյցարական բանակի դանակ ցանցային գործողությունների համար: Սցենարը սկսում է հանգույց, որը կատարում է nc հրամանը, որը լսում է 80-րդ նավահանգստում և, ի պատասխան հարցման, վերադառնում է file.html, ուղարկելով անցած հարցումը ոչ մի տեղ (նշանակը նշանակում է noop, այսինքն՝ դատարկ գործողություն)։

Օգտագործելով պարզ սցենարներ և հրամաններ, կարող եք հեշտությամբ լսել ինտերնետային ռադիո.

#!/bin/sh mpv --volume=50 -երգացանկ ~/16bit.fm_128.m3u

Բնականաբար, M3U ֆորմատով երգացանկը պետք է նախապես ներբեռնել ռադիոկայանի կայքից։ Ի դեպ, եթե MPlayer-ը սկսես փաստարկով --input-ipc-server=/tmp/mpvsocket, այն կարելի է կառավարել՝ ֆայլում հրամաններ գրելով։ Օրինակ՝ կարգավորեք ձայնը.

արձագանք «ծավալ +10» | socat - /tmp/mpvsocket

Ստեղծեք երկու սկրիպտ՝ մեկը սկսելու, մյուսը՝ ռադիոն դադարեցնելու համար ( killall mpv տողով), դրանք կախեք աշխատասեղանից և դրեք DE թեժ ստեղները՝ նվագարկումը կառավարելու համար: Voila, դուք պատրաստ ունեք ինտերնետ ռադիոյի նվագարկիչ, որը կարելի է գործարկել՝ պարզապես սեղմելով աշխատասեղանի պատկերակի վրա: Եվ դա հազիվ թե վատնի հիշողությունը կամ զբաղեցնի սկուտեղը:

Բայց եկեք շեղվենք ցանցի գործառնություններից և վերադառնանք տեղական գործերին:

#!/bin/sh tar -czf "../$(PWD##*/).tar.gz" .

Սա իմ սիրելի սցենարներից մեկն է։ Այն ստեղծում է ընթացիկ գրացուցակի tar.gz արխիվ: Այստեղ հատուկ ուշադրության է արժանի $(PWD##*/) կոնստրուկցիան, որը տանում է դեպի ընթացիկ գրացուցակի ամբողջական ուղին ($PWD փոփոխական) և հեռացնում է առաջին մասը մինչև վերջին շեղը՝ այդպիսով թողնելով միայն գրացուցակի անունը։ ինքն իրեն։ Այնուհետև դրան ավելացվում է tar.gz ընդլայնումը: Նման կոնստրուկցիաների մասին ավելին կարող եք կարդալ man bash-ում:

#!/bin/sh իսկ ճիշտ է; անել inotifywait -r -e ՓՈՓՈԽԵԼ ՏԵՂԵԿԱՏՈՒ && YOUR_COMMAND-ը կատարված է

Եվ սա սկրիպտ է, որը հրաման է տալիս՝ ի պատասխան գրացուցակում ֆայլերի փոփոխության: Այն կարող է օգտագործվել բազմաթիվ տարբեր նպատակների համար, ինչպիսիք են ավտոմատ մեկնարկնվագարկիչ MP3 ֆայլ պահելիս: Կամ պարզապես ցուցադրեք ծանուցում աշխատասեղանի վրա՝ օգտագործելով notify-send որպես հրաման.

Ծանուցել-ուղարկել «Ֆայլը փոխվել է»

Սեղան

Քանի որ մենք խոսում ենք աշխատասեղանի մասին, եկեք շարունակենք. Ինչպես մխիթարիչը, այն նույնպես կարող է գրվել: Օրինակ, ահա մի սկրիպտ, որը բեռնում է պատահական պաստառներ, որոնք տեղադրված են reddit ալիքում.

Շարունակությունը հասանելի է միայն անդամների համար

Տարբերակ 1. Միացեք «կայքի» համայնքին՝ կայքի բոլոր նյութերը կարդալու համար

Նշված ժամանակահատվածում համայնքին անդամակցելը ձեզ հնարավորություն կտա մուտք գործել ԲՈԼՈՐ Հաքերային նյութերը, կավելացնի ձեր անձնական կուտակային զեղչը և թույլ կտա ձեզ կուտակել պրոֆեսիոնալ Xakep Score վարկանիշ:

Ինչքան էլ պարզ լինի GUI Linux-ում, և անկախ նրանից, թե քանի գործառույթ կա, այնուամենայնիվ կան առաջադրանքներ, որոնք ավելի հարմար է լուծել տերմինալի միջոցով։ Նախ, քանի որ այն ավելի արագ է, և երկրորդ, ոչ բոլոր մեքենաներն ունեն գրաֆիկական ինտերֆեյս, օրինակ, սերվերների վրա, բոլոր գործողությունները կատարվում են տերմինալի միջոցով, որպեսզի խնայեն հաշվողական ռեսուրսները:

Եթե դուք արդեն ավելի փորձառու օգտատեր եք, ապա հավանաբար հաճախ եք տերմինալի միջոցով տարբեր առաջադրանքներ կատարում։ Հաճախ կան առաջադրանքներ, որոնց համար անհրաժեշտ է հերթով կատարել մի քանի հրամաններ, օրինակ՝ համակարգը թարմացնելու համար նախ պետք է թարմացնեք պահեստները, այնուհետև միայն ներբեռնեք փաթեթների նոր տարբերակները: Սա ընդամենը օրինակ է, և կան բազմաթիվ նման գործողություններ, նույնիսկ կրկնօրինակեք և վերբեռնեք պատճենված ֆայլերը հեռավոր սերվեր. Հետևաբար, նույն հրամանները մի քանի անգամ չտպելու համար կարող եք օգտագործել սկրիպտներ։ Այս հոդվածում մենք կանդրադառնանք Bash-ով սկրիպտներ գրելուն, կդիտարկենք հիմնական օպերատորները, ինչպես նաև, թե ինչպես են դրանք աշխատում, այսպես ասած, bash սկրիպտները զրոյից:

Սկրիպտը, կամ ինչպես կոչվում է նաև սկրիպտ, հրամանների հաջորդականություն է, որոնք ընթերցվում և կատարվում են թարգմանիչ ծրագրի կողմից, մեր դեպքում դա հրամանի տող ծրագիր է՝ bash։

Սցենարը պարզ տեքստային ֆայլ է, որը թվարկում է սովորական հրամանները, որոնք մենք սովոր ենք ձեռքով մուտքագրել, ինչպես նաև այն ծրագիրը, որը կկատարի դրանք: Բեռնիչը, որը կկատարի սկրիպտը, չգիտի, թե ինչպես աշխատել շրջակա միջավայրի փոփոխականների հետ, ուստի այն պետք է անցնի գործարկվող ծրագրի ճշգրիտ ուղին: Եվ հետո այն կփոխանցի ձեր սցենարը այս ծրագրին և կսկսվի կատարումը:

Bash shell-ի սցենարի ամենապարզ օրինակը.

!/bin/bash
արձագանք «Բարև աշխարհ»

Echo utility-ը տպում է իրեն փոխանցված տողը որպես էկրանի պարամետր: Առաջին տողը հատուկ է, այն նշում է այն ծրագիրը, որը կկատարի հրամանները։ Ընդհանուր առմամբ, մենք կարող ենք ստեղծել սցենար ցանկացած այլ ծրագրավորման լեզվով և նշել ցանկալի թարգմանիչը, օրինակ՝ python-ում.

!/usr/bin/env python
տպել («Բարև աշխարհ»)

Կամ PHP-ում.

!/usr/bin/env php
արձագանք «Բարև աշխարհ»;

Առաջին դեպքում մենք ուղղակիորեն մատնանշեցինք այն ծրագիրը, որը կկատարի հրամանները, հաջորդ երկուսում մենք չգիտենք ծրագրի ճշգրիտ հասցեն, ուստի խնդրում ենք env utility-ին գտնել այն անունով և գործարկել այն: Այս մոտեցումը օգտագործվում է բազմաթիվ սցենարներում: Բայց սա դեռ ամենը չէ։ Linux համակարգում, որպեսզի համակարգը գործարկի սկրիպտ, դուք պետք է դրա հետ գործարկվող դրոշը դնեք ֆայլի վրա:

Այս դրոշը ինքնին ֆայլում ոչինչ չի փոխում, այն միայն ասում է համակարգին, որ սա պարզապես տեքստային ֆայլ չէ, այլ ծրագիր, և այն պետք է կատարվի, բացեք ֆայլը, պարզեք թարգմանիչը և կատարեք: Եթե որևէ թարգմանիչ նշված չէ, օգտագործողի թարգմանիչը կօգտագործվի լռելյայն: Բայց քանի որ ոչ բոլորն են օգտագործում bash, դուք պետք է հստակորեն նշեք դա:

Վազել:

chmod ugo+x script_file

Այժմ մենք գործարկում ենք մեր փոքրիկ առաջին ծրագիրը.

./script_file

Ամեն ինչ աշխատում է։ Դուք արդեն գիտեք, թե ինչպես գրել փոքր սցենար, ասենք, թարմացման համար: Ինչպես տեսնում եք, սկրիպտները պարունակում են նույն հրամանները, որոնք կատարվում են տերմինալում, դրանք շատ հեշտ է գրել։ Բայց հիմա մենք մի փոքր կբարդացնենք խնդիրը։ Քանի որ սցենարը ծրագիր է, այն պետք է ինքնուրույն որոշ որոշումներ կայացնի, պահպանի հրամանների կատարման արդյունքները և կատարի հանգույցներ: Այս ամենը կարելի է անել Bash shell-ով։ Ճիշտ է, այստեղ ամեն ինչ շատ ավելի բարդ է։ Սկսենք պարզ.

Փոփոխականներ սկրիպտներում

Bash-ում սկրիպտներ գրելը հազվադեպ է ավարտվում առանց ժամանակավոր տվյալների պահպանման, ինչը նշանակում է փոփոխականների ստեղծում: Ոչ մի ծրագրավորման լեզու չի կարող անել առանց փոփոխականների, ինչպես նաև մեր պարզունակ shell լեզուն:

Դուք կարող եք նախկինում հանդիպել շրջակա միջավայրի փոփոխականների: Այսպիսով, սրանք նույն փոփոխականներն են և նույն կերպ են աշխատում։

Օրինակ, եկեք հայտարարենք տողային փոփոխական.

string = "Բարև աշխարհ"

Մեր տողի արժեքը չակերտների մեջ է: Բայց իրականում մեջբերումներ միշտ չէ, որ անհրաժեշտ են։ Այստեղ պահպանվում է bash-ի հիմնական սկզբունքը՝ բացատը հատուկ նիշ է, բաժանարար, այնպես որ, եթե չակերտներ չօգտագործես, աշխարհն արդեն կհամարվի առանձին հրաման, նույն պատճառով մենք բացատներ չենք դնում հավասարից առաջ և հետո։ նշան.

$ խորհրդանիշն օգտագործվում է փոփոխականի արժեքը ցուցադրելու համար: Օրինակ:

Եկեք փոփոխենք մեր սցենարը.

!/bin/bash
string1 = "բարև"
string2 = աշխարհ
string=$string1$string2
echo $string

Եվ մենք ստուգում ենք.

Bash-ը չի տարբերում փոփոխականների տեսակները, ինչպես դա անում են լեզուները բարձր մակարդակ, ինչպես C++-ը, փոփոխականին կարող եք վերագրել և՛ թիվ, և՛ տող: Հավասարապես այս ամենը կհամարվի լար։ Շելլն աջակցում է միայն տողերի միաձուլմանը, դա անելու համար պարզապես անընդմեջ գրեք փոփոխականների անունները.

!/bin/bash
string1 = "բարև"
string2 = աշխարհ
string=$string1$string2\ and\ me
string3=$string1$string2" և ես"
արձագանք $string3

Մենք ստուգում ենք.

Խնդրում ենք նկատի ունենալ, որ, ինչպես ասացի, մեջբերումները պարտադիր չեն, եթե տողում հատուկ նիշեր չկան: Ավելի ուշադիր նայեք տողերի միաձուլման երկու եղանակներին, այստեղ ցույց է տրվում նաև չակերտների դերը: Եթե ձեզ ավելին է պետք դժվար ուղիներլարերի մշակում կամ թվաբանական գործողություններ, սա ներառված չէ կեղևի հնարավորությունների մեջ, դրա համար օգտագործվում են սովորական կոմունալ ծառայություններ:

Փոփոխականներ և հրամանի ելք

Փոփոխականներն այնքան էլ օգտակար չէին լինի, եթե չկարողանային պահպանել կոմունալ ծրագրերի կատարման արդյունքը: Դրա համար օգտագործվում է հետևյալ շարահյուսությունը.

$(թիմ)

Այս կառուցվածքով հրամանի ելքը կուղղորդվի անմիջապես այնտեղ, որտեղից այն կանչվել է, և ոչ թե էկրան: Օրինակ, ամսաթիվը օգտակար է վերադարձել ընթացիկ ամսաթիվը. Այս հրամանները համարժեք են.

Դու հասկանում ես? Եկեք գրենք սցենար, որտեղ կցուցադրվեն բարև աշխարհ և ամսաթիվ.

string1 = "բարև աշխարհ"
string2=$(ամսաթիվ)

string=$string1$string2

Այժմ դուք բավականաչափ գիտեք փոփոխականների մասին և պատրաստ եք ստեղծել bash սցենար, բայց դեռ ավելին է սպասվում: Հաջորդը, մենք կանդրադառնանք պարամետրերին և կառավարման կառուցվածքներին: Հիշեցնեմ, որ սրանք բոլորը սովորական bash հրամաններ են, և ձեզ հարկավոր չէ դրանք պահել ֆայլում, դուք կարող եք դրանք անմիջապես կատարել շարժման ընթացքում:

Սցենարի ընտրանքներ

Միշտ չէ, որ հնարավոր է ստեղծել bash սկրիպտ, որը կախված չէ օգտվողի մուտքագրումից: Շատ դեպքերում դուք պետք է օգտագործողին հարցնեք, թե ինչ գործողություն պետք է ձեռնարկել կամ ինչ ֆայլ օգտագործել: Սկրիպտ կանչելիս մենք կարող ենք պարամետրեր փոխանցել դրան։ Այս բոլոր պարամետրերը հասանելի են որպես թվեր անվանվող փոփոխականներ:

1 անունով փոփոխականը պարունակում է առաջին պարամետրի արժեքը, փոփոխական 2, երկրորդը և այլն։ Այս bash սցենարը կարտադրի առաջին պարամետրի արժեքը.

!/bin/bash
արձագանք $1

Կառավարման կոնստրուկցիաները սցենարներում

Bash սցենարի ստեղծումն այնքան էլ օգտակար չէր լինի առանց որոշ գործոններ վերլուծելու և դրանց ի պատասխան գործելու հնարավորության: անհրաժեշտ գործողություններ. Սա բավականին բարդ թեմա է, բայց շատ կարևոր է bash սցենար ստեղծելու համար։

Bash-ում կա պայմանները ստուգելու հրաման, որի շարահյուսությունը հետևյալն է.

եթե command_condition
ապա
թիմը
ուրիշ
թիմը
fi

Այս հրամանը ստուգում է պայմանի հրամանի ելքի կոդը, և եթե 0 (հաջողություն), ապա կատարում է հրամանը կամ մի քանի հրամաններ բառից հետո, ապա, եթե ելքի կոդը 1 է, ապա else բլոկը կատարվում է, fi նշանակում է բլոկի ավարտ: հրամաններ.

Բայց քանի որ մեզ ամենից հաճախ հետաքրքրում է ոչ թե հրամանի վերադարձի կոդը, այլ տողերի և թվերի համեմատումը, ներմուծվեց [[ հրամանը, որը թույլ է տալիս կատարել տարբեր համեմատություններ և թողարկել վերադարձի ծածկագիր՝ կախված համեմատության արդյունքից։ Դրա շարահյուսությունը հետևյալն է.

[[ պարամետր 1 օպերատորի պարամետր 2 ]]

Համեմատության համար մենք օգտագործում ենք արդեն ծանոթ օպերատորները<,>,=,!= և այլն։Եթե արտահայտությունը ճշմարիտ է, հրամանը կվերադարձնի 0, եթե ոչ՝ 1։ Դուք կարող եք մի փոքր ստուգել դրա վարքը տերմինալում։ Վերջին հրամանի վերադարձի կոդը պահվում է $? փոփոխականում՝

Այժմ այս ամենը համադրելով՝ ստանում ենք պայմանական արտահայտությամբ սցենար.

!/bin/bash
եթե [[ $1 > 2 ]]
ապա
echo $1"-ը մեծ է 2"-ից
ուրիշ
echo $1"-ը 2 կամ 2"-ից փոքր է
fi

Իհարկե, այս դիզայնն ունի ավելի հզոր հատկանիշներ, բայց դրանք չափազանց բարդ է այս հոդվածում լուսաբանելու համար: Գուցե հետո գրեմ այդ մասին: Առայժմ եկեք անցնենք ցիկլերին:

Օղակներ սցենարներում

Ծրագրերի առավելությունն այն է, որ մենք կարող ենք մի քանի տողով նշել, թե ինչ գործողություններ է պետք կատարել մի քանի անգամ։ Օրինակ՝ կարելի է գրել bash սկրիպտներ, որոնք բաղկացած են ընդամենը մի քանի տողից, բայց աշխատում են ժամերով՝ վերլուծելով պարամետրերը և կատարելով անհրաժեշտ գործողություններ։

Եկեք նախ դիտարկենք հանգույցի համար. Ահա նրա շարահյուսությունը.

ցանկի փոփոխականի համար
անել
թիմը
կատարած

Կրկնվում է ամբողջ ցուցակի վրա և ցուցակից արժեք է վերագրում փոփոխականին, յուրաքանչյուր հանձնարարությունից հետո կատարում է do և done միջև գտնվող հրամանները:

Օրինակ, եկեք կրկնենք հինգ թվանշանից.

1 2 3 4 5 ցուցանիշի համար
անել
արձագանք $ ինդեքս
կատարած

Կամ կարող եք թվարկել բոլոր ֆայլերը ընթացիկ գրացուցակում.

ֆայլի համար $(ls -l); արձագանքել «$file»; կատարած

Ինչպես հասկանում եք, դուք կարող եք ոչ միայն ցուցադրել անուններ, այլև կատարել անհրաժեշտ գործողությունները, սա շատ օգտակար է վազելիս բաշի ստեղծումըսցենար.

Երկրորդ հանգույցը, որին մենք կանդրադառնանք, while օղակն է, որն աշխատում է մինչ պայմանի հրամանը վերադարձնում է 0 կոդը՝ հաջողություն: Դիտարկենք շարահյուսությունը.

իսկ հրամանի պայմանը
անել
թիմը
կատարած

Դիտարկենք մի օրինակ.

!/bin/bash
ինդեքս=1
մինչդեռ [[ $index< 5 ]]
անել
արձագանք $ ինդեքս
թող «index=index+1»
կատարած

Ինչպես տեսնում եք, ամեն ինչ կատարվում է, let հրամանը պարզապես կատարում է նշվածը մաթեմատիկական գործողություն, մեր դեպքում մեծացնում է փոփոխականի արժեքը մեկով։

Ես կցանկանայի նշել մեկ այլ բան. Կառուցվածքներ, ինչպիսիք են while, for, if նախագծված են մի քանի տողերի վրա գրվելու համար, և եթե փորձեք դրանք գրել մեկ տողի վրա, սխալ կստանաք: Բայց, այնուամենայնիվ, հնարավոր է, դրա համար, որտեղ պետք է լինի տողի ընդմիջում, դրեք «;»: Օրինակ, նախորդ հանգույցը կարող էր իրականացվել որպես մեկ տող.

ինդեքս=1; մինչդեռ [[ $index< 5 ]]; do echo $index; let "index=index+1"; done;

Ամեն ինչ շատ պարզ է, ես փորձեցի հոդվածը չբարդացնել հավելյալ bash տերմիններով և հնարավորություններով, միայն ամենահիմնականով: Որոշ դեպքերում ձեզ կարող է անհրաժեշտ լինել gui պատրաստել bash script-ի համար, այնուհետև կարող եք օգտագործել այնպիսի ծրագրեր, ինչպիսիք են zenity կամ kdialog, որոնց միջոցով շատ հարմար է հաղորդագրություններ ցուցադրել օգտվողին և նույնիսկ նրանից տեղեկատվություն խնդրել:

եզրակացություններ

Այժմ դուք հասկանում եք սկրիպտավորման հիմունքները Linux-ում և կարող եք գրել ձեզ անհրաժեշտ սցենարը, օրինակ՝ Պահպանեք պատճենը. Ես փորձեցի զրոյից նայել bash սցենարները: Հետևաբար, ոչ բոլոր ասպեկտներն են դիտարկվել: Թերևս մենք կանդրադառնանք այս թեմային հաջորդ հոդվածներից մեկում:

Համար գրել պարզ bash սցենարմենք պետք է կատարենք հետևյալ պարզ քայլերը.

Ինչպես է ամեն ինչ աշխատում.

Մեր սցենարի առաջին տողը կարևոր է մեր սցենարի հաջող աշխատանքի համար:

երկրորդ տողը ստեղծում է testdir գրացուցակը

երրորդ տողը թույլ է տալիս փոխել ստեղծված գրացուցակը testdir

թիմը հպումհաջորդ տողը ստեղծում է երեք ֆայլ

իսկ մեր սցենարի տողում վերջին հրամանը թույլ է տալիս ցուցադրել ընթացիկ գրացուցակի բովանդակությունը, որում նախորդ տողի շնորհիվ հայտնվել են երեք դատարկ ֆայլեր։

Հաճախ է պատահում, որ անհրաժեշտ է ավտոմատացնել որոշակի գործողություն: Bash սցենարները միշտ օգնության են հասնում:
Մի մոռացեք, որ սցենարը գործարկելու համար դուք պետք է փոխեք դրա մուտքի իրավունքները՝ ավելացնելով ֆայլը գործարկելու հնարավորությունը։

1. Մուտք-ելք, վերահղում

#!/bin/bash # Ցանկացած shell script միշտ սկսվում է #!/bin/bash (կամ #!/bin/sh) տողով # Մեկնաբանությունները միշտ սկսվում են # #-ով Հաղորդագրություն ցուցադրելու համար օգտագործեք ECHO հրամանը echo «hello, world" # և սա ձևաչափված ելքի օրինակ է...

գրեթե ինչպես C printf "formatted output ten=%d string=%s float=%f hex_number=0x%X\n" 10 "string" 11.56 234 # ստեղնաշարից մուտքագրում կարդալու օրինակ կարդալ A echo $A printf " դուք պարզապես մուտքագրված բառը՝ %s\n" "$A" #վերահղում, խողովակաշարեր, ստանալով մեկ այլ ծրագրի արդյունք #10 տառանոց գաղտնաբառի գեներացման օրինակ PASSWORD1=`cat /dev/urandom | tr -d -c ‘a-zA-Z0-9’ | fold -w 10 | head -1` echo Password=$PASSWORD1 #quotes «ձևի» արդյունքը տալիս են էկրանին այն, ինչ կա իրենց ներսում (այսինքն՝ նման չակերտների ներսում գրված ծրագիրը կամ սցենարը կատարվում է և արդյունքը տպագրվում է նրանց կողմից #standard-ում։ ելքը «backquotes» գործողության արդյունքն է #այս դեպքում, արդյունքը մի քանի ծրագրերից խողովակաշարի ելքն է։

Հետաքրքիր bash սցենարներ Linux տերմինալների սիրահարների համար

#շահագործում | հանդես է գալիս որպես փոխակրիչ: Նրանք. մեր օրինակում՝ #cat /dev/urandom-ը թողարկում է /dev/urandom ֆայլի բովանդակությունը (հատուկ ֆայլ՝ կեղծ պատահական թվեր ստեղծելու համար) stdout-ին: #tr-ն կատարում է թարգմանություն, այսինքն. որոշ բայթ փոխարինում է մյուսներով (սա անհրաժեշտ է գաղտնաբառում չտպվող նիշերի հայտնվելուց խուսափելու համար) #fold-ը բաժանում է այն, ինչ ստացել է std.in-ում 10 նիշ երկարությամբ տողերի և տպում է stdout #head -1-ը տպում է առաջինը: գծեք այն, ինչ նրան հասավ ստանդարտ մուտքագրմամբ: # կամ նման՝ PASSWORD2=`cat /dev/urandom | tr -dc _A-Z-a-z-0-9 | head -c10` echo Գաղտնաբառ=$PASSWORD2

2. Թվաբանական գործողություններ, ցիկլեր ըստ անգամների քանակի

#!/bin/bash A="10" B="5" C=`expr $A + $B` printf "A=10 B=5 C=expr \$A + \$B C=%d \n" "$C" # loop over i օրինակ I=0 while [ $I -lt 15 ] do printf "0x%02x " "$I" I=`expr $I + 1` done echo

3. Տարբեր տեսակի չեկեր

#!/bin/bash # ֆայլի առկայության ստուգման օրինակ # ստեղծել ֆայլ test1 touch test1 # ստուգել ֆայլի առկայությունը test1 if [ -f test1 ] ; ապա echo «file test1 exists» fi # ստուգեք, արդյոք ֆայլը test2 գոյություն չունի, եթե ! [-f test2]; ապա արձագանքել «ֆայլի test2 գոյություն չունի» fi # հակիրճ հղում հրամանի այլ ընտրանքներին # -d ֆայլի անվան գրացուցակը գոյություն ունի # -f ֆայլի անվանման ֆայլը գոյություն ունի # -L ֆայլի անվան սիմվոլինգը գոյություն ունի # -r, -w, -x ֆայլը ընթեռնելի է, գրավոր կամ do # -s ֆայլի անունը ֆայլը գոյություն ունի և ունի ոչ զրոյական երկարություն # f1 -nt f2 f1 ավելի նոր է, քան f2 # f1 -ot f2 f1 ավելի հին է, քան f2

Պիտակներ՝ bash, freebsd, shell

Գրեք մեկնաբանություն հետևյալի միջոցով.

Ինչպես գրել պարզ bash սցենար

Ինչպե՞ս գործարկել մի քանի հրամաններ հաջորդաբար կամ բոլորը միանգամից: Եթե Ձեզ անհրաժեշտ է գործարկել մի քանի հրամաններ, ապա նշանը « ; » կոչվում է մետանիշ։Շարահյուսությունը հետևյալն է հրաման1;հրաման2;հրաման3

Հրամաններն առանձնացված են « ; » կատարվում են հաջորդաբար: Կեղևը սպասում է հաջորդ հրամանին և վերջին հրամանի կատարումից հետո վերադառնում է հրամանի տող:

Մի քանի հրամանների միաժամանակյա կատարում

Միանգամից մի քանի հրամաններ գործարկելու համար հրամանի վերջում դնելով «&» նշանը: Օրինակ, հաշվի առեք պահուստային սցենարի սկիզբը.

# /root/ftpbackup.sh &

Եվ ձեր տերմինալն անվճար է հետագա օգտագործման համար, դուք պետք չէ սպասել, որ /root/ftpbackup.sh սկրիպտը ավարտի գործարկումը:

Օգտագործելով ամեն ինչ միասին

Դուք կարող եք ունենալ հազարավոր *.bak ֆայլեր: Բայց ձեզ հարկավոր է ընդամենը թվարկել ձեր ուզած կատեգորիաները և ամեն ինչ տեղադրել /tmp/list:

# d-ի համար «/home/sales /home/dbs /data1»-ում; գտնել $d -inname «*.bak» >> /tmp/list; կատարած &

Աղբյուր

Սովորում BASH (հիմունքներ)

Ամսաթիվ:2012-12-10

Սովորում ենք գրել սցենար

Մեծ մասամբ ամբողջ Linux-ը բաղկացած է սկրիպտներից, ուստի պարզապես անհրաժեշտ է իմանալ այս լեզուն։
Հիմնականում դա պարզապես հավաքածու է: Linux հրամաններ, համակցված օգտագործելով տարբեր կոնստրուկցիաներ՝ վերածելով լավ մտածված կոդի:

Եկեք ստեղծենք մեր առաջին սցենարը:
Դա անելու համար պարզապես բացեք տեքստային խմբագիր և լրացրեք ֆայլը հետևյալով.

#!/bin/bash
ԱՀԿ; ամսաթիվը

Այստեղ ամեն ինչ պարզ է.
Իր հիմքում հեշ նշանը (#) շատ դեպքերում դիտվում է որպես մեկնաբանության սկիզբ, բայց այստեղ, սկսած առաջին տողից, այն մեզ ասում է, որ պետք է օգտագործվի bash թարգմանիչը։

1) Անհրաժեշտ է տալ կատարման իրավունքներ

chmod u+x bash1.sh

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/խաղ

Եվ այս ֆայլը տեղափոխեք դիրեկտորիաներից մեկը, եթե, իհարկե, պետք չէ դրան հղում անել պարզապես անունով, և ոչ թե լրիվ տեղգտնվելու վայրը.

Այստեղ մենք նայեցինք, թե ինչպես է ստեղծվում սցենարը, հետո մի քանի բան կա հասկանալու համար:

Ամեն անգամ, երբ մենք գրում ենք սկրիպտներ, մենք կաշխատենք փոփոխականներով, կվերահղենք մուտքն ու ելքը, կաշխատենք խողովակների հետ և կկատարենք մաթեմատիկական հաշվարկներ:

Փոփոխականներ

Նոր փոփոխական սահմանելու համար պարզապես ասեք.

#!/bin/bash
F=Իվան
Ես=Իվանով
Օ=Իվանիչ
#Ցուցադրվում է՝
արձագանք «FIO $F $I $O»

Արդյունք

շ բաշ2.շ
FIO Իվան Իվանով Իվանիչ

Դիտել փոփոխականները;
# հավաքածու

BASH=/bin/bash
HISTFILE=/root/.bash_history
HISTFILESIZE=500
HISTSIZE=500
HOME=/արմատ
SSH_CLIENT='192.168.200.3 9382 22'
SSH_CONNECTION='192.168.200.3 9382 192.168.200.252 22'

Կա ևս մեկ շատ հետաքրքիր և օգտակար միջոց՝ փոփոխական սահմանելու ``-ով

#!/bin/bash
day=`ամսաթիվ +%y%m%d`
# Ապագայում $day փոփոխականը կարող է տեղադրվել սցենարի մեջ, օրինակ՝ կրկնօրինակում

rsync -avz /root/data /root/backup.$day

Նման սկրիպտը գործարկելու արդյունքում կհայտնվի պահուստային պատճեն՝ կրկնօրինակի ստեղծման ամսաթվի սահմանմամբ:

Մուտքի և ելքի վերահղում:

> Վերահղում դեպի ֆայլ՝ ֆայլի բովանդակության ամբողջական վերագրանցմամբ
>> Վերահղում ֆայլին կցելու համար, գոյություն ունեցող բովանդակության ավարտին:
լս -ալ / > 123
Եվ հրամանը.
ls -al /home >> 123
Թվարկեք բոլոր ֆայլերը արմատից և դրանից հետո ավելացրեք Home գրացուցակի բովանդակությունը
այս վերահղումը կոչվում է ելքային վերահղում
Input Redirection - Բովանդակությունը վերահղվում է հրամանին:
տեսակավորել< sort.txt
Sort հրամանը տեսակավորում է այբբենական կարգով, որի արդյունքում պատահականորեն լրացված sort.txt ֆայլը, տեսակավորման ծրագիր վերահղվելուց հետո, կդասավորվի այբբենական կարգով։
տեսակավորել< sort.txt | more — а построение в канал отобразит отсортированные данные постранично
տեսակավորել< sort.txt | grep s | more — отсортирует и выведет все со знаком «S»

Մեկ այլ օգտակար բան, որ պետք է իմանալ, մի հրամանի արդյունքը մյուսին կամ մի քանիսին փոխանցելն է:
Դրա օրինակը կլինի.

cat /var/log/maillog | grep արգելափակված է | ավելին

1) cat - ցուցադրում է ամբողջ մատյան ֆայլը
2) այնուհետև այս log ֆայլը մշակման համար փոխանցվում է grep հրամանին, որը ցուցադրվում է միայն Blocked-ով, բայց քանի որ այս կարգավիճակով շատ հաղորդագրություններ կան, անհրաժեշտ է այն փոխանցել more հրամանին։
3) ավելին - անհրաժեշտ է էջավորման տվյալների համար

Հրամանների նման հաջորդականությունը կոչվում է փոխանցում ալիքով, երբ մի հրամանի տվյալները փոխանցվում են մշակման համար մյուսին, իսկ դրանք՝ մյուսին և այլն, մինչև նրանք ստանան ցանկալի ձևը:

Մաթեմատիկական հաշվարկներ

Linux-ում մաթեմատիկա անելու ամենահեշտ ձևը bc հրամանն է:
Այս դեպքում դուք չպետք է սահմանեք տասնորդական տեղերի թիվը լողացող կետից հետո՝ օգտագործելով սանդղակը

#!/bin/bash
var1=45
var2=22
var3=`echo "scale=3; $var1/$var2» | մ.թ.ա
արձագանք $var3

Plutonit.ru - Վարչակազմ, Linux-ի կարգավորումև Windows 2009 - 2018 թթ

Տվյալների բազայի սխալ. «a111530_forumnew.rlf1_users» աղյուսակը գոյություն չունի

Գլխավոր -> MyLDP -> Էլեկտրոնային գրքեր Linux OS-ի համար

Սցենարի ստեղծում և գործարկում

Գրեք սցենար և անուն ընտրեք դրա համար

Shell script-ը հրամանների հաջորդականություն է, որը կարող եք օգտագործել մի քանի անգամ: Այս հաջորդականությունը սովորաբար կատարվում է հրամանի տողում սկրիպտի անունը մուտքագրելով: Բացի այդ, cron-ի հետ դուք կարող եք օգտագործել սկրիպտներ՝ առաջադրանքները ավտոմատացնելու համար: Սկրիպտների մեկ այլ օգտագործումը բեռնման և դադարեցման ընթացակարգն է UNIX համակարգերերբ daemon և սպասարկման գործառնությունները սահմանվում են init սկրիպտներում:

Shell script ստեղծելու համար բացեք նոր դատարկ ֆայլ ձեր խմբագրում: Դրա համար կարող եք օգտագործել ցանկացած տեքստային խմբագրիչ. վիմ, emacs, gedit, dtpadև այլն; ցանկացածը կանի: Այնուամենայնիվ, դուք կարող եք ընտրել ավելի առաջադեմ խմբագիր, ինչպիսին է վիմկամ emacs, քանի որ նման խմբագրիչները կարող են կազմաձևվել այնպես, որ ճանաչեն shell-ը և Bash-ի շարահյուսությունը և կարող են լավ օգնել կանխելու այն սխալները, որոնք հաճախ թույլ են տալիս սկսնակները, ինչպես օրինակ՝ մոռանալով փակել փակագծերը և կետ-ստորակետերը:

Մուտքագրեք UNIX հրամանները նոր դատարկ ֆայլում այնպես, ինչպես կմուտքագրեիք դրանք հրամանի տողում: Ինչպես քննարկվեց նախորդ գլխում (տես «Հրամանի կատարում» բաժինը), հրամանները կարող են լինել shell ֆունկցիաներ, ներկառուցված հրամաններ, UNIX հրամաններ կամ այլ սկրիպտներ:

Ընտրեք մնեմոնիկ անուն ձեր սցենարի համար, որը պատմում է ձեզ, թե ինչ է անում սցենարը: Համոզվեք, որ ձեր սցենարի անունը չի հակասում առկա հրամաններին: Ցանկացած շփոթությունից խուսափելու համար սկրիպտների անունները հաճախ ավարտվում են .sh ընդլայնմամբ: Այնուամենայնիվ, ձեր համակարգում կարող են լինել ձեր ընտրած նույն անունով այլ սցենարներ: Հրամաններ որը, որտեղ էիսկ մյուսներն արդեն տեղեկություններ են փնտրում առկա ծրագրերըև այս անունով ֆայլեր՝

որը -a script_name, որտեղ script_name-ը գտնում է script_name ( մոտավորապես տրանս.

Սցենարներ գրել Linux-ով (սովորում ենք օրինակներով)

փոխարինեք ձեր սցենարի անունով):

Սցենարի սցենար1.sh

Այս օրինակում մենք օգտագործում ենք հրամանը արձագանք, ներկառուցված Bash-ում, որն օգտագործողին կտեղեկացնի, թե ինչ պետք է արվի նախքան ելքի արտադրությունը: Խստորեն խորհուրդ է տրվում, որ օգտվողները տեղեկացված լինեն, թե ինչ է անում սկրիպտը, որպեսզի օգտագործողները չէին նյարդայնանում, եթե իրենց թվաց, թե սցենարը ոչինչ չի անում. Մենք կվերադառնանք օգտատերերին զգուշացնելու թեմային 8-րդ գլխում՝ «Ինտերակտիվ սցենար գրելը»:

Նկ.2.1. Սցենարի սցենար1.sh

Գրեք նույն սցենարը ինքներդ ձեզ համար: Լավ կլինի ստեղծել գրացուցակ, որտեղ կտեղակայվեն ձեր սցենարները: Ավելացնել այս գրացուցակը փոփոխականի բովանդակությանը.

արտահանել PATH = "$PATH:~/scripts"

Եթե դուք նոր եք Bash-ում, օգտագործեք տեքստային խմբագրիչ, որն օգտագործում է տարբեր գույներ կեղևի տարբեր կառուցվածքների համար: Շարահյուսության ընդգծումը աջակցվում է վիմ, գվիմ, (x) emacs, գրելև շատ այլ խմբագիրներ, տեսեք ձեր սիրելի խմբագրի փաստաթղթերը:

Սցենարի կատարում

Որպեսզի սկրիպտը կարողանա գործարկել, այն պետք է ունենա գործարկման իրավունքներ համապատասխան օգտագործողների համար: Թույլտվությունները սահմանելուց հետո ստուգեք, որ դուք իսկապես սահմանել եք ձեզ անհրաժեշտ թույլտվությունները: Երբ դա արվի, սցենարը կարող է գործարկվել այնպես, ինչպես ցանկացած այլ հրաման.

willy:~/scripts> chmod u+x script1.sh willy:~/scripts> ls -l script1.sh -rwxrw-r— 1 willy willy 456 Dec 24 17:11 script1.sh willy:~> script1.sh The սցենարը սկսվում է հիմա: Հեյ Վիլի! Ես հիմա ձեզ կբերեմ միացված օգտատերերի ցուցակը՝ 15:38 մինչև 18 օր, 5:37, 4 օգտվող, միջին բեռնվածություն՝ 0.12, 0.22, 0.15 ՕԳՏԱԳՈՐԾՈՂԻ TTY FROM-ից: [էլփոստը պաշտպանված է] IDLE JCPU PCPU ԻՆՉ արմատ tty2 - Շաբ 2pm 4:25m 0.24s 0.05s -bash willy:0 - Sat 2pm ? 0.00 վրկ. — willy pts/3 — Sat 2pm 3:33m 36.39s 36.39s BitchX willy ir willy pts/2 — Sat 2pm 3:33m 0.13s 0.06s /usr/bin/screen Ես հիմա երկու փոփոխական եմ դնում: Սա տող է՝ սև Եվ սա թիվ է՝ 9 Ես հիմա քեզ հետ եմ տալիս քո հուշումը: willy:~/scripts> echo $COLOUR willy:~/scripts> echo $VALUE willy:~/scripts>

Սա սցենարի կատարման ամենատարածված եղանակն է: Նախընտրելի է նման սկրիպտներ կատարել ենթաշելլում: Փոփոխականները, ֆունկցիաները և փոխանունները, որոնք ստեղծվել են այս ենթաշելլում, հայտնի են միայն տվյալ ենթաշելլի կոնկրետ Bash նիստին: Երբ այս կեղևից դուրս գա, և վերահսկողությունը ստանձնի մայր վահանակը, բոլոր կարգավորումները կջնջվեն, և սկրիպտի հետ կապված ցանկացած փոփոխություն կմոռացվի:

Եթե փոփոխականում չեք նշել դիրեկտորիաներ կամ (ընթացիկ գրացուցակ), կարող եք ակտիվացնել սցենարը այսպես.

./script_name.sh

Հնարավոր է նաև սկրիպտ կատարել գոյություն ունեցող վահանակի ներսում, բայց դա սովորաբար արվում է միայն այն դեպքում, եթե ցանկանում եք մատչելիություն, օրինակ, եթե ցանկանում եք ստուգել՝ արդյոք սկրիպտը աշխատում է մեկ այլ վահանակի հետ, կամ թողարկել հետագծում վրիպազերծման նպատակով ( մոտավորապես տրանս.- փոխարենը նշեք ձեր սցենարի անունը):

rbash script_name.sh sh script_name.sh bash -x script_name.sh

Նշված կեղևը կգործարկվի որպես ձեր ընթացիկ կեղևի ենթաշերտ և կկատարվի սցենարը: Սա արվում է, երբ ցանկանում եք, որ սկրիպտը գործարկվի հատուկ պարամետրերով կամ որոշակի պայմաններով, որոնք նշված չեն հենց սկրիպտում:

Եթե դուք չեք ցանկանում սկսել նոր վահանակ, բայց ցանկանում եք սկրիպտը կատարել ընթացիկ վահանակում, օգտագործեք հրամանը.

աղբյուր script_name.sh

Այս դեպքում սցենարը կատարման թույլտվությունների կարիք չունի: Հրամանները կատարվում են ընթացիկ կեղևի համատեքստում, ուստի ձեր միջավայրում կատարված ցանկացած փոփոխություն տեսանելի կլինի, երբ սկրիպտն ավարտի.

willy:~/scripts> source script1.sh --output ommitted- willy:~/scripts> echo $VALUE 9 willy:~/scripts>

Նախ, եկեք հասկանանք, թե որն է սցենարև ինչի համար է այն:

Սցենարթարգմանվել է անգլերենից - սցենար. Մենք բոլորս դիտում ենք ֆիլմեր, մեզանից շատերը դիտում են ներկայացումներ։ Ֆիլմ/ներկայացում ստեղծելու համար սցենարիստները նրանց համար գրում են սցենարներ, որոնց հիման վրա դերասանները, տեսարան առ տեսարան, կատարում են իրենց դերերը բեմում, որից էլ ձևավորվում է ֆիլմը/ներկայացումը։ Սցենարի ստեղծման աշխատանքը բավականին տքնաջան է, որտեղ պետք է ամեն ինչ հաշվի առնել ամենափոքր մանրամասնությամբ, որպեսզի ի վերջո արվեստագետները կատարեն սցենարիստի ծրագիրը, իսկ հեռուստադիտողը տեսնի ամբողջական աշխատանք։

Նմանապես, սկրիպտները գրվում են առաջադրանքների ցանկը կատարելու համար, որոնք օգտագործողը հավաքում է (կոդ)՝ դրանց կատարումն ավելի հեշտ և արագ դարձնելու համար։ օպերացիոն համակարգ. Պարզ սցենարներ գրելու համար պարտադիր չէ ունենալ ծրագրավորողի կրթություն։

Սկսենք, եկեք ստեղծենք ամենաշատը, որը ոչ մեկը չէ, ամենապարզը սցենար-շելլհամակարգը թարմացնելու համար:

Բոլոր գործողությունները ես իրականացնելու եմ համակարգի հետ ubuntu, բայց դրանք վերաբերում են նաև այլ համակարգերին։ Linux, բխում է ubuntu. Դրա համար մեզ անհրաժեշտ է. Տեքստի խմբագիրլրացնել այն սկրիպտ (կոդ) ստեղծելու համար անհրաժեշտ առաջադրանքներով և Տերմինալ- կատարել cos այս սցենարը. Այս գործիքները տեղադրվում են ցանկացած բաշխման մեջ Linuxլռելյայն.

Այսպիսով, բացեք տեքստային խմբագիր geditև անվան տակ մուտքագրեք դրա մեջ առաջին անհրաժեշտ նիշերը շեբանգ.
շեբանգծրագրավորման մեջ այն երկու նիշերի հաջորդականություն է՝ հեշ և բացականչության նշան (#! ) սցենարի ֆայլի սկզբում: Եվ ավելացրեք այս նիշերին առանց բացատների /bin/sh- թարգմանիչը, որտեղ կկատարվի սցենարը: /bin/sh- սովորաբար այդպես է Bourne shellկամ համատեղելի հրամանի տողի թարգմանիչ, որն անցնում է «ուղի/դեպի/սկրիպտ»որպես առաջին պարամետր:
Սցենարի առաջին անհրաժեշտ տողը կունենա հետևյալ տեսքը.

# Իմ առաջին Ubuntu-ի թարմացման սցենարը

Տողի հենց սկզբում ֆունտի նշանը (#) ասում է թարգմանչին/տերմինալին, որ այս տողը կարդալու և կատարման կարիք չունի: Տողն անհրաժեշտ է այս սցենարի կոդում, որպեսզի սցենարի ստեղծողն ինքն իմանա, թե ինչ է պատրաստվում իրականացնել կոդի այս հատվածի/տեսարանի վրա, որպեսզի ապագայում չշփոթվի, երբ շատ կլինեն։ նման տողեր. Ֆունտի նշանով նման տողերը կոչվում են. մեկնաբանեց .

sudo apt թարմացում
sudo apt բարելավում -y

-yԵրկրորդ հրամանի վերջում թարգմանչին/տերմինալին պարզ է դառնում, որ այս գործողությունը/հրամանը պետք է կատարվի ավտոմատ կերպով՝ առանց ստեղնը սեղմելու լրացուցիչ օգտագործողի կողմից հաստատման: Մուտքագրում. y- կարճ անգլերենի համար այո, այսինքն. Այո՛.

Այսքանը: Ձեր առաջին սցենարը ստեղծվել է: Դուք պետք է ունենաք նման բան նկարում.

Մնում է պահպանել ստեղծված ֆայլը/սկրիպտը և տալ այն Անունվերջում պարտադիր երկարաձգմամբ - .շ. Ընդլայնումը .շնշանակված է գործարկվողին:
Ես նրան տվեցի Անուն - թարմացնել.շ, խնայելով տնային թղթապանակօգտվող:

Որպեսզի ստեղծված ֆայլը/սկրիպտը գործարկելի լինի, պետք է դրա համար թույլտվություն տրվի: Դա կարելի է անել երկու եղանակով.

1. Գործարկեք հետևյալ հրամանը տերմինալում.

sudo chmod +x update.sh

2. Կամ բացեք ֆայլերի կառավարիչը տնային թղթապանակ(որտեղ դուք պահպանել եք ստեղծված սկրիպտը), աջ սեղմեք ֆայլի վրա, ներս համատեքստային մենյու - Հատկություններ - Թույլտվություններև ակտիվացնել նյութը - Կատարում: Թույլ տվեք ֆայլին գործարկել որպես ծրագիր:

Ստեղծված սկրիպտը կատարելու համար անհրաժեշտ է բացել տերմինալը (ինչի մասին գրել էի հոդվածի հենց սկզբում, որ տերմինալը անհրաժեշտ հատկանիշ/գործիք է սկրիպտը կատարելու համար), մուտքագրեք. շ, բացատով անջատված սցենարի անվանումը - թարմացնել.շև սեղմեք ստեղնը Մուտքագրում:

Կամ տերմինալում մուտքագրեք շև քաշել ֆայլերի կառավարիչստեղծված ֆայլը սցենարով (նաև առանձնացված բացատով).

Հրամանից հետո ֆայլի ուղին ցուցադրվելուց հետո շև բացատ, պարզապես սեղմեք ստեղնը Մուտքագրեք(Մուտքագրեք) համակարգի թարմացում կատարելու համար.

Այժմ ցանկացած պահի կարող եք կատարել համակարգի թարմացում, որը ստեղծվել է ձեր սեփական սցենարով:

Այո, ինչ-որ մեկը կարող է վիճել, որ համակարգը թարմացնելը դժվար չէ տերմինալում կատարելով այս երկու հրամանները, ինչո՞ւ փչել և ստեղծել ինչ-որ սկրիպտներ: Ճիշտ է. Բայց սա պարզ սցենար ստեղծելու օրինակ է՝ ցույց տալու, որ «Աստվածները չեն վառում կաթսաները» 😃։

Սովորելով գրել և օգտագործել ամենապարզ սկրիպտները՝ կարող եք ստեղծել համակարգի կազմաձևման սկրիպտ, որպեսզի համակարգի վերատեղադրման դեպքում նրանք կարողանան օգտագործել ստեղծված սկրիպտը՝ առանց ցանցում ամեն անգամ նմանատիպ կարգավորումներով կայքեր փնտրելու:

Ձեզանից շատերը, ամենայն հավանականությամբ, օգտագործում են համակարգային թյունինգ կայքեր, ինչպիսիք են դրանք, որոնք ես տեղադրում եմ հաջորդ թողարկումից հետո: ubuntu - Ubuntu տեղադրումից հետոկամ նմանատիպ կայքեր: Բացեք այս կայքերից մեկը. այնուհետև տեքստային խմբագրիչ՝ սցենարը ստեղծելու համար:
Օրինակ՝ ես դատարկ դարձրի հետևյալը.

IN տեքստային խմբագիրմուտքագրեք առաջին պահանջվող տողը.

# Տեղադրվելուց հետո Ubuntu-ի կարգավորում
# Համակարգի թարմացում

Հետևյալը համակարգի թարմացման հրամաններն են.

sudo apt թարմացում
sudo apt բարելավում -y

Նկարագրության տող. Պահեստների ավելացում.

# Պահեստների ավելացում

Եվ ավելացրեք անհրաժեշտ պահեստները ծրագրաշարի հետագա տեղադրման համար.

sudo add-apt-repository «deb http://archive.canonical.com/ $(lsb_release -sc) գործընկեր» -y
sudo add-apt-repository ppa:atareao/telegram -y
sudo add-apt-repository ppa:atareao/atareao -y
sudo add-apt-repository ppa:nemh/systemback -y
sudo add-apt-repository ppa:gerardpuig/ppa -y
sudo add-apt-repository ppa:haecker-felix/gradio-daily -y

Անհրաժեշտ պահեստները ավելացնելուց հետո (կրկին, դուք կարող եք ունենալ ձեր սեփական պահեստները, ես օրինակ ունեմ), դուք պետք է թարմացնեք համակարգը.

Տող նկարագրությամբ.

# Թարմացրեք համակարգը պահեստները միացնելուց հետո

Եվ կատարման հրամանը.

sudo apt թարմացում

Այժմ, երբ պահեստները ավելացվել են և համակարգը թարմացվել է, ժամանակն է տեղադրել ծրագրակազմը.

# Ծրագրերի տեղադրում

Ծրագրեր տեղադրելու համար բավական է մեկ անգամ մուտքագրել հրամանը sudo apt տեղադրում, և այնուհետև բաց տարածության միջով տրված տողավելացրեք այնքան ծրագրեր, որքան ցանկանում եք, գլխավորն այն է, որ դրանք ճիշտ կազմված են: Եթե ծրագիրը բաղկացած է մի քանի բառից, ապա դրա հրամանը պետք է լինի միաձույլ, այսինքն. դրա բոլոր բառերը պետք է մուտքագրվեն գծիկի միջոցով, օրինակ. միասնություն-կսմթել-գործիք:

sudo apt install my-weather-indicator telegram skype lm-sensors hddtemp psensor gdebi systemback unity-tweak-tool ubuntu-cleaner gradio -y

Լրացուցիչ կոդեկների տեղադրում

# Մուլտիմեդիա և կոդեկներ

sudo apt install ubuntu-restricted-extras -y

Անջատում համակարգի ձախողումների մասին

# Անջատել համակարգի վթարի մասին հաշվետվությունը

sudo sed -i "s/enabled=1/enabled=0/g" "/etc/default/apport"

Դե, երևի այսքանն է: Ստեղծված սցենարային ֆայլը պետք է այսպիսի տեսք ունենա.

Դուք պետք է պահպանեք այն (սեղմեք կոճակը Պահպանել) և տալ Անուներկարաձգմամբ .շ. Ես զանգեցի նրան Setup\Ubuntu.sh(կարող եք այն այլ կերպ անվանել, բայց միշտ .sh ընդլայնմամբ):

Ստեղծված սցենարը դարձնում ենք գործարկելի.

sudo chmod +x Setup\ Ubuntu.sh

Ստեղծված սկրիպտը գործարկելու համար մուտքագրեք տերմինալ շև ստեղծված սցենարի անվանումը՝ բաժանված բացատով կամ շ, բաց թողեք և քաշեք ստեղծված ֆայլը դեպի տերմինալ, ինչպես ավելի վաղ բացատրվել է ամենապարզ սկրիպտում և սեղմեք ստեղնը Մուտքագրում, այն իրականացնելու համար։

Նշում. ետ կտրվածք հրամանի մեջ Setup\Ubuntu.shտերմինալի համար ֆայլի անվան մեջ բաց է թողնում երկու առանձին բառերի միջև:

Սցենարը կատարելուց հետո պահեք այն ապագայի համար, համակարգի հնարավոր վերատեղադրման և վերակազմավորման համար լավագույնն է թղթապանակի f / սկավառակի առանձին հատվածում: /տուն. Եթե չկա, ապա ներս ամպային ծառայություն (Ամպային պահեստավորումտվյալներ) տեսակը: DropBox, Cloud Mail.Ru, Mega.coև այլն, որպեսզի ցանկացած պահի ինքներդ օգտագործեք սցենարը կամ օգնեք ընկերներին կամ հարազատներին համակարգը կարգավորելիս: