den huvudsakliga / Navigatorer/ Kontrollera ubuntu genom ett skript i Windows. Skapa ditt eget autokörningsskript vid datorstart

Kontrollerar ubuntu genom ett skript i Windows. Skapa ditt eget autokörningsskript vid datorstart

Idag pratar vi om bash-skript. Dessa är kommandoradsskript skrivna för bash-skalet. Det finns andra skal som zsh, tcsh, ksh, men vi kommer att fokusera på bash. Detta material är avsett för alla, det enda villkoret är förmågan att arbeta i Linux-kommandoraden.

Kommandoradsskript är samlingar av samma kommandon som kan skrivas in från tangentbordet, samlas i filer och förenas av något gemensamt syfte. I det här fallet kan resultaten av teamens arbete vara antingen av oberoende värde eller fungera som indata för andra team. Scripting är ett kraftfullt sätt att automatisera ofta utförda åtgärder.

Så om vi pratar om kommandoraden låter det dig utföra flera kommandon samtidigt och ange dem åtskilda av semikolon:

Pwd; vem är jag
Faktum är att om du har provat det i din terminal har ditt första bash-skript som använder två kommandon redan skrivits. Det fungerar så här. Först visar pwd-kommandot information om den aktuella arbetskatalogen, sedan visar whoami-kommandot information om användaren under vilken du är inloggad.

Med detta tillvägagångssätt kan du kombinera så många kommandon som du vill på en rad, begränsningen är bara i det maximala antalet argument som kan skickas till programmet. Du kan bestämma denna begränsning med följande kommando:

Getconf ARG_MAX
Kommandoraden är ett bra verktyg, men du måste ange kommandon varje gång du behöver dem. Vad händer om du skriver en massa kommandon till en fil och bara ringer den filen för att utföra dem? Faktum är att filen vi pratar om kallas ett kommandoradsskript.

Hur bash-skript fungerar

Skapa en tom fil med touch-kommandot. I den första raden måste vi ange vilket skal vi ska använda. Vi är intresserade av bash, så den första raden i filen kommer att vara så här:

#! / bin / bash
I andra rader i den här filen används hash-tecknet för att beteckna kommentarer som skalet inte bearbetar. Den första raden är dock ett specialfall, här en hash följt av ett utropstecken (denna sekvens kallas shebang) och sökvägen till bash indikerar för systemet att manuset skrevs för bash.

Shell-kommandon avgränsas med radflöden, kommentarer avgränsas med hashmarkeringar. Så här ser det ut:

#! / bin / bash # Detta är en kommentar pwd whoami
Här, liksom på kommandoraden, kan du skriva kommandon på en rad, åtskilda av semikolon. Men att skriva kommandon på separata rader gör filen lättare att läsa. I vilket fall som helst kommer skalet att bearbeta dem.

Ställer in skriptfilbehörigheter

Spara filen med namnet myscript och bash-skriptet är nästan klart. Nu återstår bara att göra den här filen körbar, annars försöker du köra den kommer du att stöta på tillståndet nekad.

Försöker köra en skriptfil med felaktigt konfigurerade behörigheter

Låt oss göra filen körbar:

Chmod + x ./myscript
Låt oss nu försöka utföra det:

./myscript
Efter att ha ställt in behörigheterna fungerar allt som det ska.

Bash-skriptet har körts

Visar meddelanden

Ekokommandot används för att mata ut text till Linux-konsolen. Låt oss dra nytta av kunskapen om detta faktum och redigera vårt skript och lägga till förklaringar till de data som visas med kommandona som redan finns i det:

#! / bin / bash # vår kommentar är här echo "Den aktuella katalogen är:" pwd echo "Den inloggade användaren är:" whoami
Detta är vad som händer efter att ha kört det uppdaterade skriptet.

Visar meddelanden från ett skript

Nu kan vi skriva ut förklarande anmärkningar med hjälp av ekokommandot. Om du inte vet hur du redigerar en fil med Linux-verktyg eller inte har sett echo-kommandot tidigare, ta en titt på den här resursen.

Använda variabler

Med variabler kan du lagra information i en skriptfil, till exempel resultaten av kommandon som ska användas av andra kommandon.

Det är inget fel med att utföra enskilda kommandon utan att lagra resultaten av deras arbete, men möjligheterna med detta tillvägagångssätt är mycket begränsade.

Det finns två typer av variabler som kan användas i bash-skript:

Miljövariabler
Användarvariabler

Miljövariabler

Ibland måste skalkommandon arbeta med vissa systemdata. Så här till exempel listar du hemkatalogen för den aktuella användaren:

#! / bin / bash # visa användarens hemeko "Hem för den aktuella användaren är: $ HOME"
Observera att vi kan använda systemvariabeln $ HOME i dubbla citat, detta kommer inte att hindra systemet från att känna igen det. Det här är vad som händer om du kör ovanstående skript.

Använda en miljövariabel i ett skript

Vad händer om du vill visa dollartecknet på skärmen? Låt oss prova detta:

Echo "Jag har $ 1 i fickan"
Systemet upptäcker dollartecknet i den citerade strängen och tror att vi refererade till en variabel. Skriptet försöker visa värdet på den odefinierade variabeln $ 1. Det här är inte vad vi vill ha. Vad ska man göra?

En backslash escape-karaktär före dollartecknet kan hjälpa till i denna situation:

Ekot "Jag har \ $ 1 i fickan"
Skriptet matar nu ut exakt vad som förväntas.

Använda en Escape-sekvens för att mata ut ett dollartecken

Användarvariabler

Förutom miljövariabler låter bash-skript dig ställa in och använda dina egna variabler i skriptet. Dessa variabler håller sitt värde tills skriptet är slutfört.

Som med systemvariabler kan användarvariabler nås med dollartecknet:
TNW-CUS-FMP - kampanjkod för 10% rabatt på våra tjänster, tillgänglig för aktivering inom 7 dagar
#! / bin / bash # testvariabler grade = 5 person = "Adam" echo "$ person är en bra pojke, han är i klass $ grade"
Detta är vad som händer efter att ha kört ett sådant manus.

Anpassade variabler i ett skript

Kommandosubstitution

En av de mest användbara funktionerna i bash-skript är möjligheten att extrahera information från kommandoutgången och tilldela den till variabler, vilket gör att denna information kan användas var som helst i skriptfilen.

Detta kan göras på två sätt.

Med backtick ""
Använda $ ()

Använd det första tillvägagångssättet och se till att du inte använder en enda offert istället för backtick. Kommandot måste ingå i två sådana ikoner:

Mydir = `pwd`
I den andra metoden skrivs samma sak så här:

Mydir = $ (pwd)
Och manuset kan i slutändan se ut så här:

#! / bin / bash mydir = $ (pwd) echo $ mydir
Under operationen sparas utdata från pwd-kommandot i mydir-variabeln, vars innehåll, med hjälp av ekokommandot, går till konsolen.

Ett skript som lagrar resultaten av ett kommando i en variabel

Matematiska operationer

För att utföra matematiska operationer i en skriptfil kan du använda en konstruktion som $ ((a + b)):

#! / bin / bash var1 = $ ((5 + 5)) echo $ var1 var2 = $ (($ var1 * 2)) echo $ var2

Matematikoperationer i ett manus

Om-då-kontrollkonstruktion

Vissa scenarier kräver kontroll av flödet av kommandokörningen. Till exempel, om något värde är större än fem, måste du utföra en åtgärd, annars - en annan. Detta är tillämpligt i många situationer, och om-då-kontrollkonstruktionen hjälper oss här. I sin enklaste form ser det ut så här:

