SO - suport seminar

Shell scripting
Shell scripting este o metodă prin care se creează
programe sau scripturi ce sunt executate într-un
shell al sistemului de operare. Shell scripting-ul este
puternic și flexibil, permițând automatizarea
sarcinilor repetitive, gestionarea sistemului,
executarea comenzi complexe și multe altele.

Scripturile shell sunt de obicei scrise pentru shell-

uri de tip Unix, cum ar fi Bourne Shell ( sh ), Bourne
Again Shell ( bash ), C Shell ( csh ), Korn Shell
( ksh ), și altele, fiecare având propria sa sintaxă și
set de funcționalități. Cel mai comun shell utilizat
pentru scripting în sistemele Linux și Unix este
bash .

Caracteristici principale ale Shell

Scripting:

• Automatizarea sarcinilor: Poți automatiza

sarcinile de rutină cum ar fi backup-ul de date,
actualizările de sistem și gestionarea fișierelor.

• Execuție de comenzi în loturi: Permite

executarea unei serii de comenzi într-o singură
rulare, fără intervenție manuală.

• Manipularea fișierelor și directoarelor: Poți

crea, șterge, muta și modifica fișiere și
directoare.

• Gestionarea proceselor: Permite oprirea,

pornirea și monitorizarea proceselor de sistem.

• Interacțiune cu utilizatorul: Poți solicita input de

la utilizator, afișa mesaje și oferi feedback.

Exemplu simplu de Shell

Script:
#!/bin/bash

# Afișează un mesaj de bun venit

echo "Bine ai venit!"

# Cere utilizatorului să introducă numele

echo -n "Te rog să îți introduci numele: "
read nume

# Salută utilizatorul
echo "Salut, $nume!"

Acest script utilizează:

• #!/bin/bash pentru a specifica interpretorul

care va executa scriptul.

• echo pentru a afișa mesaje.

• read pentru a citi intrarea de la tastatură.

Pentru a executa un script shell pe un sistem Unix

sau Linux, trebuie să urmezi câțiva pași simpli.
Presupunând că ai un script salvat cu numele
[Link] , iată cum l-ai putea rula:

1. Fă Scriptul Executabil

În primul rând, trebuie să te asiguri că scriptul are

permisiuni de executare. Acest lucru se face cu
comanda chmod (change mode). Deschide un
terminal și navighează la directorul unde ai salvat
scriptul. Apoi, rulează:

~$ chmod +x [Link]

Această comandă modifică permisiunile fișierului

[Link] pentru a permite executarea acestuia.

2. Execută Scriptul

După ce ai acordat permisiunile necesare, există

două moduri prin care poți executa scriptul:

Opțiunea 1: Folosind Calea Relativă sau Absolută

Dacă te afli în același director cu scriptul, îl poți

executa folosind o cale relativă:

~$ ./[Link]

Dacă scriptul se află într-un alt director, poți utiliza

calea absolută:

~$ /path/to/your/[Link]

Opțiunea 2: Folosind Interpretorul Direct

De asemenea, poți folosi shell-ul direct pentru a

executa scriptul, fără a modifica permisiunile de
executare. Dacă scriptul este scris pentru Bash,
folosești:

~$ bash [Link]

Acest mod de executare interpretează direct

conținutul fișierului ca un script Bash, fără a
necesita permisiuni de executare pe fișier.

Note Importante

• Asigură-te că prima linie a scriptului tău conține

