Dispozitiv de încărcare

Scriptul Linux creează și adaugă un utilizator. Executați un script când pornește sau se oprește Linux. Setarea permisiunilor pentru fișierele de script

10.09.2021

Scrierea de scripturi în Linux (învățare cu exemple)

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

1. Introducere

Ce ai nevoie pentru a scrie scripturi
Cunoașterea instrumentelor de linie de comandă și a opțiunilor necesare.
Cunostinte de baza în limba engleză nivelul de școală elementară nu va strica.

De ce sunt necesare scripturi?
În primul rând, administrarea unui server Linux într-o măsură sau alta se reduce la executarea sistematică a acelorași comenzi. Mai mult, nu este necesar ca aceste comenzi să fie efectuate de o persoană. Ele pot fi programate pentru a fi executate de o mașină.
În al doilea rând, chiar și doar efectuarea unei sarcini obișnuite, care (brut) se ridică la 20-1000... operații monotone este MULT mai ușor de implementat într-un script.

Ce este un scenariu
Un script este un set de instrucțiuni care trebuie să fie într-o anumită ordine si in anumit timp executa computerul. Instrucțiunile pot fi fie comenzi interne de shell (cicluri, condiții, procesarea informațiilor text, lucrul cu variabile de mediu etc.), precum și orice program pe care îl executăm în consolă cu parametrii necesari.

Cum se scrie un scenariu
În cazul nostru, scenariul va fi fisier text cu atribute de execuție. Dacă un fișier script începe cu secvența #!, care în lumea UNIX se numește sha-bang, atunci acesta spune sistemului ce interpret să folosească pentru a executa scriptul. Dacă acest lucru este greu de înțeles, atunci amintiți-vă că vom începe să scriem toate scripturile cu linia #!/bin/bash sau #!/bin/sh, iar apoi vor urma comenzile și comentariile pentru acestea.

Cuvinte de despărțire
Vă sfătuiesc sincer să scrieți cât mai multe comentarii pe aproape fiecare rând din scenariu. Timpul va trece și va trebui să schimbați sau să modernizați scenariul pe care l-ați scris cândva. Dacă nu vă amintiți sau nu înțelegeți ce este scris în scenariu, atunci devine dificil să îl schimbați, este mai ușor să scrieți de la zero.

De ce scripturi avem nevoie:

stabilirea regulilor de firewall la pornirea sistemului.

efectuarea de backup a setărilor și a datelor.

lansarea la o anumită oră (de preferință în fiecare noapte) a unui program care scanează jurnalele serverului proxy și produce un raport web convenabil asupra volumului de trafic descărcat.

trimițându-ne informații prin e-mail că cineva a accesat serverul nostru prin ssh, ora conexiunii și adresa clientului.

Despre metoda de scriere a scenariilor
Creăm un fișier text, îl edităm, setăm drepturi de execuție, îl rulăm, căutăm erori, îl corectăm, îl rulăm, căutăm erori...
Când totul este lustruit și funcționează corect, îl punem în autoload sau în planificator pentru un anumit timp.

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

2. Învățarea scrierii de scripturi în limbajul intern BASH
original: https://www.linuxconfig.org/Bash_scripting_Tutorial

Acest tutorial nu presupune cunoștințe anterioare despre cum să scrieți scripturi folosind limbajul intern Bash. Cu ajutorul acestui ghid, vei descoperi în curând că scrierea de scripturi este o sarcină foarte simplă. Să începem tutorialul nostru cu un script simplu care imprimă șirul „Hello World!” (tradus din engleză - Salut tuturor!)

1. Scenariul „Bună ziua tuturor”
Iată primul tău exemplu de script bash:

#!/bin/bash
ecou „Bună ziua, lume”

Să mergem la directorul care conține fișierul nostru hello_world.sh și să îl facem executabil:

Cod: Selectați toate $ chmod +x hello_world.sh

Rularea scriptului pentru execuție

Cod: Selectați toate $ ./hello_world.sh

2. Arhivarea simplă a scriptului bash

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

Cod: Selectați toate $ ./backup.sh

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

3. Lucrul cu variabile
ÎN în acest exemplu declarăm o variabilă simplă și o afișam pe ecran folosind comanda echo

#!/bin/bash
STRING=”HELLO WORLD!!!”
eco $STRING

Cod: Selectați toate $ ./hello_world.sh
SALUT LUME!!!

Scriptul nostru de arhivare cu variabile:

#!/bin/bash
OF=myhome_directory_$(data +%Y%m%d).tar.gz
IF=/acasă/utilizator
tar -czf $OF $IF

Cod: Selectați toate $ ./backup.sh
tar: Eliminarea „\” de început din numele membrilor
$ du -sh *tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Variabile globale și locale

#!/bin/bash
# Declarați o variabilă globală
# O astfel de variabilă poate fi folosită oriunde în acest script
VAR="variabilă globală"
funcția bash(
# Declarați o variabilă locală
# O astfel de variabilă este valabilă doar pentru funcția în care a fost declarată
local VAR="variabilă locală"
eco $VAR
}
eco $VAR
bash
# Rețineți că variabila globală nu s-a schimbat
eco $VAR

Cod: Selectați toate $ ./variables.sh
variabilă globală
variabilă locală
variabilă globală

4. Transmite argumente scriptului

#!/bin/bash
# Utilizați variabile predefinite pentru a accesa argumente
# Imprimați argumentele pe ecran
echo $1 $2 $3 ‘ -> echo $1 $2 $3’
#Putem accesa argumente și printr-o matrice specială args=("$@")
# Imprimați argumentele pe ecran
echo $(args) $(args) $(args) ‘ -> args=(“$@”); echo $(args) $(args) $(args)’
# Folosiți $@ pentru a imprima toate argumentele simultan
echo $@ ‘ -> echo $@’
Utilizați variabila $# pentru a afișa numărul de argumente transmise scriptului
echo Numărul de argumente transmise: $# ‘ -> echo Numărul de argumente transmise: $#’