Om kommando då kommando fi
Och här är ett fungerande exempel:

#! / bin / bash om pwd då ekar "Det fungerar" fi
I det här fallet, om pwd-kommandot slutförts framgångsrikt, kommer texten "det fungerar" att visas i konsolen.

Låt oss använda vår kunskap och skriva ett mer komplext manus. Låt oss säga att du måste hitta en viss användare i / etc / passwd, och om du hittar den, rapportera att den finns.

#! / bin / bash user = likegeeks om grep $ user / etc / passwd då ekar "The user $ user Exists" fi
Det här är vad som händer när du kör det här skriptet.

Sök efter en användare

Här har vi använt grep-kommandot för att hitta användaren i filen / etc / passwd. Om du inte känner till grep-kommandot kan dess beskrivning hittas.

I det här exemplet, om en användare hittas, visar skriptet ett lämpligt meddelande. Vad händer om användaren inte kan hittas? I det här fallet kommer skriptet helt enkelt att avslutas utan att berätta något för oss. Jag skulle vilja att han berättade om detta också, så vi kommer att förbättra koden.

Om-då-annars kontrollkonstruktion

För att programmet ska kunna rapportera både resultaten av en lyckad sökning och ett misslyckande, kommer vi att använda if-then-else-konstruktionen. Så här fungerar det:

Om kommando kommandon annars kommandon fi kommandon
Om det första kommandot returnerar noll, vilket betyder att det är framgångsrikt, kommer villkoret att vara sant och körningen kommer inte att följa den andra grenen. Annars, om något annat än noll returneras, vilket innebär fel eller ett falskt resultat, kommer kommandona efter det andra att köras.

Låt oss skriva ett manus så här:

#! / bin / bash user = anotherUser om grep $ user / etc / passwd då ekar "användaren $ user existerar" annars echo "användaren $ user existerar inte" fi
Dess utförande gick längs den andra grenen.

Köra ett skript med en if-then-else-konstruktion

Tja, låt oss fortsätta och fråga oss om svårare förhållanden. Vad händer om du behöver kontrollera mer än ett tillstånd, men flera? Om till exempel den önskade användaren hittas måste du visa ett meddelande, om något annat villkor är uppfyllt - ett annat meddelande och så vidare. I en sådan situation kommer kapslade förhållanden att hjälpa oss. Det ser ut så här:

Om command1 sedan kommandon elif command2 sedan fi kommandon
Om det första kommandot returnerar noll, vilket indikerar dess framgångsrika körning, kommer kommandona i det första därefter blocket att exekveras, annars, om det första villkoret visar sig vara falskt, och om det andra kommandot returnerar noll, kommer det andra kodblocket att bli avrättad.

#! / bin / bash user = anotherUser om grep $ user / etc / passwd då echo "The user $ user Exists" elif ls / home then echo "Användaren finns inte men det finns ändå en katalog under / home" fi
I ett sådant skript kan du till exempel skapa en ny användare med kommandot useradd om sökningen inte gav några resultat eller gjorde något annat användbart.

Jämföra siffror

Numeriska värden kan jämföras i skript. Nedan är en lista över relevanta kommandon.

n1 -eq n2 Returnerar true om n1 är lika med n2.
n1 -ge n2 Returnerar true om n1 är större än eller lika med n2.
n1 -gt n2 Returnerar true om n1 är större än n2.
n1 -le n2 Returnerar true om n1 är mindre än eller lika med n2.
n1 -lt n2 Returnerar true om n1 är mindre än n2.
n1 -ne n2 Returnerar true om n1 inte är lika med n2.

Låt oss prova en av jämförelseoperatörerna som ett exempel. Observera att uttrycket är inneslutet inom hakparenteser.

#! / bin / bash val1 = 6 om [$ val1 -gt 5] då eko "Testvärdet $ val1 är större än 5" annars echo "Testvärdet $ val1 är inte större än 5" fi
Detta är vad detta kommando kommer att mata ut.

Jämföra siffror i skript

Värdet på den variabla val1 är större än 5, som ett resultat exekveras den dåvarande grenen av jämförelseoperatören och ett motsvarande meddelande visas på konsolen.

Strängjämförelse

Du kan också jämföra strängvärden i skript. Jämförelseoperatörer ser ganska enkla ut, men strängjämförelseoperationer har vissa särdrag, som vi kommer att beröra nedan. Här är en lista över operatörer.

str1 = str2 Testar strängar för jämlikhet, returnerar true om strängar är identiska.
s tr1! = str2 Returnerar true om strängarna inte är identiska.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1> str2 Returnerar true om str1 är större än str2.
-n str1 Returnerar true om str1 är större än noll.
-z str1 Returnerar sant om längden på str1 är noll.

Här är ett exempel på att jämföra strängar i ett manus:

#! / bin / bash user = "likegeeks" om [$ user = $ USER] då ekar "User $ user är den nuvarande inloggade användaren" fi
Som ett resultat av skriptkörningen får vi följande.

Jämföra strängar i skript

Här är en funktion av strängjämförelse värt att nämna. Operatörerna ">" och "<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>"Som ett kommando för utgående omdirigering.

Så här ser det ut att arbeta med dessa operatörer i kod:

#! / bin / bash val1 = text val2 = "en annan text" om [$ val1 \>
Här är resultatet av manuset.

Jämförelse av strängar, utfärdad varning

Observera att skriptet, även om det körs, genererar en varning:

./myscript: rad 5: [: för många argument
För att bli av med denna varning, bifoga $ val2 i dubbla citat:

#! / bin / bash val1 = text val2 = "en annan text" om [$ val1 \> "$ val2"] då eko "$ val1 är större än $ val2" annars eko "$ val1 är mindre än $ val2" fi
Nu fungerar allt som det ska.

Strängjämförelse

En annan funktion hos operatörerna ">" och "<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Likegeeks likegeeks
Låt oss spara det, ge namnet myfile och kör sedan följande kommando i terminalen:

Sortera min fil
Det sorterar raderna från filen så här:

Likegeeks
Sorteringskommandot sorterar som standard rader i stigande ordning, det vill säga den gemena bokstaven i vårt exempel är mindre än den stora bokstaven. Låt oss nu förbereda ett skript som kommer att jämföra samma strängar:

#! / bin / bash val1 = Likegeeks val2 = likegeeks om [$ val1 \> $ val2] då eko "$ val1 är större än $ val2" annars eko "$ val1 är mindre än $ val2" fi
Om du kör den visar det sig att motsatsen är sant - gemener är nu större än den stora bokstaven.

Sortera kommando- och radjämförelse i en skriptfil

Jämförelsekommandon har färre versaler. Jämförelse av strängar här görs genom att jämföra ASCII-teckenkoder, sorteringsordningen beror således på teckenkoderna.

Sorteringskommandot använder i sin tur den sorteringsordning som anges i systemspråkinställningarna.

Filkontroller

Kommandona nedan är förmodligen de vanligaste i bash-skript. De låter dig kontrollera olika villkor för filer. Här är en lista över dessa kommandon.

-d-fil Kontrollerar om en fil finns och är en katalog.
-e-fil Kontrollerar om filen finns.
-f-fil Kontrollerar om filen finns och är en fil.
-r-fil Kontrollerar om filen finns och är läsbar.
-s-fil Kontrollera om filen finns och inte är tom.
-w-fil Kontrollerar om filen finns och är skrivbar.
-x-fil Kontrollerar om filen finns och är körbar.
file1 -nt file2 Kontrollerar om file1 är nyare än file2.
file1 -ot file2 Kontrollerar om file1 är äldre än file2.
-O-fil Kontrollerar om filen finns och ägs av den aktuella användaren.
-G-fil Kontrollerar om filen finns och om dess grupp-ID matchar grupp-ID för den aktuella användaren.

Dessa kommandon, liksom många andra som diskuteras idag, är lätta att komma ihåg. Deras namn, som förkortningar från olika ord, anger direkt de kontroller de utför.

Låt oss prova ett av kommandona i praktiken:

#! / bin / bash mydir = / home / likegeeks om [-d $ mydir] då ekar "$ mydir-katalogen finns" cd $ mydir ls annars echo "$ mydir-katalogen finns inte" fi
Detta skript, för en befintlig katalog, visar dess innehåll.

Mata ut innehållet i en katalog

Vi tror att du kan experimentera med resten av kommandona på egen hand, de gäller alla på samma sätt.

Resultat

Idag berättade vi hur vi kom igång med att skriva bash-skript och täckte några grundläggande saker. Faktum är att ämnet bash-programmering är enormt. Denna artikel är en översättning av den första delen av en stor serie med 11 artiklar. Om du vill fortsätta just nu - här är en lista över originalen på dessa material. För enkelhets skull inkluderar detta den översättning du just läst.

Så om vi pratar om kommandoraden låter det dig utföra flera kommandon samtidigt och ange dem åtskilda av semikolon:

Hur bash-skript fungerar

Skapa en tom fil med touch-kommandot. I den första raden måste vi ange vilket skal vi ska använda. Vi är intresserade av bash, så den första raden i filen kommer att vara så här:

Shell-kommandon avgränsas med radflöden, kommentarer avgränsas med hashmarkeringar. Så här ser det ut:

Ställer in skriptfilbehörigheter

Spara filen med namnet myscript och bash-skriptet är nästan klart. Nu återstår bara att göra den här filen körbar, annars försöker du köra den kommer du att stöta på tillståndet nekad.

Försöker köra en skriptfil med felaktigt konfigurerade behörigheter

Låt oss göra filen körbar:

Chmod + x ./myscript
Låt oss nu försöka utföra det:

./myscript
Efter att ha ställt in behörigheterna fungerar allt som det ska.

Bash-skriptet har körts

Visar meddelanden

#! / bin / bash # vår kommentar är här echo "Den aktuella katalogen är:" pwd echo "Den inloggade användaren är:" whoami
Detta är vad som händer efter att ha kört det uppdaterade skriptet.

Visar meddelanden från ett skript

Använda variabler

Med variabler kan du lagra information i en skriptfil, till exempel resultaten av kommandon som ska användas av andra kommandon.

Det är inget fel med att utföra enskilda kommandon utan att lagra resultaten av deras arbete, men möjligheterna med detta tillvägagångssätt är mycket begränsade.

Det finns två typer av variabler som kan användas i bash-skript:

Miljövariabler
Användarvariabler

Miljövariabler

Ibland måste skalkommandon arbeta med vissa systemdata. Så här till exempel listar du hemkatalogen för den aktuella användaren:

Använda en miljövariabel i ett skript

Vad händer om du vill visa dollartecknet på skärmen? Låt oss prova detta:

En backslash escape-karaktär före dollartecknet kan hjälpa till i denna situation:

Ekot "Jag har \ $ 1 i fickan"
Skriptet matar nu ut exakt vad som förväntas.

Använda en Escape-sekvens för att mata ut ett dollartecken

Användarvariabler

Förutom miljövariabler låter bash-skript dig ställa in och använda dina egna variabler i skriptet. Dessa variabler håller sitt värde tills skriptet är slutfört.

Anpassade variabler i ett skript

Kommandosubstitution

Detta kan göras på två sätt.

Med backtick ""
Använda $ ()

Använd det första tillvägagångssättet och se till att du inte använder en enda offert istället för backtick. Kommandot måste ingå i två sådana ikoner:

Mydir = `pwd`
I den andra metoden skrivs samma sak så här:

Mydir = $ (pwd)
Och manuset kan i slutändan se ut så här:

#! / bin / bash mydir = $ (pwd) echo $ mydir
Under operationen sparas utdata från pwd-kommandot i mydir-variabeln, vars innehåll, med hjälp av ekokommandot, går till konsolen.

Ett skript som lagrar resultaten av ett kommando i en variabel

Matematiska operationer

För att utföra matematiska operationer i en skriptfil kan du använda en konstruktion som $ ((a + b)):

#! / bin / bash var1 = $ ((5 + 5)) echo $ var1 var2 = $ (($ var1 * 2)) echo $ var2

Matematikoperationer i ett manus

Om-då-kontrollkonstruktion

Om kommando då kommando fi
Och här är ett fungerande exempel:

#! / bin / bash om pwd då ekar "Det fungerar" fi
I det här fallet, om pwd-kommandot slutförts framgångsrikt, kommer texten "det fungerar" att visas i konsolen.

Låt oss använda vår kunskap och skriva ett mer komplext manus. Låt oss säga att du måste hitta en viss användare i / etc / passwd, och om du hittar den, rapportera att den finns.

#! / bin / bash user = likegeeks om grep $ user / etc / passwd då ekar "The user $ user Exists" fi
Det här är vad som händer när du kör det här skriptet.

Sök efter en användare

Här har vi använt grep-kommandot för att hitta användaren i filen / etc / passwd. Om du inte känner till grep-kommandot kan dess beskrivning hittas.

Om-då-annars kontrollkonstruktion

För att programmet ska kunna rapportera både resultaten av en lyckad sökning och ett misslyckande, kommer vi att använda if-then-else-konstruktionen. Så här fungerar det:

Låt oss skriva ett manus så här:

Köra ett skript med en if-then-else-konstruktion

Jämföra siffror

Numeriska värden kan jämföras i skript. Nedan är en lista över relevanta kommandon.

n1 -eq n2 Returnerar true om n1 är lika med n2.
n1 -ge n2 Returnerar true om n1 är större än eller lika med n2.
n1 -gt n2 Returnerar true om n1 är större än n2.
n1 -le n2 Returnerar true om n1 är mindre än eller lika med n2.
n1 -lt n2 Returnerar true om n1 är mindre än n2.
n1 -ne n2 Returnerar true om n1 inte är lika med n2.

Låt oss prova en av jämförelseoperatörerna som ett exempel. Observera att uttrycket är inneslutet inom hakparenteser.

#! / bin / bash val1 = 6 om [$ val1 -gt 5] då eko "Testvärdet $ val1 är större än 5" annars echo "Testvärdet $ val1 är inte större än 5" fi
Detta är vad detta kommando kommer att mata ut.

Jämföra siffror i skript

Värdet på den variabla val1 är större än 5, som ett resultat exekveras den dåvarande grenen av jämförelseoperatören och ett motsvarande meddelande visas på konsolen.

Strängjämförelse

str1 = str2 Testar strängar för jämlikhet, returnerar true om strängar är identiska.
s tr1! = str2 Returnerar true om strängarna inte är identiska.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1> str2 Returnerar true om str1 är större än str2.
-n str1 Returnerar true om str1 är större än noll.
-z str1 Returnerar sant om längden på str1 är noll.

Här är ett exempel på att jämföra strängar i ett manus:

#! / bin / bash user = "likegeeks" om [$ user = $ USER] då ekar "User $ user är den nuvarande inloggade användaren" fi
Som ett resultat av skriptkörningen får vi följande.

Jämföra strängar i skript

Så här ser det ut att arbeta med dessa operatörer i kod:

#! / bin / bash val1 = text val2 = "en annan text" om [$ val1 \>
Här är resultatet av manuset.

Jämförelse av strängar, utfärdad varning

Observera att skriptet, även om det körs, genererar en varning:

./myscript: rad 5: [: för många argument
För att bli av med denna varning, bifoga $ val2 i dubbla citat:

#! / bin / bash val1 = text val2 = "en annan text" om [$ val1 \> "$ val2"] då eko "$ val1 är större än $ val2" annars eko "$ val1 är mindre än $ val2" fi
Nu fungerar allt som det ska.

Strängjämförelse

Likegeeks likegeeks
Låt oss spara det, ge namnet myfile och kör sedan följande kommando i terminalen:

Sortera min fil
Det sorterar raderna från filen så här:

Sortera kommando- och radjämförelse i en skriptfil

Jämförelsekommandon har färre versaler. Jämförelse av strängar här görs genom att jämföra ASCII-teckenkoder, sorteringsordningen beror således på teckenkoderna.

Sorteringskommandot använder i sin tur den sorteringsordning som anges i systemspråkinställningarna.

Filkontroller

Kommandona nedan är förmodligen de vanligaste i bash-skript. De låter dig kontrollera olika villkor för filer. Här är en lista över dessa kommandon.

-d-fil Kontrollerar om en fil finns och är en katalog.
-e-fil Kontrollerar om filen finns.
-f-fil Kontrollerar om filen finns och är en fil.
-r-fil Kontrollerar om filen finns och är läsbar.
-s-fil Kontrollera om filen finns och inte är tom.
-w-fil Kontrollerar om filen finns och är skrivbar.
-x-fil Kontrollerar om filen finns och är körbar.
file1 -nt file2 Kontrollerar om file1 är nyare än file2.
file1 -ot file2 Kontrollerar om file1 är äldre än file2.
-O-fil Kontrollerar om filen finns och ägs av den aktuella användaren.
-G-fil Kontrollerar om filen finns och om dess grupp-ID matchar grupp-ID för den aktuella användaren.

Dessa kommandon, liksom många andra som diskuteras idag, är lätta att komma ihåg. Deras namn, som förkortningar från olika ord, anger direkt de kontroller de utför.

Låt oss prova ett av kommandona i praktiken:

Mata ut innehållet i en katalog

Vi tror att du kan experimentera med resten av kommandona på egen hand, de gäller alla på samma sätt.

Resultat

PCloud för Linux erbjuder en synkroniseringsapplikation för Linux som en bild (den senaste versionen finns tillgänglig). Lösningen på den till synes enkla frågan om att automatisera processen "klientlansering - synkronisering - klientavstängning" ledde till behovet av att lösa flera problem relaterade till särdragen hos pCloud-klientarbetet. Lösningen ges för den grafiska xfce-miljön.

I slutändan resulterade lösningen för att automatisera automatiseringen av processen till att två eller tre uppgifter inleddes enligt ett schema (se).

Startar pCloud-klienten

Ett enkelt skript används för att starta klienten, till exempel pcloud1.sh

#! / bin / bash
/ path_to_file / pcloud

Och det anpassade uppgiftskommandot är

Exportera DISPLAY =: 0 && /path/pcloud1.sh

Path - vägen till skriptet pcloud1.sh

Att först lägga till en utgångslinje till pcloud1.sh (slutföra pcloud1.sh) gav inte det önskade resultatet. Det uppstod två processer i uppgiftshanteraren:

Pcloud1.sh
sh -c export DISPLAY =: 0 && /path/pcloud1.sh

För att förhindra att pcloud1.sh "hänger" i uppgiftshanteraren skapades pcloud2.sh-skriptet, som lanserades på ett schema en minut efter att pcloud1.sh startat. Skriptet är en "begäran" om att avsluta alla befintliga processer med namnet pcloud1.sh

#! / bin / bash
killall -s TERM pcloud1.sh
sova 1 & & avsluta

Stoppar pCloud-klienten

Detta manus var ur tidpunkten för skapandet det mest tidskrävande, vilket förklaras av två skäl.

Fråga 1. Kundens arbete började åtföljas av flera processer. Till exempel när du startar klienten och sedan automatiskt öppnar alla fönster i aktivitetshanteraren kan du se 6 pcloud-processer:

Efter att ha stängt huvudklientfönstret och filhanteringsinstansen som visar pCloudDrive-molninnehållet kommer 5 pcloud-processer att finnas kvar i aktivitetshanteraren:

Eftersom det inte finns något terminalkommando för att stänga av klienten kan du använda lösningen för att "mjukt" avsluta pcloud-processen med dess pid-värde, det vill säga med kommandot kill -15 pid_pcloud

Men om du begär pid för pcloud-processen blir resultatet antingen 6 grupper av siffror som motsvarar pids i pcloud-processerna (exempel: 16129 16103 16077 16048 16036 16032) eller 5 grupper (exempel: 29419 29398 29352 29324 29320). Dessa pidvärden ändras varje gång.

Antalet processer (5 eller 6) beror på om du har öppnat alla fönster som öppnas automatiskt när klienten startar, eller om dessa fönster är stängda och endast statusikonen på skrivbordets stativ (systempanel, fack) är aktiv.

En naturlig fråga uppstår: vilken process ska stängas av?

Fråga 2. När pCloud-klienten startas öppnas automatiskt två fönster, varav det ena är ett klientfönster och det andra är en instans av filhanteraren som motsvarar den öppna pCloudDrive-katalogen, vars innehåll är innehållet i molnutrymmet för pCloud-kontot monterad i den, till exempel:

Om klientfönstret (översta siffran) försvinner efter stängning av pCloud-klienten förblir det andra fönstret öppet. Innehållet i det andra fönstret kommer att vara tomt eftersom pCloud-molnet avmonterades under avstängningen av klienten.

Fråga: och hur stänger du den automatiskt?

Notera. Frågan om att stänga det öppna pCloud-applikationsfönstret ställs inte, eftersom ikonen på panelen (systemfält, fack) i xfce endast visar tillståndet "synkroniserat" eller "synkroniserat". Information om antalet uppladdade eller nedladdade filer samt processens hastighet visas längst ner i det öppna fönstret i pCloud-applikationen.

Vi kommer att svara på de frågor som ställs i följd.

Svar 1. Det konstaterades experimentellt att för att lämna pcloud-klienten är det nödvändigt att stänga av pcloud-processen med det lägsta pid-värdet, vilket motsvarar pCloud Drive-processen (se uppgiftshanteraren). Därför är den svåraste uppgiften att automatisera att välja den minsta pid bland de erhållna värdena för att tilldela den till en variabel senare.

Som det visade sig kan detta problem lösas på minst fyra sätt. Dessutom kan den "mjuka" avstängningen av alla pcloud-processer göras med killall-kommandot som anger processnamnet. Eftersom alla lösningar, varav 5 är typade, leder till samma resultat listas de nedan.

Alternativ 1: killall -s TERM pcloud

Allt är klart här. Ett kommando utfärdas för att avsluta alla pcloud-processer.

De följande tre metoderna är en serie sekventiella operationer. Först hämtas pid-värdena för alla pcloud-instanser och skrivs till en fil (till exempel pcloud.txt). Innehållet i filen är en sekvens av 5 eller 6 grupper av siffror (se förklaring ovan). Sedan "fångas" den sista gruppen (5 siffror) från den resulterande serien av pidvärden och tilldelas en variabel (till exempel VAR). Det sista steget är att köra kommandot kill -15 $ VAR, vilket är detsamma som att köra kill -15 med det lägsta pidvärdet från filen pcloud.txt.

2, 3, 4 alternativ:
pidof pcloud> ~ / pcloud.txt
VAR = `cat ~ / pcloud.txt | grep -o * $ `
döda -15 $ VAR

Pidof pcloud> ~ / pcloud.txt
VAR = `cat ~ / pcloud.txt | awk "(skriv ut $ NF)" "
döda -15 $ VAR

Pidof pcloud> ~ / pcloud.txt
VAR = `cat ~ / pcloud.txt | rev | klipp -d "" -f 1 | varv
döda -15 $ VAR

Varianter 1–4 föreslogs av användare av Linuxmint.com.ru-forumet med smeknamnen lutande (2), Chocobo (3 och 4), demonlibra (1). Med detta tillfälle vill jag än en gång uttrycka min tacksamhet till dem.

Alternativ 5

När du får en lista över pid-processer pcloud med kommandot pgrep kommer resultatet i pcloud.txt-filen att visas "i en kolumn", det vill säga varje pid-värde kommer att ligga på en ny rad i stigande ordning, till exempel:

29320
29324
29352
29398
29419

Nästa steg är att tilldela variabeln värdet på den allra första raden i filen pcloud.txt.

Pgrep pcloud> ~ / pcloud.txt
VAR = `sed -n" 1p "~ / pcloud.txt`
döda -15 $ VAR

Svar 2. Trots att kommandot att stänga det aktiva Thunar-fönstret verkar vara enkelt med kommandot thunar (erhållet efter att ha utfört thunar --hjälp i terminalen), fungerar det i det här fallet inte.

Efter att ha granskat processträdet fann man att det finns Thunar - demon i listan över aktiva processer:

Det finns tre sätt att stänga Thunar-fönstret som öppnas av pCloud-klienten:

A) döda alla aktiva Thunar-processer killall -s TERM / usr / bin / Thunar;

B) få pid av Thunar-processen, skriv den till en variabel och avsluta den med dödkommandot -15 variable_value

