Terminalul Linux: comenzile pe care le folosești zilnic

Comenzile Linux esențiale pentru programatori: navigare, fișiere, căutare, pipe-uri, permisiuni, procese, rețea și primul script bash.

Terminalul pare intimidant la început: un ecran negru, fără butoane, în care o comandă greșită poate șterge fișiere. În realitate, majoritatea programatorilor folosesc zilnic doar câteva zeci de comenzi, iar după ce le stăpânești, multe sarcini devin mai rapide decât în orice interfață grafică. Ghidul acesta adună comenzile esențiale, grupate după situațiile în care chiar le vei folosi.

Terminal, shell și cum începi

Terminalul este fereastra în care scrii comenzi. Shell-ul este programul care le interpretează și le execută. Pe majoritatea distribuțiilor Linux, shell-ul implicit este bash, iar pe macOS este zsh. Comenzile din acest ghid funcționează la fel în ambele.

Dacă lucrezi pe Windows, cea mai simplă cale de a avea un mediu Linux real este WSL (Windows Subsystem for Linux). Deschide PowerShell ca administrator și rulează:

wsl --install

După repornire, vei avea o distribuție Ubuntu pe care o deschizi din meniul Start sau din Windows Terminal.

Când deschizi terminalul, vezi un prompt, de obicei ceva de forma ana@laptop:~$. Acesta îți arată utilizatorul, numele calculatorului și directorul curent (~ înseamnă directorul tău personal, de exemplu /home/ana).

Navigarea prin fișiere

pwd                  # afișează directorul curent
ls                   # listează conținutul directorului
ls -la               # listă detaliată, inclusiv fișierele ascunse
cd proiecte/site     # intră într-un director (cale relativă)
cd /var/log          # intră într-un director (cale absolută)
cd ..                # urcă un nivel
cd ~                 # mergi în directorul personal (la fel ca simplu cd)
cd -                 # revino în directorul anterior

Fișierele și directoarele al căror nume începe cu punct (de exemplu .git sau .env) sunt ascunse și apar doar cu ls -a.

Două obiceiuri care îți economisesc mult timp:

Tasta Tab completează automat numele de fișiere, directoare și comenzi. Apăsată de două ori, îți arată toate variantele posibile.
Ctrl+R caută în istoricul comenzilor. Scrii o parte din comandă și apeși din nou Ctrl+R ca să mergi la rezultatul anterior.

Lucrul cu fișiere și directoare

mkdir proiect-nou                 # creează un director
mkdir -p src/componente/butoane   # creează și directoarele intermediare
touch index.html                  # creează un fișier gol
cp config.json config.backup.json # copiază un fișier
cp -r src/ src-backup/            # copiază un director, recursiv
mv vechi.txt nou.txt              # redenumește
mv raport.pdf ~/Documente/        # mută
rm fisier.txt                     # șterge un fișier
rm -r director/                   # șterge un director cu tot conținutul

Atenție: rm nu trimite fișierele în Recycle Bin; le șterge definitiv. Verifică de două ori calea înainte de un rm -r și evită să-l combini cu sudo dacă nu ești sigur ce faci. Opțiunea -i (rm -ri director/) cere confirmare pentru fiecare fișier.

Citirea conținutului

cat README.md            # afișează tot fișierul
less server.log          # citește un fișier lung, pagină cu pagină (q pentru ieșire)
head -n 20 date.csv      # primele 20 de linii
tail -n 50 app.log       # ultimele 50 de linii
tail -f app.log          # urmărește fișierul în timp real (Ctrl+C pentru oprire)
wc -l date.csv           # numărul de linii

tail -f este una dintre comenzile pe care le vei folosi cel mai des când depanezi un server: vezi log-urile pe măsură ce apar, în timp ce testezi aplicația.

În less, poți căuta un text apăsând /, scriind termenul și apoi Enter; n te duce la următorul rezultat.

Editarea fișierelor direct din terminal

Pe un server conectat prin SSH nu ai editorul tău preferat, așa că mai devreme sau mai târziu va trebui să modifici un fișier de configurare direct din terminal. Cel mai simplu editor pentru început este nano, instalat implicit pe majoritatea distribuțiilor:

nano config.env

Comenzile sunt afișate în partea de jos a ecranului (simbolul ^ înseamnă tasta Ctrl). Cele mai importante: Ctrl+O salvează fișierul, Ctrl+X închide editorul, Ctrl+W caută un text.