shebang-ul ( #! ) urmat de calea către
interpretorul adecvat. Pentru un script Bash,
aceasta este de obicei #!/bin/bash .

• Dacă întâmpini erori referitoare la "bad

interpreter: No such file or directory", verifică
shebang-ul pentru erori de cale.

Comentarii în Bash Script

• Comentarii pe o singură linie: Încep cu simbolul
# . Tot textul de pe linie după # este tratat ca
un comentariu.

• Comentarii pe mai multe linii: Bash nu are o

sintaxă specifică pentru comentariile pe mai
multe linii similar cu alte limbaje de programare,
dar poți folosi mai multe linii de comentarii pe o
singură linie sau un hack folosind :
'...comment...' .

#!/bin/bash

# Acest script afișează un mesaj de salut.

echo "Salut!"

# Calcularea sumei a două numere

numar1=5
numar2=10
suma=$((numar1 + numar2)) # Adună numărul1
și numărul2

echo "Suma este: $suma"

# Următoarele linii sunt comentate și nu

vor fi executate
# echo "Acesta este un comentariu pe mai
multe linii."
# echo "Această parte a codului este
dezactivată pentru demonstrație."

# Folosind hack-ul pentru comentarii pe mai

multe linii
: '
Acesta este un exemplu de comentariu
pe mai multe linii folosind hack-ul cu :
'

Utilizarea Variabilelor
În exemplul anterior, variabilele numar1 și numar2
sunt folosite pentru a stoca valori numerice. Apoi,
aceste valori sunt folosite pentru a efectua un calcul
matematic.

numar1=5
numar2=10

Alocarea valorilor variabilelor se face fără spații în

jurul semnului = . Pentru a accesa valoarea unei
variabile, se utilizează semnul $ înaintea numelui
variabilei.

Calculul Expresiei Matematice

Shell-ul Bash permite efectuarea calculului

expresiilor matematice folosind diverse metode. În
exemplul dat, este folosită comanda internă
$((expresie)) pentru a evalua suma a două
numere.

suma=$((numar1 + numar2)) # Adună numărul1 și n

Acest mecanism, $((expresie)) , evaluează

expresia matematică specificată în interiorul
parantezelor duble și atribuie rezultatul variabilei
suma . În acest caz, numar1 și numar2 sunt
adunate, iar rezultatul lor, 15 , este stocat în
variabila suma .

Afișarea rezultatului se face folosind echo :

echo "Suma este: $suma"

Aceasta afișează valoarea variabilei suma în

consolă, care în exemplul nostru este 15 .

În Bash scripting, variabilele nu sunt tipizate în mod

strict în sensul limbajelor de programare static
tipizate precum Java sau C++. În schimb, Bash
tratează toate variabilele ca șiruri de caractere
(strings). Cu toate acestea, Bash permite efectuarea
de operații aritmetice pe variabile fără a necesita
conversia explicită între tipuri de date, atâta timp cât
valorile variabilelor pot fi interpretate ca numere.

Caracteristici ale Variabilelor în Bash:

• Dinamice: Variabilele în Bash pot stoca atât

numere cât și text, și tipul lor poate fi schimbat
dinamic în timpul execuției scriptului.

• Conversia Automată: Când efectuați operații

aritmetice, Bash încearcă să convertească
automat valorile la numere. Dacă o variabilă
conține un șir care poate fi interpretat ca un
număr, atunci poate fi utilizat direct în expresii
aritmetice.

• Lipsa Declarației: Nu este necesar să declari

tipul unei variabile înainte de a o folosi.
Atribuirea unei valori unei variabile este
suficientă pentru a o declara.

Chiar dacă Bash gestionează variabilele într-un mod

flexibil, această flexibilitate vine cu
responsabilitatea de a asigura că valorile variabilelor
sunt adecvate pentru operațiile la care sunt supuse.
De exemplu, încercarea de a efectua o operație
aritmetică cu un șir de caractere care nu poate fi
interpretat ca un număr va duce la o eroare.

Array-uri (Vectori)

Array-urile permit stocarea mai multor valori într-o

singură variabilă, fiecare valoare putând fi accesată
printr-un index. Bash suportă array-uri
unidimensionale.

Exemplu de Declarare și Utilizare:

nume=('Alice' 'Bob' 'Carol')

echo "${nume[0]}" # Afișează Alice
echo "${nume[@]}" # Afișează toate elementele a
echo "${#nume[@]}" # Afișează numărul de elemen

nume+=("Dave")
echo "${nume[@]}" # Afișează toate elementele a

Lucrul cu sub-array-uri (sau porțiuni dintr-un array)

se poate face utilizând sintaxa de slicing de array-
uri. Aceasta permite extragerea unei secțiuni dintr-
un array bazată pe indicii de start și stop. Sintaxa
generală pentru slicing este:

${array[@]:pozitie_start:lungime}

Unde:

• array este numele array-ului din care vrei să

extragi sub-array-ul.

• pozitie_start este indicele elementului de la

care începe extracția (indicele începe de la 0).

• lungime este numărul de elemente de extras

din array, începând cu pozitie_start .

Exemplu de Utilizare

Să presupunem că avem următorul array:

numere=(0 1 2 3 4 5 6 7 8 9)

Dacă dorim să extragem un sub-array care începe

de la indicele 3 și are lungimea 4, vom folosi:

echo "${numere[@]:3:4}"

Acesta va afișa:

3 4 5 6

• Dacă omiti parametrul lungime , se vor extrage

toate elementele începând cu pozitie_start
până la sfârșitul array-ului.

• Bash nu suportă direct array-uri

multidimensionale, așa că lucrul cu sub-array-
uri necesită manipulare manuală sau abordări
creative pentru structuri de date mai complexe.

Array-uri Asociative (Dictionare sau Map-

uri)

Array-urile asociative sunt o extensie a array-urilor

simple și permit accesarea valorilor folosind chei
unice, în loc de indici numerici. Sunt similare cu
dictionarele din Python sau obiectele din JavaScript.

Exemplu de Declarare și Utilizare:

Pentru a folosi array-uri asociative, trebuie să

declarăm variabila folosind declare -A :

declare -A capitale
capitale["Franța"]="Paris"
capitale["Germania"]="Berlin"
echo "Capitala Franței este: ${capitale["Franța

IF / THEN / ELSE
Structura if-then-else în Bash este o construcție
fundamentală folosită pentru a testa condiții și a
executa diferite blocuri de cod bazate pe rezultatul
testului. Această structură permite scripturilor să ia
decizii și să execute diferite acțiuni în funcție de
diferite condiții.

Sintaxa de bază

if [ condiție ]; then
# Comenzi executate dacă condiția este adevăr
else
# Comenzi executate dacă condiția este falsă
fi

• if - începe testul condițional.

• [ condiție ] - condiția care trebuie evaluată.

Parantezele drepte [ ] reprezintă comanda
test în Bash.

• then - dacă condiția evaluată este adevărată,

comenzile care urmează până la else sau fi
vor fi executate.

• else - (opțional) specifică comenzile care vor

fi executate dacă condiția este falsă.

• fi - încheie blocul if .

Exemplu 1: Test simplu

#!/bin/bash

numar=10

if [ $numar -eq 10 ]; then

echo "Numărul este egal cu 10."
else
echo "Numărul nu este egal cu 10."
fi

Acest script va afișa "Numărul este egal cu 10."

pentru că condiția testată ( $numar -eq 10 ) este
adevărată.

Exemplu 2: Verificarea Existentei unui

Fișier

#!/bin/bash

filename="[Link]"

if [ -e "$filename" ]; then
echo "Fișierul există."
else
echo "Fișierul nu există."
fi

Acest script verifică dacă fișierul [Link]

există în directorul curent. Dacă fișierul există, va
afișa "Fișierul există."; altfel, va afișa "Fișierul nu
există."

Exemplu 3: Structură If-Elif-Else

Bash permite și utilizarea elif pentru a testa

condiții multiple în aceeași structură if .

#!/bin/bash

nota=85

if [ $nota -ge 90 ]; then

echo "Ai obținut A."
elif [ $nota -ge 80 ]; then
echo "Ai obținut B."
else
echo "Ai obținut C sau mai jos."
fi

Acest script evaluează o notă și afișează

calificativul corespunzător. În exemplul nostru, va
afișa "Ai obținut B.".

• Este important să pui spațiu după [ și înainte

de ] în condiția if .

• Pentru a testa mai multe condiții în cadrul

aceleiași instrucțiuni if , poți folosi operatorii
logici && (și) și || (sau).

• Folosirea ghilimelelor în jurul variabilelor, de

exemplu, "$filename" , previne erori legate de
valori goale sau conținând spații.

În Bash, operatorii de test sunt folosiți pentru a

evalua condiții în instrucțiunile de control, cum ar fi
if , while , și until . Acești operatori permit
compararea numerică, verificarea șirurilor de
caractere, testarea atributelor fișierelor și altele. Iată
o listă a celor mai comuni operatori de test în Bash:

Testarea Numerică

• -eq : egal cu (ex: $a -eq $b )

• -ne : nu este egal cu (ex: $a -ne $b )

• -gt : mai mare decât (ex: $a -gt $b )

• -ge : mai mare sau egal cu (ex: $a -ge $b )

• -lt : mai mic decât (ex: $a -lt $b )

• -le : mai mic sau egal cu (ex: $a -le $b )

Testarea Șirurilor de Caractere

• = sau == : egal (ex: $a = $b )

• != : nu este egal (ex: $a != $b )

• -z : șirul este gol (ex: -z $a )

• -n : șirul nu este gol (ex: -n $a )

• $a : șirul a are o lungime mai mare decât 0

Testarea Fișierelor

• -e : fișierul există (ex: -e [Link] )

• -f : fișierul există și este un fișier obișnuit (nu

un director sau un dispozitiv) (ex: -f
[Link] )

• -d : fișierul există și este un director (ex: -d

director )

• -r : fișierul există și este citibil (ex: -r

[Link] )

• -w : fișierul există și este scriibil (ex: -w

[Link] )

• -x : fișierul există și este executabil (ex: -x

[Link] )

• -s : fișierul există și nu este gol (are

dimensiunea mai mare decât zero) (ex: -s
[Link] )

• -L : fișierul există și este un link simbolic (ex: -

L link_simbolic )

Operatori Logici

• ! : negație (inversarea stării de adevăr) (ex: !

-e [Link] )

• -a sau && : și logic (ex: [$a -lt 20] && [$b -

gt 100] )

• -o sau || : sau logic (ex: [$a -lt 20] || [$b

-gt 100] )

Pentru a utiliza acești operatori în scripturile tale

Bash, poți folosi comanda test sau paranteze
pătrate (de exemplu, [ $a -lt $b ] ). Este
important să pui spațiu după [ , înainte de ] , și în
jurul operatorilor pentru a asigura interpretarea
corectă a expresiei de către shell.

Structuri repetitive: FOR /

WHILE / UNTIL
Aceste structuri sunt esențiale pentru scrierea
scripturilor care necesită iterație, cum ar fi
procesarea colecțiilor de date sau așteptarea
schimbării unei condiții.

1. FOR

Structura for repetă un set de comenzi pentru

fiecare element dintr-o listă.

Exemplu:

#!/bin/bash

for nume in Alice Bob Carol

do
echo "Salut, $nume!"
done

Acest script va afișa un mesaj de salut pentru

fiecare nume specificat în listă.

Structura for în Bash poate fi utilizată și cu un

iterator numeric, permițând iterarea printr-o
secvență de numere. Acest lucru este des realizat
folosind o sintaxă specifică, care seamănă cu cea
din limbajele de programare tradiționale. Iată un
exemplu care afișează numerele de la 1 la 5:

Exemplu 2:

#!/bin/bash

for (( i=1; i<=5; i++ ))

do
echo "Numărul curent este: $i"
done

Exemplu 3:

#!/bin/bash

#iterarea element cu element printr-un array, c

nume=('Alice' 'Bob' 'Carol')
for i in "${!nume[@]}"; do
echo "Salut, ${nume[i]}!"
done

Aici, ${!nume[@]} generează o listă de indici

pentru array-ul nume , iar for iterează prin acești
indici. Variabila i reprezintă pe rând fiecare indice,
permițându-ți să accesezi elementul corespunzător
din array ( ${nume[i]} ).

2. WHILE

Structura while execută un bloc de comenzi atât

timp cât o condiție este adevărată.

Exemplu:

#!/bin/bash

contor=1
while [ $contor -le 5 ]
do
echo "Iterația $contor"
((contor++))
done

Acest script va afișa numărul iterației de cinci ori,

incrementând variabila contor la fiecare pas până
când aceasta devine mai mare decât 5.

3. UNTIL

Structura until este similară cu while , dar

repetă comenzi până când condiția devine
adevărată (adică face loop pe condiție falsă).

Exemplu:

#!/bin/bash

contor=1
until [ $contor -gt 5 ]
do
echo "Iterația $contor"
((contor++))
done

Acest script funcționează la fel ca exemplul while ,

afișând numărul iterației până când contor
depășește 5. Diferența principală este în verificarea
condiției: until execută blocul de comenzi atât
timp cât condiția este falsă.

Exemple comenzi in script

1. Căutarea unui Text în Fișiere

Acest script folosește grep pentru a căuta un șir

specific în toate fișierele .txt din directorul curent.

#!/bin/bash

search_string="error"
for file in *.txt; do
echo "Caută '$search_string' în $file:"
grep "$search_string" "$file" && echo
"Găsit în $file" || echo "Nu a fost găsit
în $file"