OUTPUT = "$ (pidof / usr / bin / thunar)"
döda -15 $ (UTGÅNG)

C) få tag i Thunar-processen, skriv den till en fil, tilldela variabeln det värde som erhålls från att läsa filen och avsluta den med dödkommandot -15 variabelvärde

Pidof / usr / bin / Thunar> ~ / thunar.txt
VAR2 = `cat ~ / thunar.txt`
döda -15 $ VAR2

Alla alternativ är lika. Resultatet av deras körning är avslutningen av thunar - daemon- och Thunar-processerna (motsvarar ett öppet fönster med innehållet i pCloudDrive-katalogen).

När det gäller frågan om "vikten" av thunar - daemon-processen på det engelsktalande forumet, hittades information att detta inte påverkar Thunar och systemet som helhet i någon större utsträckning. Den enda nackdelen är att utan den här processen monteras det anslutna löstagbara mediet (till exempel en flash-enhet) automatiskt bara när Thunar-fönstret är öppet. Om ingen instans av Thunar körs, monteras inte det flyttbara mediet automatiskt. I det här fallet måste du öppna Thunar och montera den manuellt, till exempel:

I vilket fall som helst, efter nästa start av systemet kommer thunar --daemon att startas automatiskt

vad som bestäms av filens innehåll