Vei întâlni și vim, care se deschide uneori automat (de exemplu, când Git îți cere un mesaj de commit). Dacă ai ajuns în el fără să vrei, apasă Esc, scrie :q! și Enter ca să ieși fără să salvezi, sau :wq ca să salvezi și să ieși. Ca să eviți surpriza, poți seta editorul implicit pentru Git cu git config --global core.editor nano.

Căutarea fișierelor și a textului

grep "ERROR" app.log                  # liniile care conțin ERROR
grep -i "eroare" app.log              # fără a ține cont de majuscule
grep -rn "calculeazaTotal" src/       # caută recursiv, cu numărul liniei
grep -v "DEBUG" app.log               # liniile care NU conțin DEBUG

find . -name "*.log"                  # fișierele .log din directorul curent și subdirectoare
find . -type d -name node_modules     # directoarele numite node_modules
find /tmp -type f -mtime +7           # fișierele modificate acum mai mult de 7 zile

Pentru căutări în proiecte mari de cod, mulți programatori folosesc rg (ripgrep), o alternativă mai rapidă la grep -r care ignoră automat fișierele din .gitignore. Pe Ubuntu se instalează cu sudo apt install ripgrep.

Pipe-uri și redirecționări

Puterea reală a terminalului vine din combinarea comenzilor mici. Operatorul | (pipe) trimite rezultatul unei comenzi ca input pentru următoarea.

# Cele mai frecvente 10 mesaje de eroare dintr-un log
grep "ERROR" app.log | sort | uniq -c | sort -rn | head -n 10

# Câte fișiere JavaScript sunt în proiect
find src -name "*.js" | wc -l

# Procesele care conțin "node" în nume
ps aux | grep node

Redirecționările trimit rezultatul într-un fișier:

Operator	Ce face	Exemplu
`>`	Scrie output-ul într-un fișier (îl suprascrie)	`ls > lista.txt`
`>>`	Adaugă output-ul la finalul fișierului	`echo "gata" >> jurnal.txt`
`2>`	Redirecționează erorile	`npm run build 2> erori.txt`
`2>&1`	Trimite erorile în același loc cu output-ul normal	`npm test > rezultat.txt 2>&1`
`&&`	Rulează a doua comandă doar dacă prima a reușit	`npm install && npm start`
`\|\|`	Rulează a doua comandă doar dacă prima a eșuat	`ping -c 1 server \|\| echo "indisponibil"`

Permisiuni

ls -l afișează permisiunile fiecărui fișier:

-rwxr-xr-- 1 ana dev 1024 mar 14 10:30 deploy.sh

Primul caracter indică tipul (- fișier, d director). Urmează trei grupuri de câte trei caractere: permisiunile pentru proprietar (rwx), pentru grup (r-x) și pentru ceilalți (r--). r înseamnă citire, w scriere, x execuție.

chmod +x deploy.sh        # face scriptul executabil
./deploy.sh               # îl rulează
chmod 644 config.json     # proprietarul citește și scrie; ceilalți doar citesc
chmod 600 ~/.ssh/id_ed25519   # doar proprietarul poate citi cheia privată
sudo chown ana:dev fisier.txt # schimbă proprietarul și grupul

Cifră	Permisiuni	Semnificație
7	`rwx`	citire, scriere, execuție
6	`rw-`	citire și scriere
5	`r-x`	citire și execuție
4	`r--`	doar citire
0	`---`	niciun drept

sudo rulează o comandă cu drepturi de administrator. Folosește-l doar când comanda chiar o cere (instalarea pachetelor, modificarea fișierelor de sistem), nu ca reflex când primești „Permission denied”.

Procese și porturi

ps aux                    # toate procesele care rulează
top                       # monitorizare în timp real (q pentru ieșire)
kill 4821                 # cere procesului cu PID 4821 să se oprească
kill -9 4821              # îl oprește forțat, doar dacă primul kill nu a mers

O situație foarte frecventă: pornești aplicația și primești o eroare că portul 3000 este deja folosit. Afli ce proces îl ocupă cu:

ss -tlnp | grep 3000
# sau
lsof -i :3000

Pentru procesele pornite din terminalul curent:

Scurtătură / comandă	Efect
Ctrl+C	Oprește procesul care rulează
Ctrl+Z	Suspendă procesul
`bg`	Continuă procesul suspendat în fundal
`fg`	Aduce procesul înapoi în prim-plan
`comanda &`	Pornește direct comanda în fundal
`jobs`	Listează procesele din fundal ale terminalului curent

htop este o variantă mai prietenoasă a lui top, cu culori și navigare cu săgețile. Pe Ubuntu se instalează cu sudo apt install htop.