Cod: Selectați toate $ ./arguments.sh Bash Scripting Tutorial
Bash Scripting Tutorial -> echo $1 $2 $3
Tutorial Bash Scripting -> args=("$@"); echo $(args) $(args) $(args)
Tutorial Bash Scripting -> echo $@
Numărul de argumente transmise: 3 -> echo Numărul de argumente transmise: $#

5. Executarea comenzilor shell într-un script

#!/bin/bash
# utilizați ghilimele inverse " ` ` " pentru a executa o comandă shell
ecou `uname -o`
# acum să încercăm fără ghilimele
echo uname -o

Cod: Selectați toate $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname -o

După cum puteți vedea, în al doilea caz a fost afișată comanda în sine, și nu rezultatul executării acesteia

6. Citirea intrărilor utilizatorului (interactivitate)

#!/bin/bash
echo -e "Bună, vă rugăm să introduceți cuvântul: \c "
citește cuvântul
echo „Cuvântul introdus este: $word”
echo -e „Poți, te rog, să introduci două cuvinte? »
citește cuvânt1 cuvânt2
echo "Aici este intrarea dvs.: \"$cuvânt1\" \"$cuvânt2\""
echo -e „Ce părere aveți despre scripting-ul bash? »
Comanda # read stochează acum un răspuns în variabila predefinită încorporată $REPLY
citit
echo „Ai spus $REPLY, mă bucur să aud asta! »
echo -e „Care sunt culorile tale preferate? »
# -a face ca comanda citire să citească într-o matrice
citeste -a culori
echo „Culorile mele preferate sunt și $(culori), $(culori) și $(culori):-)”

Cod: Selectați toate $ ./read.sh
Bună, te rog tastați cuvântul: ceva
Cuvântul pe care l-ai introdus este: ceva
Poti te rog sa introduci doua cuvinte?
Debian Linux
Iată intrarea dvs.: „Debian” „Linux”
Ce părere aveți despre scripting-ul bash?
bun
Ai spus bine, mă bucur să aud asta!
Care sunt culorile tale preferate?
albastru verde negru
Culorile mele preferate sunt si albastru, verde si negru :-)

7. Folosirea unei capcane

#!/bin/bash
# declara o capcană
capcană bashtrap INT
# șterge ecranul
clar;
# Funcția de cârlig este executată când utilizatorul apasă CTRL-C:
# Ecranul va afișa => Executarea subrutinei capcană bash!
# dar scriptul va continua să ruleze
bashtrap()
{
echo "CTRL+C detectat!... executând capcana bash!"
}
# scriptul va număra până la 10
pentru a în `seq 1 10`; do
echo „$a/10 la ieșire”.
somn 1;
Terminat
echo „Exemplu de ieșire din Bash Trap!!!”

Cod: Selectați toate $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL+C detectat !...executarea capcanei bash !
10/10
Exit Bash Trap Exemplu!!!

După cum puteți vedea, combinația de taste Ctrl-C nu a oprit execuția scriptului.

8. Matrice
8.1 Declararea unui tablou simplu

