Stăpânește logica: Cum să folosești corect variabile într-un Bash script boolean

Dragă pasionatule de terminal și rânduri de cod, ai simțit vreodată că scripturile tale Bash ar putea fi mai inteligente, mai reactive, mai… logice? Ei bine, nu ești singur! Inima oricărui script robust stă în capacitatea sa de a lua decizii. Și când vine vorba de decizii simple, de tipul „da” sau „nu”, „adevărat” sau „fals”, intră în scenă logica booleană. Astăzi vom desluși misterele utilizării corecte a variabilelor pentru a implementa această logică esențială în scripturile tale Bash. Pregătește-te să transformi scripturile tale dintr-o serie de comenzi într-un sistem inteligent de decizie! 🚀

Ce Înseamnă „Boolean” în Universul Bash?

Dacă ai experiență cu alte limbaje de programare, știi probabil că tipul de date „boolean” are valori bine definite: true (adevărat) și false (fals). În Bash, lucrurile stau puțin diferit și, sincer, la început pot fi puțin derutante. Shell-ul nu are un tip de date boolean nativ în sensul strict. În schimb, se bazează pe codurile de ieșire (exit codes) ale comenzilor pentru a evalua succesul sau eșecul, și implicit, starea logică.

• 💡 O comandă care se execută cu succes returnează un cod de ieșire 0. Acesta este interpretat ca „adevărat” (true) în contextul condițiilor Bash.
• ⚠️ O comandă care eșuează returnează un cod de ieșire non-zero (de obicei 1, dar poate fi orice număr de la 1 la 255). Acesta este interpretat ca „fals” (false).

Deci, în loc să gândim în termeni de true/false ca valori directe ale unei variabile, trebuie să ne adaptăm la paradigma „succes/eșec” a shell-ului. Totuși, putem simula variabile booleane utilizând șiruri de caractere (string-uri) precum „true” și „false”, sau chiar numere (0 și 1), atâta timp cât suntem consecvenți în interpretarea lor. Este vital să înțelegem această subtilitate pentru a scrie scripturi eficiente și fără erori.

Declararea și Manipularea Variabilelor Boolean în Bash

Deși nu avem un tip de date explicit „boolean”, putem atribui valori variabilelor noastre care să reprezinte stări logice. Cele mai comune abordări includ:

1. Șiruri de caractere („true”, „false”): Aceasta este probabil cea mai intuitivă metodă, deoarece se aliniază cu denumirile booleene universale.
2. Valori numerice (0, 1): Unii preferă 1 pentru „adevărat” și 0 pentru „fals”, similar cu alte limbaje de programare. Atenție însă la confuzia cu codurile de ieșire!

Exemplu de Declarație:

# Utilizând șiruri de caractere
ESTE_ACTIV="true"
A_FINALIZAT="false"

# Utilizând valori numerice (cu precauție!)
ARE_PERMISIUNI=1  # 1 pentru adevărat
VERIFICARE_ESUATA=0 # 0 pentru fals

Acum că avem variabilele noastre, cum le folosim în logica decizională? Aici intervin structurile condiționale și operatorii de comparație.

Evaluarea Condițiilor: `test`, `[ ]`, `[[ ]]` și `(( ))`

Bash oferă mai multe modalități de a evalua condiții, fiecare cu propriile sale avantaje. Cunoașterea diferențelor este crucială pentru a alege instrumentul potrivit.

1. `test` și `[ ]` (Paranteze Simple)

Comanda test este fundamentul evaluării condiționale. [ ] este, de fapt, un alias sintactic pentru test. Aceasta este o comandă externă (sau o funcție builtin în Bash) care returnează un cod de ieșire 0 (adevărat) dacă condiția este îndeplinită și 1 (fals) în caz contrar.

ESTE_LOGAT="true"

# Folosind 'test'
if test "$ESTE_LOGAT" = "true"; then
    echo "Utilizatorul este conectat."
fi

# Folosind '[ ]' (mai comun)
if [ "$ESTE_LOGAT" = "true" ]; then
    echo "Utilizatorul este conectat."
fi

NUMAR=10
if [ "$NUMAR" -gt 5 ]; then # -gt pentru "greater than"
    echo "Numărul este mai mare decât 5."
fi

⚠️ Atenție! La utilizarea [ ], este esențial să lași spații de jur împrejurul parantezelor și operatorilor. De asemenea, variabilele trebuie ghilimele pentru a preveni problemele cu cuvintele despărțite (word splitting) sau variabilele goale.