/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml (se --daemon)

Totalt kan manuset för att stänga av pCloud-klienten (till exempel pcloud3.sh) ha följande innehåll (ett alternativ och en metod har valts):

#! / bin / bash
alternativ 1, 2, 3, 4, 5
sova 5
metod a, b, c
sova 5 && utgång

Kommandot för 5 sekunders paus släep 5 introducerades för att testa skriptet för övervakningsprocesser. Du behöver inte använda den i ett fungerande skript.

Exempel på anpassat cron-jobb för daglig 40-minuters automatisk synkronisering med pCloud från 21:40 till 22:20

40 21 * * * export DISPLAY =: 0 && /home/user/Tools/scripts/pcloud1.sh
41 21 * * * /home/user/Tools/scripts/pcloud2.sh

Om vi bara begränsar oss till start- och avstängningsskript, det vill säga pcloud1.sh och pcloud3.sh, ska pcloud3.sh-skriptet stänga av pcloud med pid-processen inte den minsta, men en till, det vill säga från erhållna serier av värden, till exempel

28354 28355 28359 28371 28399 28426 28449 28684 ,

Den andra ska väljas (28355). Förklaringen är att 28354 motsvarar det aktiva skriptet pcloud1.sh.

Följaktligen kommer följande kod i det här fallet att användas för att stänga av pcloud-processer:

Pgrep pcloud> ~ / pcloud.txt
VAR = `sed -n" 2p "~ / pcloud.txt`
döda -15 $ VAR

Sedan tar den anpassade uppgiften formen, till exempel:

40 21 * * * export DISPLAY =: 0 && /home/user/Tools/scripts/pcloud1.sh
20 22 * * * /home/user/Tools/scripts/pcloud3.sh

Först och främst, låt oss ta en titt på vad som är manus och vad är det för.

Manusöversatt från engelska - scenario... Vi tittar alla på filmer, många av oss tittar på föreställningar. För att skapa en film / pjäs skriver manusförfattare manus till dem, på grundval av vilka skådespelarna, scen för scen, utför sina roller på scenen, vilket utgör filmen / pjäsen. Arbetet med att skapa manuset är ganska noggrant, där man måste ta hänsyn till allt till minsta detalj, så att artisterna i slutändan kan uppfylla manusförfattarens plan och betraktaren ser hela arbetet.

På samma sätt skrivs skript för att utföra en lista över uppgifter som användaren sätter ihop (kod) för att göra dem enklare och snabbare i operativsystemet. Det är inte nödvändigt att ha en programmerareutbildning för att skriva enkla manus.

Låt oss först skapa det enklaste skript-skal för att uppdatera systemet.

Jag kommer att utföra alla åtgärder med systemet Ubuntu men de är också tillämpliga på andra system Linux härrörande från Ubuntu... För detta behöver vi: Textredigerare för att fylla den med nödvändiga uppgifter för att skapa ett skript (kod) och Terminal- att köra det skapade skriptet. Dessa verktyg installeras på alla distributioner Linux standard.