#!/bin/bash
# Declarați o matrice simplă cu 4 elemente
ARRAY=('Debian Linux' 'Redhat Linux' Ubuntu Linux)
# Obțineți numărul de elemente din matrice
ELEMENTS=$(#ARRAY[@])
# buclă prin fiecare element al matricei
pentru ((i=0;i<$ELEMENTS;i++)); do
echo $(ARRAY[$(i)])
Terminat

Cod: Selectați tot $./arrays.sh
Debian Linux
Redhat Linux
Ubuntu
Linux

8.2 Umplerea matricei cu valorile din fișier

#!/bin/bash
# Declarați o matrice
declara -a ARRAY
# comanda exec # stdin (de obicei tastatura) va fi derivat din acest fișier. Acest lucru face posibilă citirea
# conținutul fișierului, rând cu linie, și analizați fiecare linie introdusă folosind sed și/sau awk.
executiv 10 fie count=0
în timp ce citește LINE<&10; do
ARRAY[$count]=$LINE
((numărare++))
Terminat
echo Număr de elemente: $(#ARRAY[@])
# Imprimați valorile matricei
echo $(ARRAY[@])
# închide fișierul
exec 10>&-

Cod: Selectați tot $ cat bash.txt
Debian Linux
Redhat Linux
Ubuntu
Linux
$ ./arrays.sh
Numar de elemente: 4
Debian Linux Redhat Linux Ubuntu Linux

9. Condiții dacă-atunci-altfel
9.1. Utilizarea simplă a condițiilor „dacă altfel”.
Acordați atenție spațiilor dintre parantezele pătrate, fără de care condiția nu va funcționa.

#!/bin/bash
directory="./BashScripting"
# verificați prezența în director
if [ -d $director ]; apoi
echo „Directorul există”
altfel
echo „Directorul nu există”
fi

Cod: Selectați toate $ ./if_else.sh
Directorul nu există
$ mkdir BashScripting
$ ./if_else.sh
Directorul există

9.2 Condiții imbricate dacă-altfel

#!/bin/bash
# Declarați o variabilă cu valoarea 4
alegere=4
# Afișare
ecou „1. Bash"
ecou „2. Scripting"
ecou „3. Tutorial"

# Executați în timp ce variabila este egală cu patru
# Buclă
în timp ce [ $alegerea -eq 4 ]; do
# citește intrarea utilizatorului
alegerea citirii
# condiție imbricată if-else
if [ $alegere -eq 1 ] ; apoi
echo „Ați ales cuvântul: Bash”
if [ $alegere -eq 2 ] ; apoi
echo „Ați ales cuvântul: Scripting”
altfel
if [ $alegere -eq 3 ] ; apoi
echo „Ați ales cuvântul: Tutorial”
altfel
echo "Vă rugăm să alegeți între 1-3!"
ecou „1. Bash"
ecou „2. Scripting"
ecou „3. Tutorial"
echo -n „Vă rugăm să alegeți un cuvânt? »
alegere=4
fi
fi
fi
Terminat

Cod: Selectați toate $ ./nested.sh
1. Lovitură
2. Scriptare
3. Tutorial

5

1. Lovitură
2. Scriptare
3. Tutorial
Vă rog să alegeți un cuvânt?
4
Vă rugăm să alegeți între 1-3!
1. Lovitură
2. Scriptare
3. Tutorial
Vă rog să alegeți un cuvânt?
3
Ai ales cuvântul: Tutorial

Astfel, corpul buclei „while” este executat primul, deoarece variabila de alegere este iniţial egală cu patru. Apoi citim intrarea utilizatorului în ea și, dacă intrarea nu este egală cu 1,2 sau 3, atunci facem din nou variabila noastră egală cu 4 și, prin urmare, corpul buclei se repetă (trebuie să introduceți 1,2 sau 3 din nou).

10. Comparații
10.1 Comparații aritmetice

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

#!/bin/bash

NUM1=2
NUM2=2
if [ $NUM1 -eq $NUM2 ]; apoi
echo „Ambele valori sunt egale”
altfel
echo „Valorile NU sunt egale”
fi

Cod: Selectați toate $ ./equals.sh
Ambele valori sunt egale

#!/bin/bash
# Declarați variabile cu valori întregi
NUM1=2
NUM2=3
if [ $NUM1 -eq $NUM2 ]; apoi
echo „Ambele valori sunt egale”
altfel
echo „Valorile NU sunt egale”
fi

Cod: Selectați toate $ ./equals.sh
Valorile NU sunt egale

#!/bin/bash
# Declarați variabile cu valori întregi
NUM1=2
NUM2=1
if [ $NUM1 -eq $NUM2 ]; apoi
echo „Ambele valori sunt egale”
elif [ $NUM1 -gt $NUM2 ]; apoi
echo „$NUM1 este mai mare decât $NUM2”
altfel
echo „$NUM2 este mai mare decât $NUM1”
fi

Cod: Selectați toate $ ./equals.sh
2 este mai mare decât 1

10.2 Comparații caracter-text

Aceeași
!= nu la fel
< меньще чем
> mai mult decât
-n s1 variabila s1 nu este goală
-z s1 variabila s1 este goală

#!/bin/bash

S1="Bash"

S2="Scriptare"
dacă [ $S1 = $S2 ]; apoi

altfel
echo „Șirurile NU sunt egale”
fi

Cod: Selectați toate $ ./statement.sh
Șirurile NU sunt egale

#!/bin/bash
# Declarați variabila caracter S1
S1="Bash"
# Declarați variabila caracter S2
S2="Bash"
dacă [ $S1 = $S2 ]; apoi
echo „Ambele șiruri sunt egale”
altfel
echo „Șirurile NU sunt egale”
fi

Cod: Selectați toate $ ./statement.sh
Ambele șiruri sunt egale

11. Verificarea fișierelor

B nume de fișier Blocați fișierul special
-c nume de fișier Fișier cu caractere speciale
-d directoryname Verificați existența directorului
-e nume de fișier Verificați existența fișierului
-f nume de fișier Verificați existența unui fișier obișnuit, nu un director
-G nume de fișier Verificați dacă fișierul există și este deținut de ID-ul efectiv al grupului.
-g nume de fișier adevărat dacă fișierul există și este set-group-id.
-k nume de fișier Sticky bit
-L nume de fișier Legătură simbolică
-O nume de fișier Adevărat dacă fișierul există și este deținut de id-ul de utilizator efectiv.
-r nume de fișier Verificați dacă fișierul este lizibil
-S nume de fișier Verificați dacă fișierul este socket
-s nume de fișier Verificați dacă fișierul are dimensiunea diferită de zero
-u filename Verificați dacă fișierul set-ser-id bit este setat
-w nume de fișier Verificați dacă fișierul poate fi scris
-x nume de fișier Verificați dacă fișierul este executabil

#!/bin/bash
file="./file"
if [ -e $fișier ]; apoi
echo „Fișierul există”
altfel
echo „Fișierul nu există”
fi

Cod: Selectați toate $ ls
fişier.sh
$./fișier.sh
Fisierul nu exista
$ fișier tactil
$ls
fișier file.sh
$./fișier.sh
fisierul exista

În mod similar, de exemplu, putem folosi buclele „while” pentru a verifica dacă fișierul nu există. Acest script va dormi până când fișierul există. Rețineți negatorul Bash "!" care anulează (inversează) opțiunea -e.

12. Cicluri
12.1. Pentru buclă

#!/bin/bash
# pentru buclă
pentru f în $(ls /var/); do
ecou $f
Terminat

Rularea unei bucle for din linia de comandă bash:

Cod: Selectați toți $ pentru f în $(ls /var/); do echo $f; done Code: Selectați toți $ pentru f în $(ls /var/); do echo $f; Terminat
copii de rezervă
cache
prăbușire
jocuri
lib
local
Lacăt
Buturuga
Poștă
opta
alerga
bobina
tmp
www

12.2. buclă în timp ce

#!/bin/bash
COUNT=6
# buclă while
în timp ce [ $COUNT -gt 0 ]; do

fie COUNT=COUNT-1
Terminat

Cod: Selectați tot $ ./while_loop.sh
Valoarea numărului este: 6
Valoarea numărului este: 5
Valoarea numărului este: 4
Valoarea numărului este: 3
Valoarea numărului este: 2
Valoarea numărului este: 1

12.3. Până la buclă

#!/bin/bash
COUNT=0
# până la buclă
până la [ $COUNT -gt 5 ]; do
echo Valoarea numărului este: $COUNT
fie COUNT=COUNT+1
Terminat

Cod: Selectați toate $ ./until_loop.sh
Valoarea numărului este: 0
Valoarea numărului este: 1
Valoarea numărului este: 2
Valoarea numărului este: 3
Valoarea numărului este: 4
Valoarea numărului este: 5

12.4. Bucle cu condiții implicite
În exemplul următor, condiția buclei while este prezența intrării standard.
Corpul buclei va fi executat atâta timp cât există ceva de redirecționat de la ieșirea standard la comanda de citire.

#!/bin/bash
# Acest script va căuta și va elimina spații
# în fișiere, înlocuindu-le cu liniuțe de subliniere
DIR="
Controlarea unei bucle cu comanda citire prin redirecționarea ieșirii în buclă.
găsiți $DIR -tip f | în timp ce se citește fișierul; do
# utilizați clasa POSIX [:space:] pentru a găsi spații în numele fișierelor
dacă [[ "$fișier" = *[[:spațiu:]]* ]]; apoi
# înlocuiți spațiile cu caractere de subliniere
mv „$fișier” `echo $fișier | tr ‘ ‘ ‘_’’
fi;
Terminat

Cod: Selectați toate $ ls -1
script.sh
$ atingeți „fișier cu spații”
$ls -1
fișier cu spații
script.sh
$ ./script.sh
$ls -1
fișier_cu_spații
script.sh

13. Funcții

#!/bin/bash
# Funcțiile pot fi declarate în orice ordine
functia function_B(
Funcția echo B.
}
functia function_A (
eco $1
}
functia function_D(
Funcția echo D.
}
functia function_C(
eco $1
}
# Funcții de apel
# treceți parametrul la funcția A
function_A "Funcția A."
funcția_B
# treceți parametrul la funcția C
function_C "Funcția C."
funcția_D

Cod: Selectați toate $ ./functions.sh
Funcția A.
Funcția B.
Funcția C.
Funcția D.

14. Operator de selecție - Selectați

#!/bin/bash
PS3=’Alegeți un cuvânt: ‘
#Selectați
selectați cuvântul în „linux” „bash” „scripting” „tutorial”
do
echo „Cuvântul pe care l-ați selectat este: $cuvânt”
# Anulați, altfel bucla va fi nesfârșită.
pauză
Terminat
iesirea 0

Cod: Selectați toate $ ./select.sh
1) Linux
2) lovitura
3) scripting
4) tutorial
Alegeți un cuvânt: 4
Cuvântul pe care l-ați selectat este: tutorial

15. Operator de selecție - Caz

#!/bin/bash
echo „Care este limbajul de programare/scriptare preferat”
ecou "1) bash"
ecou "2)perl"
ecou "3) fiton"
ecou „4) c++”
ecou „5) Nu știu!”
citire caz;
# structură simplă de selecție a cazurilor
# rețineți că în acest exemplu $case este doar o variabilă
# și nu trebuie să fie numit așa. Acesta este doar un exemplu
caz $case in
1) ecou „Ați selectat bash”;;
2) ecou „Ați selectat perl”;;
3) ecou „Ați selectat phyton”;;
4) echo „Ați selectat c++”;;
5) ieșire
esac

Cod: Selectați toate $ ./case.sh
Care este limbajul dvs. de programare/scripting preferat
1) lovitura
2) perl
3) fiton
4) c++
5) Nu stiu!
4
Ai selectat c++

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

Informații mai detaliate pot fi obținute din diverse surse, de exemplu aici
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

Un script shell este o secvență de comenzi pe care o puteți folosi în mod repetat. Executarea acestei secvențe se realizează de obicei prin introducere Linie de comanda numele scriptului. În plus, cu cron puteți folosi scripturi pentru a automatiza sarcinile. O altă utilizare a scripturilor este procedura de pornire și oprire a unui sistem UNIX, când operațiunile cu demoni și servicii sunt definite în scripturile de inițializare.

Pentru a crea un script shell, deschideți un fișier nou, gol în editor. Puteți folosi orice editor de text pentru aceasta: vim, emacs, gedit, dtpad etc.; Orice va face. Cu toate acestea, puteți alege un editor mai avansat, cum ar fi vim sau emacs, deoarece astfel de editori pot fi configurați să recunoască sintaxa shell și Bash și pot fi de un bun ajutor în evitarea greșelilor pe care le fac adesea începătorii, cum ar fi uitarea de a închide parantezele și utilizarea punctului și virgulă.

Tastați comenzi UNIX într-un fișier nou, gol, așa cum ați face la linia de comandă. După cum sa discutat în capitolul anterior (vezi secțiunea „Rularea unei comenzi”), comenzile pot fi funcții shell, comenzi încorporate, comenzi UNIX sau alte scripturi.

Dați scriptului un nume mnemonic care spune ce face scriptul. Asigurați-vă că numele dvs. de script nu intră în conflict cu comenzile existente. Pentru a evita orice confuzie, numele scripturilor se termină adesea cu extensia .sh. Cu toate acestea, pot exista și alte scripturi cu același nume pe care l-ați ales pe sistemul dvs. Utilizarea comenzilor care, unde esteși altele, căutați informații despre programele și fișierele existente cu acest nume:

Care -a script_name unde este script_name localizează script_name ( aproximativ : înlocuiți script_name cu numele scriptului dvs).

Script script1.sh

În acest exemplu folosim comanda ecou, încorporat în Bash, care va informa utilizatorul ce trebuie făcut înainte ca rezultatul să fie dat. Este foarte recomandat ca utilizatorii să fie informați despre ceea ce face scriptul, astfel încât utilizatorii nu erau nervoși dacă li se părea că scenariul nu face nimic. Vom reveni la subiectul notificării utilizatorilor în Capitolul 8, „Scrierea unui script interactiv”.

Fig.2.1. Script script1.sh

Scrieți același scenariu pentru dvs. O idee bună ar fi să creați un director ~/scripts unde vor fi localizate scripturile dvs. Adăugați acest director la conținutul variabilei PATH:

Export PATH="$PATH:~/scripts"

Dacă abia ați început să utilizați Bash, utilizați un editor de text care folosește culori diferite pentru diferite constructe shell. Evidențierea sintaxelor este acceptată în vim, gvim, (x)emacs, kwriteși mulți alți editori, consultați documentația pentru editorul dvs. preferat.

Executarea scenariului

Pentru ca un script să fie rulat, acesta trebuie să aibă permisiuni de rulare pentru utilizatorii corespunzători. După ce ați setat permisiunile, verificați dacă ați setat de fapt permisiunile de care aveți nevoie. Odată ce acest lucru este făcut, scriptul poate fi rulat la fel ca orice altă comandă:

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 Scenariul începe acum. salut willy! Vă voi aduce acum o listă de utilizatori conectați: 15:38 până la 18 zile, 5:37, 4 utilizatori, medie de încărcare: 0,12, 0,22, 0,15 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT root tty2 - Sat 2pm 4:25m 0.24s 0.05s -bash willy:0 - Sâmbătă 14:00? 0.00s? - willy pts/3 - Sâmbătă 2pm 3:33m 36.39s 36.39s BitchX willy ir willy pts/2 - Sat 2pm 3:33m 0.13s 0.06s /usr/bin/screen Am setat două variabile acum. Acesta este un șir : negru Și acesta este un număr: 9 Vă dau înapoi solicitarea acum. willy:~/scripts> echo $COLOUR willy:~/scripts> echo $VALUE willy:~/scripts>

Acesta este cel mai comun mod de a executa un script. Este de preferat să rulați scripturi ca acesta într-un subshell. Variabilele, funcțiile și aliasurile create în acest subshell sunt cunoscute numai în acea sesiune bash specifică din acel subshell. Când acest shell este ieșit și shell-ul părinte preia controlul, toate setările sunt șterse și orice modificări care au fost făcute de script în starea acelui shell vor fi uitate.

Dacă nu ați specificat scripturile sau . (directorul curent), puteți activa scriptul astfel:

./script_name.sh

De asemenea, este posibil să rulați un script în interiorul unui shell existent, dar acest lucru se face de obicei numai dacă doriți caracteristici speciale, cum ar fi dacă doriți să testați dacă un script funcționează cu un alt shell sau să produceți o urmă în scopuri de depanare ( aproximativ- în loc de script_name, specificați numele scriptului dvs.):

Rbash nume_script.sh sh nume_script.sh bash -x nume_script.sh

Shell-ul de comandă specificat va fi lansat ca un subshell al shell-ului dvs. curent și va executa scriptul. Acest lucru se face atunci când doriți ca scriptul să fie rulat cu parametri specifici sau în anumite condiții care nu sunt specificate în scriptul în sine.

Dacă nu doriți să porniți un nou shell, dar doriți să rulați scriptul în shell-ul curent, utilizați comanda sursă:

Sursă script_name.sh

În acest caz, scriptul nu are nevoie de drepturi de execuție. Comenzile sunt executate în contextul shell-ului curent, astfel încât orice modificări aduse mediului dumneavoastră vor rămâne vizibile când scriptul se termină de executat:

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

Creați un fișier gol.

Prima linie scriem:

#!/bin/sh

Această linie specifică ce shell de comandă să folosească. Urmează echipele tale.

Să-l salvăm sub numele original (pentru a nu coincide cu cele existente) în directorul /usr/sbin/.

Pentru ca scriptul să ruleze la pornire, trebuie să îl înregistrați în fișierul /etc/rc.local până la ieșirea de linie 0. Dacă nu aveți acest fișier, creați-l și inserați următorul conținut în el:

#!/bin/sh -e #Aici inserăm o linie care indică scriptul tău. /usr/sbin/mescripts ieșire 0

Un mod puțin mai complicat

Vă permite să setați secvența de încărcare și comportamentul scriptului la diferite niveluri de execuție.

Studiem /etc/init.d/skeleton, pe baza lui creăm un script /etc/init.d/my_script care va porni/opri aplicația noastră.

Aceste directoare conțin scripturi pentru oprirea serviciilor:

/etc/rc0.d/ /etc/rc1.d/ /etc/rc6.d/

Acestea sunt scripturile de lansare a serviciului:

/etc/rc2.d/ /etc/rc3.d/ /etc/rc4.d/ /etc/rc5.d/

Le studiem pentru consecvență (cu cât prima cifră este mai mică la începutul scriptului, cu atât aplicația pornește/se oprește mai devreme). Acest lucru poate fi critic dacă aplicația dvs. depinde de unele servicii.

După ce ne-am hotărât asupra scriptului și secvenței de lansare, efectuăm următoarele:

Sudo update-rc.d my_script start 70 2 3 4 5 . oprire 20 0 1 6 .

Aici am stabilit că scenariul meu ar trebui să înceapă mai târziu decât celelalte (70) și să se oprească mai devreme (20). Numerele 2 3 4 5 0 1 6 indică nivelurile de încărcare.

Dacă nu vă place ceva, puteți șterge totul

Sudo update-rc.d -f my_script remove

Consultați man update-rc.d pentru detalii.

Executarea unui script când rețeaua este pornită/oprită

Există un director /etc/network/ cu subdirectoare if-down.d , if-pre-up.d , if-post-down.d , if-up.d . Dacă plasați scriptul într-unul din aceste subdirectoare, acesta va fi executat respectiv la oprire, înainte de pornire, după oprire sau la pornirea rețelei.

O altă modalitate este de a specifica una dintre următoarele directive în fișierul /etc/network/interfaces: up , pre-up , post-up , down , pre-down , post-down . De exemplu, linia

Post-up /path/to/script.sh

după pornirea rețelei va executa scriptul script.sh. Puteți citi mai multe în interfețele man.

În orice caz, scriptul trebuie să aibă drepturi de execuție setate, altfel nu va putea rula.

Astăzi vom vorbi despre scripturile bash. Acestea sunt scripturi de linie de comandă scrise pentru bash shell. Există și alte shell-uri, de exemplu - zsh, tcsh, ksh, dar ne vom concentra pe bash. Acest material este destinat tuturor, singura condiție este capacitatea de a lucra pe linia de comandă Linux.

Scripturile din linia de comandă sunt colecții ale acelorași comenzi care pot fi introduse de la tastatură, colectate în fișiere și unite printr-un scop comun. În acest caz, rezultatele muncii echipelor pot fi fie de valoare independentă, fie pot servi drept date de intrare pentru alte echipe. Scripturile sunt o modalitate puternică de a automatiza acțiunile efectuate frecvent.

Deci, dacă vorbim despre linia de comandă, vă permite să executați mai multe comenzi deodată introducându-le separate prin punct și virgulă:

Pwd; cine sunt
De fapt, dacă ați încercat acest lucru în terminalul dvs., primul dvs. script bash care implică două comenzi a fost deja scris. Funcționează așa. Mai întâi, comanda pwd afișează informații despre directorul de lucru curent, apoi comanda whoami afișează informații despre utilizatorul sub care sunteți conectat.

Folosind această abordare, puteți combina câte comenzi doriți pe o singură linie, singura limită este numărul maxim de argumente care pot fi transmise programului. Puteți defini această limită folosind următoarea comandă:

Getconf ARG_MAX
Linia de comandă este un instrument grozav, dar trebuie să introduceți comenzi în ea de fiecare dată când aveți nevoie de ele. Ce se întâmplă dacă am scrie un set de comenzi într-un fișier și pur și simplu am numi acel fișier pentru a le executa? De fapt, fișierul despre care vorbim se numește script de linie de comandă.

Cum funcționează scripturile bash

Creați un fișier gol folosind comanda tactilă. Prima linie trebuie să indice ce shell vom folosi. Suntem interesați de bash , așa că prima linie a fișierului va fi astfel:

#!/bin/bash
Alte linii din acest fișier folosesc simbolul hash pentru a indica comentariile pe care shell-ul nu le procesează. Cu toate acestea, prima linie este un caz special, în care un hash urmat de un semn de exclamare (această secvență se numește shebang) și o cale către bash indică sistemului că scriptul a fost creat special pentru bash.

Comenzile Shell sunt separate printr-un avans de linie, comentariile sunt separate printr-un semn hash. Cam asa arata:

#!/bin/bash # Acesta este un comentariu pwd whoami
Aici, la fel ca pe linia de comandă, puteți scrie comenzi pe o singură linie, separate prin punct și virgulă. Cu toate acestea, dacă scrieți comenzile pe linii diferite, fișierul este mai ușor de citit. În orice caz, shell-ul le va procesa.

Setarea permisiunilor pentru fișierele de script

Salvați fișierul și denumiți-l myscript și aproape ați terminat de creat scriptul bash. Acum, tot ce rămâne este să faceți acest fișier executabil, altfel, dacă încercați să-l executați, veți întâlni o eroare Permisiune refuzată.

Încercarea de a rula un fișier script cu permisiuni configurate incorect

Să facem fișierul executabil:

Chmod +x ./myscript
Acum să încercăm să-l executăm:

./scriptul meu
După setarea permisiunilor, totul funcționează așa cum ar trebui.

Rulează cu succes scriptul bash

Ieșire mesaj

Pentru a afișa text în Consola Linux Este folosită comanda echo. Să folosim cunoștințele despre acest fapt și să ne edităm scriptul, adăugând explicații la datele care sunt transmise de comenzile deja în el:

#!/bin/bash # comentariul nostru este aici echo „Directorul curent este:” pwd echo „Utilizatorul conectat este:” whoami
Acesta este ceea ce se întâmplă după rularea scriptului actualizat.

Ieșirea mesajelor dintr-un script

Acum putem afișa note explicative folosind comanda echo. Dacă nu știți cum să editați un fișier utilizând instrumentele Linux sau nu ați mai întâlnit comanda echo înainte, aruncați o privire la această resursă.

Utilizarea variabilelor

Variabilele vă permit să stocați informații într-un fișier script, cum ar fi rezultatele comenzilor, pentru a fi utilizate de alte comenzi.

Nu este nimic în neregulă cu executarea comenzilor individuale fără a stoca rezultatele acestora, dar această abordare este destul de limitată în capacitățile sale.

Există două tipuri de variabile care pot fi utilizate în scripturile bash:

variabile de mediu
Variabile utilizator

variabile de mediu

Uneori, comenzile shell trebuie să funcționeze cu unele date de sistem. Iată un exemplu despre cum să afișați directorul principal al utilizatorului curent:

#!/bin/bash # display user home echo „Acasă pentru utilizatorul curent este: $HOME”
Vă rugăm să rețineți că putem folosi variabila de sistem $HOME între ghilimele duble, acest lucru nu va împiedica sistemul să o recunoască. Aceasta este ceea ce obțineți dacă rulați scenariul de mai sus.

Utilizarea unei variabile de mediu într-un script

Ce se întâmplă dacă trebuie să afișați un semn dolar pe ecran? Să încercăm asta:

Echo „Am 1 dolar în buzunar”
Sistemul va detecta un semn dolar într-un șir ghilimeleu și va presupune că am făcut referire la o variabilă. Scriptul va încerca să afișeze valoarea variabilei nedefinite $1. Nu de asta avem nevoie. Ce să fac?

ÎN situație similară Folosind caracterul de evacuare, o bară oblică inversă, înainte de semnul dolarului va ajuta:

Echo „Am \$1 în buzunar”
Scriptul va afișa acum exact ceea ce este așteptat.

Folosind o secvență de escape pentru a tipări un semn dolar

Variabile utilizator

Pe lângă variabilele de mediu, scripturile bash vă permit să definiți și să utilizați propriile variabile în script. Astfel de variabile păstrează o valoare până când script-ul finalizează execuția.

Ca și în cazul variabilelor de sistem, variabilele utilizator pot fi accesate folosind semnul dolar:
TNW-CUS-FMP - cod promoțional pentru o reducere de 10% la serviciile noastre, disponibil pentru activare în 7 zile
#!/bin/bash # testing variables grade=5 person="Adam" echo "$persoana este un băiat bun, este în clasa $grade"
Iată ce se întâmplă după rularea unui astfel de script.

Variabile personalizate într-un script

Înlocuirea comenzii

Una dintre cele mai utile caracteristici ale scripturilor bash este capacitatea de a extrage informații din ieșirea comenzii și de a le atribui variabilelor, permițând ca aceste informații să fie utilizate oriunde în fișierul script.

Există două moduri de a face acest lucru.

Folosind backtick „`”
Folosind constructul $().

Când utilizați prima abordare, aveți grijă să nu includeți un singur ghilimele în locul ticului înapoi. Comanda trebuie să fie inclusă în două astfel de pictograme:

Mydir=`pwd`
În a doua abordare, același lucru este scris astfel:

Mydir=$(pwd)
Și scenariul ar putea ajunge să arate așa:

#!/bin/bash mydir=$(pwd) echo $mydir
În timpul funcționării sale, ieșirea comenzii pwd va fi stocată în variabila mydir, al cărei conținut, folosind comanda echo, va fi trimis către consolă.

Un script care salvează rezultatele unei comenzi într-o variabilă

Operatii matematice

Pentru a efectua operații matematice într-un fișier script, puteți utiliza o construcție ca $((a+b)):

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

Operații matematice într-un script

constructul de control dacă-atunci

În unele scenarii, trebuie să controlați fluxul de execuție a comenzii. De exemplu, dacă o anumită valoare este mai mare de cinci, trebuie să efectuați o acțiune, în caz contrar, alta. Acest lucru este aplicabil în multe situații, iar aici managerul ne va ajuta dacă-atunci construi. În cele mai multe în formă simplă arata cam asa:

If comandă atunci fi comandă
Iată un exemplu de lucru:

#!/bin/bash dacă pwd apoi ecou „Funcționează” fi
În acest caz, dacă comanda pwd se finalizează cu succes, textul „funcționează” va fi tipărit pe consolă.

Să folosim cunoștințele pe care le avem și să scriem un scenariu mai complex. Să presupunem că trebuie să găsim un anumit utilizator în /etc/passwd și, dacă am reușit să-l găsim, raportăm că el există.

#!/bin/bash user=likegeeks if grep $user /etc/passwd apoi echo „Utilizatorul $user există” fi
Acesta este ceea ce se întâmplă după rularea acestui script.

Căutați un utilizator

Aici am folosit comanda grep pentru a căuta utilizatorul în fișierul /etc/passwd. Dacă comanda grep nu vă este familiară, puteți găsi descrierea acesteia.

În acest exemplu, dacă utilizatorul este găsit, scriptul va afișa un mesaj corespunzător. Ce se întâmplă dacă utilizatorul nu ar putea fi găsit? În acest caz, scriptul va finaliza pur și simplu execuția fără a ne spune nimic. Ne-ar plăcea să ne spună și el despre asta, așa că vom îmbunătăți codul.

constructul de control dacă-atunci-altfel

Pentru ca programul să poată raporta atât rezultatele unei căutări reușite, cât și ale eșecului, vom folosi constructul if-then-else. Iată cum funcționează:

If command then commands else comenzi fi
Dacă prima comandă returnează zero, ceea ce înseamnă că a fost executată cu succes, condiția va fi adevărată și execuția nu va continua de-a lungul ramurii else. În caz contrar, dacă se returnează altceva decât zero, ceea ce ar indica un eșec sau un rezultat fals, comenzile după else vor fi executate.

Să scriem următorul script:

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "Utilizatorul $user Exists" else echo "Utilizatorul $user nu există" fi
Execuția sa a mers de-a lungul ramurii celorlalte.

Rularea unui script cu un construct if-then-else

Ei bine, să trecem mai departe și să ne întrebăm despre condiții mai complexe. Ce se întâmplă dacă trebuie să verificați nu o singură condiție, ci mai multe? De exemplu, dacă utilizatorul dorit găsit, trebuie să afișați un mesaj, dacă este îndeplinită o altă condiție - un alt mesaj și așa mai departe. Într-o astfel de situație, condițiile imbricate ne vor ajuta. Arata cam asa:

Dacă comandă1, atunci comandă elif comandă2, atunci comandă fi
Dacă prima comandă returnează zero, indicând succesul, comenzile din primul apoi bloc vor fi executate, în caz contrar, dacă prima condiție este falsă, iar dacă a doua comandă returnează zero, al doilea bloc de cod va fi executat.

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "Utilizatorul $user Exists" elif ls /home then echo "Utilizatorul nu există, dar oricum există un director sub /home" fi
Într-un astfel de script, puteți, de exemplu, să creați un utilizator nou utilizând comanda useradd dacă căutarea nu produce rezultate sau să faceți altceva util.

Comparația numerelor

În scripturi puteți compara valori numerice. Mai jos este o listă de comenzi relevante.

n1 -eq n2 Returnează adevărat dacă n1 este egal cu n2 .
n1 -ge n2 Returnează adevărat dacă n1 este mai mare sau egal cu n2 .
n1 -gt n2 Returnează adevărat dacă n1 este mai mare decât n2 .
n1 -le n2 Returnează adevărat dacă n1 este mai mic sau egal cu n2.
n1 -lt n2 Returnează adevărat dacă n1 este mai mic decât n2 .
n1 -ne n2 Returnează adevărat dacă n1 nu este egal cu n2 .

De exemplu, să încercăm unul dintre operatorii de comparație. Rețineți că expresia este cuprinsă între paranteze drepte.

#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "Valoarea de test $val1 este mai mare de 5" else echo "Valoarea de test $val1 nu este mai mare de 5" fi
Aceasta este ceea ce va scoate această comandă.

Compararea numerelor din scripturi

Valoarea variabilei val1 este mai mare decât 5, drept urmare ramura de atunci a operatorului de comparație este executată și un mesaj corespunzător este afișat în consolă.

Comparație de șiruri

Scripturile pot compara, de asemenea, valorile șirurilor. Operatorii de comparare par destul de simpli, dar operațiile de comparare a șirurilor au anumite caracteristici, pe care le vom atinge mai jos. Iată o listă de operatori.

str1 = str2 Testează șirurile de caractere pentru egalitate, returnând adevărat dacă șirurile sunt identice.
s tr1 != str2 Returnează adevărat dacă șirurile nu sunt identice.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 Returnează adevărat dacă str1 este mai mare decât str2.
-n str1 Returnează adevărat dacă lungimea lui str1 este mai mare decât zero.
-z str1 Returnează adevărat dacă lungimea lui str1 este zero.

Iată un exemplu de comparare a șirurilor într-un script:

#!/bin/bash user ="likegeeks" if [$user = $USER] atunci echo "Utilizatorul $user este utilizatorul conectat curent" fi
Ca rezultat al executării scriptului, obținem următoarele.

Compararea șirurilor în scripturi

Iată o caracteristică a comparației șirurilor care merită menționată. Și anume, operatorii „>” și „<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>» ca o comandă de redirecționare a ieșirii.

Iată cum arată lucrul cu acești operatori în cod:

#!/bin/bash val1=text val2="alt text" dacă [ $val1 \>
Iată rezultatele scenariului.

Comparație de șiruri, avertisment dat

Vă rugăm să rețineți că scriptul, deși este executat, emite un avertisment:

./myscript: linia 5: [: prea multe argumente
Pentru a scăpa de acest avertisment, includem $val2 între ghilimele duble:

#!/bin/bash val1=text val2="alt text" dacă [ $val1 \> "$val2" ] atunci echo "$val1 este mai mare decât $val2" altfel echo "$val1 este mai mic decât $val2" fi
Acum totul funcționează așa cum ar trebui.

Comparație de șiruri

O altă caracteristică a operatorilor „>” și „<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Likegeeks like geeks
Să-l salvăm, dându-i numele fișierul meu și apoi să rulăm următoarea comandă în terminal:

Sortați fișierul meu
Acesta va sorta liniile din fișier astfel:

Likegeeks Likegeeks
Comanda sortare, în mod implicit, sortează șirurile în ordine crescătoare, adică litera minusculă din exemplul nostru este mai mică decât cea mare. Acum să pregătim un script care va compara aceleași șiruri de caractere:

#!/bin/bash val1=Likegeeks val2=likegeeks dacă [ $val1 \> $val2 ] atunci echo "$val1 este mai mare decât $val2" altfel echo "$val1 este mai mic decât $val2" fi
Dacă îl rulați, se dovedește că totul este invers - litera mică este acum mai mare decât cea mare.

Comanda sortare și compararea șirurilor într-un fișier script

În comenzile de comparație, literele mari sunt mai mici decât literele mici. Compararea șirurilor aici se face prin compararea codurilor ASCII ale caracterelor, ordinea de sortare depinde astfel de codurile caracterelor.

Comanda de sortare, la rândul său, utilizează ordinea de sortare specificată în setările limbii sistemului.

Verificări ale fișierelor

Poate că următoarele comenzi sunt folosite cel mai des în scripturile bash. Acestea vă permit să verificați diferite condiții privind fișierele. Iată o listă cu aceste comenzi.

-d fișier Verifică dacă fișierul există și este un director.
-e fișier Verifică dacă fișierul există.
-f fișier Verifică dacă fișierul există și este un fișier.
-r fișier Verifică dacă fișierul există și este lizibil.
-s fișier Verifică dacă fișierul există și nu este gol.
-w fișier Verifică dacă fișierul există și poate fi scris.
-x file Verifică dacă fișierul există și este executabil.
fișier1 -nt fișier2 Verifică dacă fișierul1 este mai nou decât fișierul2.
fișier1 -ot fișier2 Verifică dacă fișierul1 este mai vechi decât fișierul2.
-O fișier Verifică dacă fișierul există și este deținut de utilizatorul curent.
-G file Verifică dacă un fișier există și dacă ID-ul său de grup se potrivește cu ID-ul de grup al utilizatorului curent.

Aceste comenzi, precum și multe altele discutate astăzi, sunt ușor de reținut. Numele lor, fiind abrevieri ale diverselor cuvinte, indică direct verificările pe care le efectuează.

Să încercăm una dintre comenzile în practică:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "Directorul $mydir există" cd $ mydir ls else echo "Directorul $mydir nu există" fi
Acest script, pentru un director existent, își va afișa conținutul.

Listarea conținutului unui director

Credem că puteți experimenta singur cu comenzile rămase, toate sunt folosite după același principiu.

Rezultate

Astăzi am vorbit despre cum să începem să scriem scripturi bash și am acoperit câteva lucruri de bază. De fapt, tema programării bash este uriașă. Acest articol este o traducere a primei părți a unei serii mari de 11 materiale. Dacă doriți să continuați chiar acum, iată o listă cu originalele acestor materiale. Pentru comoditate, traducerea pe care tocmai ați citit-o este inclusă aici.

Pentru scrierea unui script bash simplu, trebuie să parcurgem următorii pași simpli:

Cum funcționează totul:

Prima linie a scriptului nostru #!/bin/bash este esențială pentru ca scriptul nostru să se execute cu succes.

a doua linie mkdir testdir creează directorul testdir

a treia linie cd testdir vă permite să mergeți la directorul creat testdir

echipă atingereîn linia următoare atingeți fișier1 fișier2 fișier3 creează trei fișiere

iar ultima comandă din linia scriptului nostru, ls -al, vă permite să afișați conținutul directorului curent, în care, datorită liniei anterioare, au apărut trei fișiere goale.

După cum vedem, în nostru script simplu toate comenzile încep cu linie nouă. Fiecare linie, atunci când rulează scriptul, își realizează succesiv munca, efectuând anumite acțiuni.

Dacă executați zilnic un lanț de comenzi identice (cu parametri constanti) în Linux, atunci poate că are sens să scrieți același lucru script bash simplu, care vă va permite să economisiți timp și să vă automatizați munca.