2. `[[ ]]` (Paranteze Dube – Comparații Avansate)

Acesta este un operator compus, o caracteristică extinsă a Bash (nu o comandă separată). Oferă mai multă flexibilitate și este, în general, mai sigur și mai puternic decât [ ].

Avantaje majore ale [[ ]]:

• ✅ Nu necesită ghilimele pentru variabile în majoritatea cazurilor, deoarece previne word splitting. (Totuși, este o bună practică să le ghilimezi, pentru consecvență.)
• ✅ Suportă operatori logici precum && (AND) și || (OR) direct în expresie, fără a folosi operatori specifici [ ] precum `-a` sau `-o`.
• ✅ Permite potrivirea de expresii regulate (regex matching) folosind operatorul =~.
• ✅ Suportă potrivirea de globuri (wildcard matching) fără a invoca utilitare externe.

STATUS_PROCES="running"
VERIFICARE_RETE="true"

if [[ "$STATUS_PROCES" == "running" && "$VERIFICARE_RETE" == "true" ]]; then
    echo "Sistemul este operațional."
fi

FISIER="raport.txt"
if [[ -f "$FISIER" || -d "$FISIER" ]]; then # -f pentru fișier, -d pentru director
    echo "Calea $FISIER există și este fie un fișier, fie un director."
fi

TEXT="Acesta este un exemplu de text."
if [[ "$TEXT" =~ "exemplu" ]]; then
    echo "Textul conține cuvântul 'exemplu'."
fi

Pentru majoritatea scenariilor moderne de scripting, [[ ]] este alegerea preferată datorită siguranței și funcționalității extinse.

3. `(( ))` (Dublu Paranteze Rotunde – Evaluare Aritmetică)

Acest constructor este dedicat evaluărilor aritmetice și poate fi folosit și pentru condiții numerice. În (( )), 0 este interpretat ca „fals”, iar orice altă valoare non-zero (pozitivă sau negativă) este interpretată ca „adevărat”.

COUNTER=5
POATE_CONTINUA=1 # 1 pentru adevărat

if (( COUNTER > 0 && POATE_CONTINUA )); then
    echo "Condiție numerică adevărată."
    (( COUNTER-- )) # Decrementăm contra.
fi

FLAG_NUMERIC=0 # Fals
if (( ! FLAG_NUMERIC )); then # Operatorul '!' pentru negație
    echo "Flag-ul numeric este fals (sau zero)."
fi

Este excelent pentru variabile care dețin valori numerice, inclusiv pentru a simula un boolean unde 1 este „adevărat” și 0 este „fals”.

Operatori Logici în Bash: `&&`, `||`, `!`

Pe lângă operatorii de comparație, Bash oferă și operatori logici care îți permit să combine sau să negi condiții. Aceștia sunt esențiali pentru construirea unei logici complexe.

• `&&` (AND logic): Execută comanda din dreapta doar dacă cea din stânga returnează un cod de ieșire 0 (adevărat).
• `||` (OR logic): Execută comanda din dreapta doar dacă cea din stânga returnează un cod de ieșire non-zero (fals).
• `!` (NOT logic): Negă codul de ieșire al unei comenzi. Dacă o comandă eșuează (non-zero), ! o transformă în succes (0) și viceversa.

ESTE_ADMIN="true"
ARE_ACCES="false"

# Combinăm condiții cu && și ||
if [[ "$ESTE_ADMIN" == "true" && "$ARE_ACCES" == "true" ]]; then
    echo "Acces complet acordat."
elif [[ "$ESTE_ADMIN" == "true" || "$ARE_ACCES" == "true" ]]; then
    echo "Acces parțial acordat (admin sau are acces)."
else
    echo "Acces refuzat."
fi

# Utilizăm ! pentru a nega o condiție
ESTE_ACTIV="false"
if ! [[ "$ESTE_ACTIV" == "true" ]]; then
    echo "Utilizatorul nu este activ (negație)."
fi

Acești operatori sunt extrem de puternici și contribuie la claritatea și concizia scripturilor tale. Ei urmează principiul „short-circuiting”: expresia este evaluată doar atât cât este necesar. De exemplu, în conditie1 && conditie2, dacă conditie1 este falsă, conditie2 nu va fi evaluată deloc.

Variabile Boolean ca Argumente sau Valori de Retur în Funcții

Scripturile bune sunt modulare. Variabilele booleane își arată utilitatea și în comunicarea dintre funcții sau în definirea comportamentului unei funcții.

Trecerea Flag-urilor către Funcții:

Poți pasa variabile booleane ca argumente pentru a controla fluxul de execuție al unei funcții. De exemplu, un flag pentru modul „debug”.

function proceseaza_date() {
    local FISIER="$1"
    local MOD_DEBUG="$2" # true sau false

    if [ "$MOD_DEBUG" == "true" ]; then
        echo "⚙️ Modul DEBUG activat pentru fișierul: $FISIER"
        # Comenzi suplimentare de depanare
    fi

    # Logica principală de procesare
    if [ -f "$FISIER" ]; then
        echo "Procesăm fișierul $FISIER..."
        # ...
        return 0 # Succes
    else
        echo "⚠️ Eroare: Fișierul $FISIER nu există!"
        return 1 # Eșec
    fi
}

# Apelăm funcția cu mod debug
proceseaza_date "config.txt" "true"

# Apelăm funcția în modul normal
proceseaza_date "data.csv" "false"

if proceseaza_date "fisier_inexistent.log" "false"; then
    echo "Procesare reușită."
else
    echo "Procesare eșuată."
fi

Observă cum funcția proceseaza_date returnează 0 pentru succes și 1 pentru eșec, permițând utilizarea ei direct în structuri if.

Capcane Comune și Cum Să Le Evităm

Chiar și cei mai experimentați scriptori Bash cad în aceste capcane. Cunoașterea lor te va salva de multă frustrare! 🤯

1. ⚠️ Lipsa Spațiilor în `[ ]`: Am menționat deja, dar este o greșeală atât de frecventă încât merită repetată. [ "$var" = "true" ] este corect, ["$var"="true"] este greșit.
2. ⚠️ Lipsa Ghilimelelor la Variabile: Dacă o variabilă este goală sau conține spații, [ $VAR = "ceva" ] va eșua. Folosește întotdeauna [ "$VAR" = "ceva" ], chiar și cu [[ ]] pentru consecvență.
3. ⚠️ Confuzia dintre `==` și `-eq`:
   • `==` (sau `=`) este pentru comparații de șiruri de caractere (string-uri).
   • `-eq` este pentru comparații numerice (equal). Similar: `-ne` (not equal), `-gt` (greater than), `-lt` (less than), `-ge` (greater or equal), `-le` (less or equal).

   
           VALOARE="10"
           if [ "$VALOARE" == "10" ]; then echo "Comparație string corectă."; fi
           if [ "$VALOARE" -eq 10 ]; then echo "Comparație numerică corectă."; fi
           # if [ "$VALOARE" -eq "10" ] # Ar funcționa, dar e mai bine fără ghilimele la numere
           # if [ "$VALOARE" == 10 ] # Potențial periculos dacă VALOARE nu e număr pur
           

4. ⚠️ Amestecarea Operatorilor Logici: În [ ], operatorii logici sunt -a (AND) și -o (OR). În [[ ]], aceștia sunt && și ||. Nu le confunda! Folosește [[ ]] pentru claritate maximă.
5. ⚠️ Supra-complicarea Logicii: Încearcă să menții condițiile cât mai simple și lizibile. Dacă o condiție devine prea lungă, împarte-o în mai multe sub-condiții sau folosește funcții.

Exemplu Practic Complex: Verificarea Serviciilor și Stării Sistemului

Să punem în practică ce am învățat printr-un script mai complex. Acesta va verifica starea unui serviciu și starea spațiului pe disc, utilizând variabile booleane și condiții avansate.

#!/bin/bash
set -euo pipefail # O bună practică: ieșire la eroare, variabile nedefinite, eroare în pipe

# ⚙️ Funcție pentru a verifica dacă un serviciu rulează
function verifica_serviciu() {
    local SERVICE_NAME="$1"
    # systemctl is-active returnează 0 pentru activ, non-zero pentru inactiv
    if systemctl is-active --quiet "$SERVICE_NAME"; then
        echo "✅ Serviciul '$SERVICE_NAME' rulează."
        return 0 # Adevărat
    else
        echo "⚠️ Serviciul '$SERVICE_NAME' NU rulează."
        return 1 # Fals
    fi
}

# ⚙️ Funcție pentru a verifica spațiul pe disc
function verifica_spatiu_disc() {
    local THRESHOLD="$1" # Prag de utilizare în procente
    local PARTITION="$2" # Partitia de verificat, ex: /
    local USAGE=$(df -h "$PARTITION" | awk 'NR==2 {print $5}' | sed 's/%//g') # Extrage procentul

    echo "⚙️ Utilizare disc pentru '$PARTITION': $USAGE%"

    if (( USAGE > THRESHOLD )); then
        echo "⚠️ Atenție: Utilizarea discului pentru '$PARTITION' depășește $THRESHOLD% ($USAGE%)."
        return 1 # Fals
    else
        echo "✅ Spațiul pe disc pentru '$PARTITION' este în limite normale ($USAGE%)."
        return 0 # Adevărat
    fi
}