Så öppna en textredigerare Gedit och ange de första önskade tecknen i den under namnet shebang.
shebang i programmering är det en sekvens av två tecken: en hash och ett utropstecken ( #! ) i början av skriptfilen. Och lägg till dessa tecken utan mellanslag / bin / sh- tolk där manuset kommer att köras. / bin / sh- det här är vanligtvis Bourne skal eller en kompatibel kommandoradstolk som passerar "sökväg / till / skript" som den första parametern.
Den första obligatoriska raden i skriptet ser ut så här:

# Mitt första Ubuntu-uppgraderingsskript

Hashtecknet (#) i början av en rad gör det tydligt för tolk / terminal att denna rad inte behöver läsas och köras. Linjen behövs i koden för detta manus så att manusskaparen själv vet vad han ska utföra på ett visst segment / scen i koden, för att inte bli förvirrad i framtiden när det finns många sådana rader . Sådana linjer med ett hash-tecken kallas - kommenterade .

sudo apt uppdatering
sudo apt uppgradering -y

-y i slutet av det andra kommandot gör det klart för tolk / terminal att denna åtgärd / kommando måste utföras automatiskt, utan ytterligare bekräftelse av användaren, genom att trycka på en tangent Inmatning. y- förkortat från engelska ja, d.v.s. Ja.

Det är allt. Ditt första skript har skapats. Du borde ha något som bilden:

Det återstår att spara den skapade filen / skriptet och ge det namn med en förlängning som krävs i slutet - .sh... Förlängning .sh tilldelas den körbara filen.
jag gav honom namn - update.sh sparar in Hemmapp användare:

För att den skapade filen / skriptet ska kunna köras måste den ges tillstånd att göra det. Detta kan göras på två sätt.

1. Kör följande kommando i terminalen:

sudo chmod + x update.sh

2. Eller öppna filhanteraren i Hemmapp(där du sparade det genererade skriptet), högerklicka på filen i snabbmenyn - Fastigheter - Rättigheter och aktivera artikeln - Prestanda: Låt filen köras som ett program:

För att köra det skapade skriptet måste du öppna en terminal (som jag skrev om i början av artikeln, att terminalen är ett nödvändigt attribut / verktyg för att utföra skriptet), ange sh, är namnet på skriptet åtskilt av ett mellanslag - update.sh och tryck på knappen Inmatning:

Eller i terminalen går vi in sh och dra den skapade filen med skriptet från filhanteraren (också avgränsat med ett mellanslag):

Efter att filvägen visas efter kommandot sh och ett mellanslag, tryck bara på knappen Stiga på(Enter) för att uppdatera systemet:

Nu när som helst kan du göra en systemuppdatering skapad med ditt eget skript.

Ja, någon kan argumentera för att det inte är svårt att uppdatera systemet genom att utföra dessa två kommandon i terminalen, varför puffa upp och skapa några skript? Det är okej. Men detta är ett exempel på att skapa ett enkelt manus för att visa att "det är inte gudarna som bränner krukor"

Skriva skript i Linux (lärande med exempel)

———————————————————————————-

1. Introduktion

Vad du behöver för att skriva manus
Kunskaper i kommandoradsverktyg och deras nödvändiga alternativ.
Grundläggande kunskaper i engelska på grundskolanivå skadar inte.

Varför manus behövs
För det första kommer administrationen av en Linux-server, i en eller annan grad, ner till det systematiska utförandet av samma kommandon. Dessutom är det inte nödvändigt att dessa kommandon utförs av en person. De kan programmeras att köras av maskinen.
För det andra, även att bara utföra en gemensam uppgift, som (plötsligt) uppgår till 20-1000 ... repetitiva operationer är MYCKET lättare att implementera i ett skript.

Vad är ett manus
Ett skript är en uppsättning instruktioner som en dator måste utföra i en specifik ordning och vid en viss tidpunkt. Instruktioner kan vara antingen interna skalkommandon (slingor, villkor, bearbetning av textinformation, arbete med miljövariabler etc.) eller något program som vi kör i konsolen med nödvändiga parametrar.

Hur man skriver ett manus
I vårt fall kommer skriptet att vara en textfil med körattribut. Om en skriptfil börjar med #!, Som kallas sha-bang i UNIX-världen, berättar detta för systemet vilken tolk som ska användas för att köra skriptet. Om detta är svårt att förstå, kom bara ihåg att vi börjar skriva alla skript exakt från raden #! / Bin / bash eller #! / Bin / sh, och sedan kommer kommandon och kommentarer till dem.

Avskedsord
Jag rekommenderar uppriktigt att du skriver så många kommentarer som möjligt till nästan alla rader i manuset. Tiden kommer att gå och du kommer att behöva ändra eller modernisera det manus som skrivs en gång. Om du inte kommer ihåg eller förstår vad som står i manuset blir det svårt att ändra det, det är lättare att skriva från grunden.

Vilka skript vi kan behöva:

ställa in brandväggsregler när systemet startar.

säkerhetskopiera inställningar och data.

lägga till brevlådor till e-postservern (närmare bestämt till mysql-databasen)

som startar vid ett visst tillfälle (helst varje natt) ett program som skannar proxyserverns loggar och genererar en bekväm webbrapport om mängden nedladdad trafik.

skicka oss via e-post information om att någon har fått tillgång till vår server via ssh, anslutningstid och klientens adress.

Om skripttekniker
Vi skapar en textfil, redigerar den, ställer in körningstillstånd, startar, kontrollerar fel, fixar, startar, kontrollerar fel ...
När allt är slickat och fungerar korrekt lägger vi det i autoladdning eller i schemaläggaren under en viss tid.

———————————————————————————-

2. Lära sig att skriva manus på det interna BASH-språket
original: https://www.linuxconfig.org/Bash_scripting_Tutorial

Denna handledning förutsätter ingen förkunskaper om skripttekniker (scripting) som använder det interna Bash-språket. Med den här guiden kommer du snart att upptäcka att manus är en mycket enkel uppgift. Låt oss börja vår handledning med ett enkelt skript som matar ut strängen "Hello World!" (översatt från engelska - Hej allihopa!)

1. Scenario "Hej alla"
Här är ditt första bash-skriptexempel:

#! / bin / bash
eko "Hello World"

Gå till katalogen som innehåller vår hello_world.sh-fil och gör den körbar:

Kod: Välj allt $ chmod + x hello_world.sh

Kör skriptet för körning

Kod: Välj alla $ ./hello_world.sh

2. Ett enkelt arkiv bash-skript

#! / bin / bash
tar -czf myhome_directory.tar.gz / home / user

Kod: Välj alla $ ./backup.sh

$ du -sh myhome_directory.tar.gz
41M myhome_directory.tar.gz

3. Arbeta med variabler
I det här exemplet deklarerar vi en enkel variabel och skriver ut den på skärmen med hjälp av ekokommandot

#! / bin / bash
STRING = "HELLO WORLD !!!"
eko $ STRING

Kod: Välj alla $ ./hello_world.sh
HEJ VÄRLDEN !!!

Vårt arkiveringsskript med variabler:

#! / bin / bash
OF = myhome_directory _ $ (datum +% Y% m% d) .tar.gz
IF = / hem / användare
tjära -czf $ OF $ IF

Kod: Välj alla $ ./backup.sh
tar: Ta bort ledande "\" från medlemsnamn
$ du -sh * tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Globala och lokala variabler

#! / bin / bash
# Förklara en global variabel
# En sådan variabel kan användas var som helst i detta skript
VAR = "global variabel"
funktion bash (
# Förklara en lokal variabel
# En sådan variabel är endast giltig för den funktion där den deklareras
lokal VAR = "lokal variabel"
eko $ VAR
}
eko $ VAR
våldsamt slag
# Observera att den globala variabeln inte har förändrats
eko $ VAR

Kod: Välj alla $ ./variables.sh
global variabel
lokal variabel
global variabel

4. Skicka argument till manuset

#! / bin / bash
# Använd fördefinierade variabler för att få åtkomst till argument
# Visa argument på skärmen
echo $ 1 $ 2 $ 3 '-> echo $ 1 $ 2 $ 3'
# Vi kan också komma åt argumenten genom den speciella matrisen args = (“ [e-postskyddad]»)
# Visa argument på skärmen
echo $ (args) $ (args) $ (args) ‘-> args = (“ [e-postskyddad]"); echo $ (args) $ (args) $ (args) '
# Använd en variabel [e-postskyddad] att mata ut alla argument samtidigt
eko [e-postskyddad]‘-> eko [e-postskyddad]’
Använd variabeln $ # för att visa antalet argument som skickats till skriptet
echo Antal överförda argument: $ # ‘-> echo Antal överförda argument: $ #’

Kod: Välj alla $ ./arguments.sh Bash Scripting Tutorial
Bash Scripting Tutorial -> echo $ 1 $ 2 $ 3
Bash Scripting Tutorial -> args = (" [e-postskyddad]"); echo $ (args) $ (args) $ (args)
Bash Scripting Tutorial -> echo [e-postskyddad]
Antal överförda argument: 3 -> eko Antal överförda argument: $ #

5. Utföra skalkommandon i ett skript

#! / bin / bash
# använd backticks "" "" för att köra skalkommando
eko `uname -o`
# nu ska vi försöka utan citat
echo uname -o

Kod: Välj alla $ uname -o
GNU / Linux
$ ./bash_backtricks.sh
GNU / Linux
uname -o

Som du kan se, i det andra fallet, visades själva kommandot och inte resultatet av dess körning.

6. Läsa användarinmatning (interaktivitet)

#! / bin / bash
echo -e "Hej, skriv ordet: \ c"
läs ord
eko "Det ord du angav är: $ word"
echo -e “Kan du skriva två ord? "
läs ord1 ord2
eko "Här är din inmatning: \" $ word1 \ "\" $ word2 \ ""
echo -e “Hur tycker du om bash-skript? "
# read-kommandot lagrar nu ett svar i standardinbyggnadsvariabeln $ REPLY
läsa
eko “Du sa $ SVAR, jag är glad att höra det! "
echo -e “Vilka är dina favoritfärger? "
# -a gör läskommandot för att läsa i en matris
läs -en färger
eko "Mina favoritfärger är också $ (färger), $ (färger) och $ (färger) :-)"

Kod: Välj alla $ ./read.sh
Hej, skriv ordet: något
Ordet du skrev in är: något
Kan du skriva två ord?
Debian Linux
Här är din inmatning: "Debian" "Linux"
Hur känner du dig för bash-skript?
Bra
Du sa bra, jag är glad att höra det!
Vilka är dina favoritfärger?
blågrön svart
Mina favoritfärger är också blå, grön och svart :-)

7. Använda en fälla

#! / bin / bash
# förklara en fälla
trap bashtrap INT
# rensa skärmen
klar;
# krokfunktionen körs när användaren trycker på CTRL-C:
# Skärmen visar => Exekvering av bash trap subrutine!
# men manuset kommer att fortsätta att köras
bashtrap ()
{
eko "CTRL + C upptäckt! ... kör bash trap!"
}
# skript räknas till 10
för a i `seq 1 10`; do
eko "$ a / 10 till Exit."
sova 1;
Gjort
eko "Exit Bash Trap Exempel !!!"

Kod: Välj alla $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL + C upptäckt! ... kör bash trap!
10/10
Exit Bash Trap Exempel !!!

Som du kan se stoppade tangentkombinationen Ctrl-C inte körningen av skriptet.

8. Arrayer
8.1 Deklarera en enkel matris

#! / bin / bash
# Förklara en enkel matris med fyra element
ARRAY = ('Debian Linux' '' Redhat Linux 'Ubuntu Linux)
# Få antalet element i matrisen
ELEMENTS = $ (# ARRAY [@])
# mata ut i en slinga varje element i matrisen
för ((i = 0; i<$ELEMENTS;i++)); do
echo $ (ARRAY [$ (i)])
Gjort

Kod: Välj alla $. / Arrays.sh
Debian Linux
Redhat Linux
Ubuntu
Linux

8.2 Fyllning av matrisen med värden från filen

#! / bin / bash
# Förklara en matris
förklara -en ARRAY
# Exec-kommando # stdin (vanligtvis tangentbordet) kommer att produceras från den här filen. Detta gör det möjligt att läsa
# innehållet i filen, rad för rad, och analysera varje rad som anges med sed och / eller awk.
exec 10 låt räkna = 0
medan du läser LINE<&10; do
ARRAY [$ count] = $ LINE
((räkna ++))
Gjort
eko Antal element: $ (# ARRAY [@])
# Matar ut matrisvärden
echo $ (ARRAY [@])
# stäng filen
exec 10> & -

Kod: Välj alla $ cat bash.txt
Debian Linux
Redhat Linux
Ubuntu
Linux
$ ./arrays.sh
Antal element: 4
Debian Linux Redhat Linux Ubuntu Linux

9. Om-då-annars villkor
9.1. Enkel användning av "om-annars" villkor
Var uppmärksam på utrymmena inom hakparenteser, utan vilka villkoret inte fungerar.

#! / bin / bash
katalog = "./ BashScripting"
# kontrollera om katalogen finns
om [-d $ katalog]; sedan
eko "Katalog finns"
annan
eko "Katalog finns inte"
fi

Kod: Välj alla $ ./if_else.sh
Katalog finns inte
$ mkdir BashScripting
$ ./if_else.sh
Katalog finns

9.2 Inkapslade om-annars villkor

#! / bin / bash
# Förklara en variabel med värdet 4
val = 4
# Visar
eko "1. Bash "
eko "2. Skript "
eko "3. Handledning "

# Kör tills variabeln är fyra
# Looping
medan [$ choice -ekv 4]; do
# läs användarinmatning
läsval
# kapslad om-annars villkor
om [$ choice -ekv 1]; sedan
eko "Du har valt ord: Bash"
om [$ choice -ekv 2]; sedan
eko "Du har valt ord: Scripting"
annan
om [$ choice -ekv 3]; sedan
eko "Du har valt ord: Handledning"
annan
eko "Vänligen välj mellan 1-3!"
eko "1. Bash "
eko "2. Skript "
eko "3. Handledning "
echo -n “Välj ett ord? "
val = 4
fi
fi
fi
Gjort

Kod: Välj alla $ ./nested.sh
1. Bash
2. Skript
3. Handledning

5

1. Bash
2. Skript
3. Handledning
Vänligen välj ett ord?
4
Vänligen välj mellan 1-3!
1. Bash
2. Skript
3. Handledning
Vänligen välj ett ord?
3
Du har valt ord: Tutorial

Således körs först kroppen av "while" -slingan, eftersom variabelvalet är initialt lika med fyra. Sedan läser vi användarinmatningen i den, och om ingången inte är lika med 1,2 eller 3, gör vi vår variabel lika med 4 igen, i samband med vilken slingans kropp upprepas (igen är det nödvändigt att ange 1.2 eller 3).

10. Jämförelser
10.1 Aritmetiska jämförelser

Lt<
-gt>
-le<=
-ge> =
-eq ==
-ne! =

#! / bin / bash

NUM1 = 2
NUM2 = 2
om [$ NUM1 -ekv $ NUM2]; sedan
eko "Båda värdena är lika"
annan
eko "Värdena är INTE lika"
fi

Kod: Välj alla $ ./equals.sh
Båda värdena är lika

#! / bin / bash
# Förklara variabler med heltal
NUM1 = 2
NUM2 = 3
om [$ NUM1 -ekv $ NUM2]; sedan
eko "Båda värdena är lika"
annan
eko "Värdena är INTE lika"
fi

Kod: Välj alla $ ./equals.sh
Värdena är INTE lika

#! / bin / bash
# Förklara variabler med heltal
NUM1 = 2
NUM2 = 1
om [$ NUM1 -ekv $ NUM2]; sedan
eko "Båda värdena är lika"
elif [$ NUM1 -gt $ NUM2]; sedan
ekot "$ NUM1 är större än $ NUM2"
annan
ekot "$ NUM2 är större än $ NUM1"
fi

Kod: Välj alla $ ./equals.sh
2 är större än 1

10.2 Symboliska textjämförelser

Det samma
! = inte samma sak
< меньще чем
> mer än
-n s1 variabel s1 är inte tom
-z s1 variabel s1 är tom

#! / bin / bash

S1 = "Bash"

S2 = "Skript"
om [$ S1 = $ S2]; sedan

annan
eko "Strängar är INTE lika"
fi

Kod: Välj alla $ ./statement.sh
Strängar är INTE lika

#! / bin / bash
# Förklara den symboliska variabeln S1
S1 = "Bash"
# Förklara den symboliska variabeln S2
S2 = "Bash"
om [$ S1 = $ S2]; sedan
eko "Båda strängarna är lika"
annan
eko "Strängar är INTE lika"
fi

Kod: Välj alla $ ./statement.sh
Båda strängarna är lika

11. Kontrollera filer

B-filnamn Blockera specialfil
-c filnamn Specialteckenfil
-d katalognamn Kontrollera om katalogen finns
-e filnamn Kontrollera om filen finns
-f filnamn Kontrollera om det finns en vanlig fil inte en katalog
-G filnamn Kontrollera om filen finns och ägs av ett effektivt grupp-ID.
-g filnamn sant om filen finns och är set-group-id.
-k filnamn Sticky bit
-L filnamn Symbolisk länk
-O filnamn Sant om filen finns och ägs av det effektiva användar-id: t.
-r filnamn Kontrollera om filen är läsbar
-S filnamn Kontrollera om filen är uttagen
-s filnamn Kontrollera om filen inte är nollstor
-u filnamn Kontrollera om filset-ser-id-bit är inställd
-w filnamn Kontrollera om filen är skrivbar
-x filnamn Kontrollera om filen är körbar

#! / bin / bash
fil = "./ fil"
om [-e $ fil]; sedan
eko "Fil finns"
annan
eko "Filen finns inte"
fi

Kod: Välj alla $ ls
file.sh
$ ./fil.sh
Filen finns inte
$ touch-fil
$ ls
fil file.sh
$ ./fil.sh
fil existerar

På samma sätt för exemplet kan vi använda "while" -slingorna för att kontrollera om filen inte finns. Det här skriptet kommer att sova medan filen inte finns. Lägg märke till Bash-negatorn "!" vilket negerar (inverterar) alternativet -e.

12. Cykler
12.1. För loop

#! / bin / bash
# för loop
för f i $ (ls / var /); do
eko $ f
Gjort

Köra en for-loop från bash-kommandoraden:

Kod: Välj allt $ för f i $ (ls / var /); gör echo $ f; gjort kod: Välj allt $ för f i $ (ls / var /); gör echo $ f; Gjort
säkerhetskopior
cache
krascha
spel
lib
lokal
låsa
logga
post
välja
springa
spole
tmp
www

12.2. While loop

#! / bin / bash
RÄKNING = 6
# while loop
medan [$ COUNT -gt 0]; do

låt COUNT = COUNT-1
Gjort

Kod: Välj alla $ ./ While_loop.sh
Värdet på räkningen är: 6
Värdet på räkningen är: 5
Värdet på räkningen är: 4
Värdet på räkningen är: 3
Värde på räkningen är: 2
Värdet på räkningen är: 1

12.3. Fram till loop

#! / bin / bash
RÄKNING = 0
# tills loop
fram till [$ COUNT -gt 5]; do
ekovärde för räkningen är: $ COUNT
låt COUNT = COUNT + 1
Gjort

Kod: Välj alla $ ./until_loop.sh
Värdet på räkningen är: 0
Värdet på räkningen är: 1
Värde på räkningen är: 2
Värdet på räkningen är: 3
Värdet på räkningen är: 4
Värdet på räkningen är: 5

12.4. Slingor med implicita villkor
I följande exempel är villkoret för en stundslinga närvaron av standardingång.
Loopens kropp kommer att köras så länge det finns något som ska omdirigeras från standardutgång till läskommandot.

#! / bin / bash
# Detta skript söker efter och tar bort mellanslag
# i filer och ersätter dem med understrykningar
DIR = "."
Styr en slinga med ett läskommando genom att omdirigera utdata i en slinga.
hitta $ DIR -typ f | medan du läser filen; do
# använd POSIX-klassen [: space:] för att hitta mellanslag i filnamn
om [["$ file" = * [[: space:]] *]]; sedan
# ersätt mellanslag med understrykningar
mv "$ file" `echo $ file | tr '' '_' '
fi;
Gjort

Kod: Välj alla $ ls -1
script.sh
$ touch "fil med mellanslag"
$ ls -1
fil med mellanslag
script.sh
$ ./script.sh
$ ls -1
file_with_spaces
script.sh

13. Funktioner

#! / bin / bash
# Funktioner kan deklareras i valfri ordning
funktion funktion_B (
ekfunktion B.
}
funktion funktion_A (
eko $ 1
}
funktion funktion_D (
ekfunktion D.
}
funktion funktion_C (
eko $ 1
}
# Samtalsfunktioner
# pass parameter till funktion A
function_A "Funktion A."
funktion_B
# skicka parametern till funktionsfunktionen C
function_C "Funktion C."
funktion_D

Kod: Välj alla $ ./funktioner.sh
Funktion A.
Funktion B.
Funktion C.
Funktion D.

14. Val av operatör - Välj

#! / bin / bash
PS3 = 'Välj ett ord:'
# Välj
välj ord i "linux" "bash" "scripting" "tutorial"
do
eko "Det ord du valt är: $ word"
# Avbryt, annars blir slingan oändlig.
ha sönder
Gjort
avsluta 0

Kod: Välj alla $ ./select.sh
1) Linux
2) bash
3) skript
4) handledning
Välj ett ord: 4
Ordet du har valt är: tutorial

15. Val av operatör - Ärende

#! / bin / bash
eko "Vad är ditt föredragna programmerings- / skriptspråk"
eko "1) bash"
eko "2) perl"
eko "3) phyton"
eko "4) c ++"
eko "5) Jag vet inte!"
läs fallet;
# enkel struktur för val av fall
# notera att $ i detta exempel bara är en variabel
# och behöver inte kallas det. Detta är bara ett exempel
fall $ fall in
1) eko "Du valde bash" ;;
2) eko "Du valde perl" ;;
3) eko "Du valde phyton" ;;
4) eko "Du valde c ++" ;;
5) avsluta
esac

Kod: Välj alla $ ./case.sh
Vad är ditt föredragna programmerings- / skriptspråk
1) bash
2) perl
3) phyton
4) c ++
5) Jag vet inte!
4
Du valde c ++

———————————————————————————-

Mer information kan erhållas från olika källor, till exempel härifrån
original: https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin ... -book.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Kontrollerar ubuntu genom ett skript i Windows. Skapa ditt eget autokörningsskript vid datorstart

Hur bash-skript fungerar

Ställer in skriptfilbehörigheter

Visar meddelanden

Använda variabler

Miljövariabler

Användarvariabler

Kommandosubstitution

Matematiska operationer

Om-då-kontrollkonstruktion

Om-då-annars kontrollkonstruktion

Jämföra siffror

Strängjämförelse

Filkontroller

Resultat

Hur bash-skript fungerar

Ställer in skriptfilbehörigheter

Visar meddelanden

Använda variabler

Miljövariabler

Användarvariabler

Kommandosubstitution

Matematiska operationer

Om-då-kontrollkonstruktion

Om-då-annars kontrollkonstruktion

Jämföra siffror

Strängjämförelse

Filkontroller

Resultat

Återställning av lösenord