Spațiu pe disc și informații despre sistem

df -h                     # spațiul liber pe fiecare partiție
du -sh *                  # dimensiunea fiecărui element din directorul curent
du -sh node_modules       # cât ocupă un director
free -h                   # memoria RAM folosită și liberă
uname -a                  # informații despre kernel
cat /etc/os-release       # distribuția și versiunea

Opțiunea -h (human-readable) afișează valorile în KB, MB și GB, nu în octeți.

Rețea și servere

curl https://api.example.com/produse            # face o cerere GET
curl -I https://example.com                     # doar header-ele răspunsului
curl -X POST https://api.example.com/produse \
  -H "Content-Type: application/json" \
  -d '{"nume": "Laptop", "pret": 3500}'         # cerere POST cu JSON

ping -c 4 example.com                           # verifică dacă un host răspunde
ssh ana@203.0.113.10                            # conectare la un server
scp backup.tar.gz ana@203.0.113.10:/home/ana/   # copiază un fișier pe server

Pentru conexiuni SSH fără parolă, generezi o pereche de chei cu ssh-keygen -t ed25519 și copiezi cheia publică pe server cu ssh-copy-id ana@203.0.113.10.

Instalarea pachetelor

Fiecare familie de distribuții are propriul manager de pachete:

# Debian, Ubuntu (inclusiv WSL implicit)
sudo apt update
sudo apt install git curl

# Fedora, RHEL
sudo dnf install git curl

apt update actualizează lista de pachete disponibile; nu instalează nimic. Rulează-l înainte de apt install, mai ales pe un sistem proaspăt instalat.

Variabile de mediu și personalizare

echo $HOME                    # afișează o variabilă
echo $PATH                    # directoarele în care shell-ul caută comenzi
export NODE_ENV=development   # setează o variabilă pentru sesiunea curentă
env                           # toate variabilele de mediu

O variabilă setată cu export dispare când închizi terminalul. Ca să fie permanentă, o adaugi în ~/.bashrc (sau ~/.zshrc pe zsh), împreună cu aliasurile tale:

alias ll='ls -la'
alias gs='git status'
export EDITOR=nano

După ce salvezi fișierul, aplici modificările cu source ~/.bashrc.

Primul tău script

Un script bash este doar un fișier text cu comenzi. Iată un exemplu care face o arhivă cu data curentă în nume:

#!/usr/bin/env bash
set -euo pipefail

sursa="$HOME/proiecte"
destinatie="$HOME/backup"
data=$(date +%Y-%m-%d)

mkdir -p "$destinatie"
tar -czf "$destinatie/proiecte-$data.tar.gz" -C "$sursa" .
echo "Backup creat: $destinatie/proiecte-$data.tar.gz"

Linia set -euo pipefail oprește scriptul la prima eroare, la folosirea unei variabile nedefinite sau la eșecul unei comenzi dintr-un pipe, ceea ce previne multe surprize neplăcute. Salvezi fișierul ca backup.sh, îl faci executabil cu chmod +x backup.sh și îl rulezi cu ./backup.sh.

Cum găsești ajutor

man grep          # manualul complet al comenzii
grep --help       # rezumatul opțiunilor

Paginile man sunt complete, dar lungi. Pentru exemple rapide, utilitarul tldr afișează cazurile de utilizare cele mai comune ale unei comenzi. Iar pentru detalii despre shell, manualul oficial Bash este referința de bază.

Scurtături care fac diferența

Scurtătură	Efect
Tab	Completare automată
Ctrl+R	Căutare în istoricul comenzilor
Ctrl+A / Ctrl+E	Salt la începutul / sfârșitul liniei
Ctrl+U	Șterge tot ce e înaintea cursorului
Ctrl+L	Curăță ecranul (la fel ca `clear`)
Ctrl+D	Închide sesiunea curentă (la fel ca `exit`)
`!!`	Repetă ultima comandă (de exemplu `sudo !!`)
Săgeată sus	Comanda anterioară din istoric

Pașii următori

Dacă ești pe Windows, instalează WSL și folosește terminalul Linux pentru toate proiectele tale de acum înainte.
Timp de o săptămână, încearcă să faci din terminal operațiile pe care le făceai din interfața grafică: creare de directoare, mutare de fișiere, căutare.
Scrie un script mic care automatizează ceva ce faci des, de exemplu pornirea proiectului sau curățarea fișierelor temporare.
Continuă cu roadmap-ul DevOps, unde terminalul devine unealta principală pentru servere, deploy și automatizare, sau cu Docker, care se folosește aproape exclusiv din linia de comandă.