# Definirea variabilelor booleane (implicite "false" la început)
SERVICIU_OK="false"
DISC_OK="false"

# Verificăm serviciul Nginx
if verifica_serviciu "nginx"; then
    SERVICIU_OK="true"
fi

# Verificăm spațiul pe disc pentru / (rădăcină) cu un prag de 80%
if verifica_spatiu_disc 80 "/"; then
    DISC_OK="true"
fi

echo ""
echo "--- Sumar Verificări ---"

# Evaluăm starea generală folosind variabilele booleane
if [[ "$SERVICIU_OK" == "true" && "$DISC_OK" == "true" ]]; then
    echo "✅ Sistemul este complet operațional! Toate verificările au trecut."
    exit 0
elif [[ "$SERVICIU_OK" == "true" || "$DISC_OK" == "true" ]]; then
    echo "⚠️ Sistemul are unele probleme. Verificați rapoartele de mai sus."
    exit 1
else
    echo "❌ Sistemul are probleme critice! Ambele verificări au eșuat."
    exit 2
fi

Acest exemplu demonstrează cum poți folosi funcțiile pentru a încapsula logica de verificare, returnând coduri de ieșire pe care le interpretezi apoi pentru a seta variabile interne (SERVICIU_OK, DISC_OK). În final, aceste variabile sunt utilizate în condiții [[ ]] pentru a determina starea generală a sistemului. Este o metodă robustă și scalabilă.

Opinii și Sfaturi Profesionale pentru un Scripting Eficient

Pe parcursul anilor de scripting, am observat că cel mai mare impediment nu este lipsa funcționalităților, ci adesea neînțelegerea modului în care Bash interpretează conceptele. Iată câteva sfaturi bazate pe experiență:

💡 Claritatea este cheia în scripting. Deși Bash are particularitățile sale, mai ales în lipsa unui tip boolean nativ, adoptarea unei convenții clare (fie „true”/”false” ca șiruri, fie 0/1 ca numere pentru flag-uri, alături de respectarea codurilor de ieșire standard) te va salva de multă confuzie. Nu te teme să fii explicit, chiar dacă pare redundant, pentru că un script care funcționează azi poate deveni un coșmar de depanat mâine fără o logică impecabilă.

Iată câteva practici recomandate:

• ✅ Denumește variabilele sugestiv: ESTE_GATA, A_ESUAT, MOD_DEBUG_ACTIVAT. Evită nume scurte și ambigue.
• ✅ Folosește `[[ ]]` pe cât posibil: Pentru majoritatea comparațiilor de șiruri și condițiilor complexe, oferă o sintaxă mai sigură și mai puternică.
• ✅ Ghilimelează variabilele întotdeauna: Chiar și în [[ ]], este o bună practică care previne erori neașteptate.
• ✅ Comentează-ți logica: Explică intenția din spatele condițiilor complexe. Un comentariu bun valorează o mie de depanări.
• ✅ Folosește `set -e`, `set -u`, `set -o pipefail`: Aceste opțiuni sunt esențiale pentru scripturi robuste, forțând scriptul să eșueze la prima eroare (-e), să detecteze variabilele nedefinite (-u) și să propage erorile prin pipe-uri (-o pipefail).
• ✅ Testează-ți scripturile riguros: Scrie unități de test dacă scriptul este complex. Variabilele booleane sunt adesea puncte critice în logica de control, iar testarea adecvată le poate valida comportamentul.

Concluzie

Stăpânirea logicii booleane în Bash nu înseamnă să te lupți cu lipsa unui tip de date explicit, ci să înțelegi cum shell-ul interpretează succesul și eșecul. Prin utilizarea inteligentă a codurilor de ieșire, a variabilelor de stare și a constructorilor condiționali precum [[ ]] și (( )), poți crea scripturi incredibil de puternice și flexibile. Practica este cheia. Începe cu scripturi simple, extinde-le treptat și nu te teme să experimentezi. Cu fiecare rând de cod scris și testat, vei deveni mai priceput în a face ca mașinile tale să ia decizii logice, iar munca ta să devină mai eficientă. Acum, ieși și scrie niște logică solidă! 💪