...
Pregătire interviuri

100 de întrebări de interviu Git, cu răspunsuri

Întrebările despre Git care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Git: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 136 minde citit
Întrebări de interviu Git cu răspunsuri

La un interviu în care se verifică Git, primele întrebări sunt despre fundamente: cele trei zone (working tree, staging, repository), ce face un commit, ce e o ramură, cum diferă fetch de pull. Urmează aproape mereu scenarii: „ai împins un commit greșit”, „ai pierdut munca după un reset”, „PR-ul are conflicte”, „trebuie să livrezi un fix fără codul nou de pe main”. Unele firme cer să rulezi comenzile live într-un terminal sau să citești un git log --graph și să spui ce s-a întâmplat.

De la un junior se așteaptă fluxul zilnic fără greșeli: commit-uri curate, .gitignore corect, ramuri, merge, rezolvarea unui conflict, restore, reset și revert folosite potrivit, push și pull request. De la un mid se așteaptă rebase interactiv, cherry-pick, recuperare prin reflog, --force-with-lease, alegerea între merge, squash și rebase și înțelegerea modelului de date (blob, tree, commit, refs). Întrebările senior ating procesul echipei: protecția ramurilor, trunk-based development cu feature flags, repository-uri mari, secrete commituite din greșeală și recuperarea după incidente.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi răspunsul scurt și spune-l cu voce tare, apoi compară cu explicația detaliată. Cel mai mult înveți dacă rulezi exemplele într-un repository de test (git init demo) și îl strici intenționat: un reset sau un rebase recuperat o dată cu reflog-ul nu te mai sperie la interviu. Comenzile sunt pentru Git 2.40 sau mai nou; unde o opțiune a apărut mai târziu, versiunea e menționată.

Modelul de date și cele trei zone

1 Junior

Ce este Git și prin ce diferă un sistem de control al versiunilor distribuit de unul centralizat, cum e SVN?

Răspuns scurt: Git este un sistem de control al versiunilor distribuit: fiecare clonă conține tot istoricul proiectului, nu doar ultima versiune. Poți face commit, vedea istoricul sau crea ramuri fără conexiune la server, iar serverul e doar o copie convenită ca sursă comună.

Într-un sistem centralizat (SVN, CVS, Perforce în modul clasic) istoricul stă pe un singur server. Pe calculatorul tău ai doar o copie de lucru a unei revizii. Ca să faci commit, să vezi istoricul sau să compari cu o versiune veche, ai nevoie de conexiune la server, iar dacă serverul cade, echipa e blocată.

În Git, git clone aduce tot repository-ul: toate commit-urile, ramurile și tag-urile. Consecințele practice:

  • commit, log, diff, branch, merge se fac local, deci sunt rapide și merg offline;
  • fiecare clonă e un backup complet al istoricului;
  • poți lucra cu mai multe remote-uri (de exemplu origin și upstream la un fork);
  • publicarea e un pas separat: git push trimite commit-urile tale, git fetch le aduce pe ale altora.

Serverul (GitHub, GitLab, Bitbucket sau un server propriu) nu are un rol tehnic special: e doar repository-ul pe care echipa a convenit să-l considere sursa comună, plus funcții de colaborare (pull request-uri, CI, permisiuni). Git a fost creat în 2005 de Linus Torvalds pentru dezvoltarea kernelului Linux, unde contează tocmai lucrul în paralel al multor oameni fără un server central care să fie gâtuire.

Ce urmărește intervievatorul: Verifică dacă știi ce înseamnă „distribuit” în practică. Mulți candidați spun doar „Git e pentru versiuni” fără să explice că istoricul complet e local.

2 Junior

Care e diferența dintre Git, GitHub și GitLab?

Răspuns scurt: Git este unealta de control al versiunilor care rulează local, în linia de comandă. GitHub și GitLab sunt platforme care găzduiesc repository-uri Git și adaugă colaborare: pull/merge request-uri, code review, issues, CI/CD, permisiuni.

Git este programul: îl instalezi pe calculator, iar comenzile git init, git commit, git merge lucrează cu repository-ul din folderul .git. Funcționează complet fără internet și fără vreun cont.

GitHub, GitLab și Bitbucket sunt servicii care țin o copie a repository-ului pe un server și construiesc în jurul ei:

  • interfață web pentru cod, istoric și diferențe;
  • pull request (GitHub, Bitbucket) sau merge request (GitLab): cererea de a integra o ramură, cu discuție și review;
  • issues, proiecte, wiki;
  • CI/CD: GitHub Actions, GitLab CI/CD;
  • permisiuni, reguli de protecție a ramurilor, fork-uri.

Funcțiile acestea nu fac parte din Git. Un pull request nu există în repository: dacă muți proiectul de pe GitHub pe GitLab, istoricul Git vine cu el, dar discuțiile din PR-uri și issues rămân pe platforma veche (doar dacă nu folosești un import dedicat).

GitLab poate fi instalat și pe serverele firmei (self-managed), de aceea îl întâlnești des în companii cu cerințe stricte de securitate. Pentru interviu e suficient să arăți că separi clar unealta de platformă: „am făcut rebase” e Git, „am cerut review pe PR” e GitHub.

Ce urmărește intervievatorul: Întrebare de încălzire care separă pe cei care au folosit doar butoanele din interfața web de cei care înțeleg că Git e independent de platformă.

3 Junior

Explică cele trei zone din Git: working tree, staging area (index) și repository. De ce există zona de staging?

Răspuns scurt: Working tree sunt fișierele de pe disc pe care le editezi, staging area (index) e propunerea pentru următorul commit, iar repository-ul conține commit-urile salvate. Staging-ul te lasă să alegi exact ce intră într-un commit, chiar și doar o parte dintr-un fișier.

Fluxul de bază trece prin trei locuri:

  • working tree (directorul de lucru): fișierele așa cum le vezi în editor;
  • index sau staging area: un fișier binar, .git/index, care descrie conținutul următorului commit;
  • repository: obiectele și commit-urile din .git, adică istoricul.
BASH
# editezi app.js -> modificarea e doar în working tree
git add app.js        # copiază versiunea curentă în index
git commit -m "..."   # creează un commit din ce e în index

Un detaliu important: indexul conține toată structura proiectului, nu doar modificările. După un commit, indexul e identic cu commit-ul; git add actualizează în el doar fișierele adăugate.

De ce există? Pentru că rareori vrei să salvezi tot ce ai atins. Ai reparat un bug și, în același timp, ai lăsat un console.log de test: adaugi în index doar reparația și faci un commit curat. Cu git add -p poți alege chiar bucăți (hunks) dintr-un fișier.

Comenzile care compară zonele:

  • git diff: working tree față de index;
  • git diff --staged: index față de ultimul commit;
  • git status: rezumatul ambelor.

Dacă modifici fișierul după git add, în commit intră versiunea din momentul add, nu cea de acum.

Ce urmărește intervievatorul: Este fundamentul tuturor comenzilor de anulare. Greșeala tipică: candidatul crede că git add „salvează” sau că staging-ul conține doar diferențe.

Eroarea, în practică:nothing to commit, working tree cleannothing added to commit but untracked files present

4 Junior

Ce înseamnă fiecare linie din rezultatul de mai jos?

$ git status -s
 M src/app.js
M  README.md
MM src/util.js
A  src/nou.js
?? notite.txt
 D vechi.txt

Răspuns scurt: Prima coloană e starea în index, a doua în working tree. M modificat neadăugat, M pus în staging, MM pus în staging și apoi modificat iar, A fișier nou adăugat, ?? neurmărit, D șters de pe disc, dar nu din index.

Formatul scurt are două coloane, X și Y: X compară indexul cu HEAD, Y compară working tree-ul cu indexul.

  • M src/app.js: fișierul e modificat pe disc, dar modificarea nu e în staging. git commit nu o va include.
  • M README.md: modificarea e în staging, iar pe disc fișierul e identic cu indexul. Intră în commit.
  • MM src/util.js: ai dat git add, apoi ai mai modificat fișierul. Commit-ul va conține versiunea din momentul add; ce ai scris după apare în git diff.
  • A src/nou.js: fișier nou, adăugat în index pentru prima dată.
  • ?? notite.txt: fișier neurmărit (untracked); Git nu știe de el.
  • D vechi.txt: l-ai șters cu rm, dar ștergerea nu e în staging. Cu git rm vechi.txt sau git add vechi.txt ștergerea trece în index (D ).

Alte coduri utile: R redenumit, U conflict nerezolvat (de exemplu UU), !! ignorat (doar cu --ignored).

Varianta git status -sb adaugă pe prima linie ramura și cât e înainte sau în urmă față de upstream, de exemplu ## main...origin/main [ahead 2]. Acest format e potrivit și pentru scripturi; pentru un format garantat stabil între versiuni se folosește git status --porcelain.

Ce urmărește intervievatorul: Verifică dacă ai lucrat efectiv în terminal și înțelegi că un fișier poate fi simultan în două stări. Cazul MM îi încurcă pe cei care cred că git add se aplică automat la commit.

Eroarea, în practică:nothing added to commit but untracked files present

5 Junior

Ce face git init și ce găsești în folderul .git?

Răspuns scurt: git init creează un repository gol: folderul ascuns .git cu baza de date de obiecte, referințele (ramuri, tag-uri), fișierul HEAD și configurația locală. Fișierele proiectului nu sunt atinse și nici urmărite până nu le adaugi.

git init transformă folderul curent în working tree-ul unui repository nou. Nu adaugă nimic în istoric și nu modifică fișierele existente; ele apar ca untracked până la git add.

Conținutul important din .git:

  • objects/: baza de date cu toate obiectele (blob, tree, commit, tag), adresate prin hash;
  • refs/heads/: ramurile locale, fiecare fiind un fișier care conține un hash de commit;
  • refs/tags/ și refs/remotes/: tag-urile și ramurile remote-urilor;
  • HEAD: unde ești acum, de obicei ref: refs/heads/main;
  • index: zona de staging;
  • config: setările acestui repository (remote-uri, setări locale);
  • hooks/: scripturi exemplu care pot rula la anumite evenimente.

Numele ramurii inițiale vine din init.defaultBranch (opțiune apărută în Git 2.28); fără setare, multe versiuni folosesc încă master și afișează un avertisment.

BASH
git init proiect          # creează folderul și repository-ul
git init -b main          # alege direct numele ramurii
git init --bare server.git  # repository fără working tree, pentru server

Consecința practică: tot istoricul e în .git. Dacă îl ștergi, proiectul rămâne doar cu fișierele curente. Dacă copiezi folderul cu tot cu .git, copiezi tot istoricul. Nu rula git init în folderul home: tot ce e acolo devine un repository uriaș.

Ce urmărește intervievatorul: Arată dacă știi unde trăiește istoricul. Candidații care au rulat doar git clone adesea nu știu că un repository e doar un folder .git.

Eroarea, în practică:fatal: not a git repositoryUsing 'master' as the name for the initial branch

6 Junior

Ce este hash-ul unui commit, din ce se calculează și de ce spunem că istoricul Git e imuabil?

Răspuns scurt: Hash-ul (SHA-1, 40 de caractere hex) se calculează din conținutul commit-ului: arborele de fișiere, părinții, autorul, data și mesajul. Orice modificare produce alt hash, deci un commit existent nu poate fi schimbat, doar înlocuit cu unul nou.

Git e o bază de date adresată prin conținut: cheia fiecărui obiect e hash-ul conținutului său. Pentru un commit, conținutul arată așa:

tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
parent 8f3a1c2...
author Ana Pop <ana@exemplu.ro> 1730370000 +0200
committer Ana Pop <ana@exemplu.ro> 1730370000 +0200

Adaugă validarea emailului

Pentru că hash-ul părintelui intră în calcul, fiecare commit „sigilează” tot istoricul de dinaintea lui. Dacă schimbi un singur caracter dintr-un commit vechi, îi schimbi hash-ul, apoi al copilului lui și tot așa până la vârf. De aceea --amend, rebase sau filter-repo nu modifică commit-uri: creează commit-uri noi, iar cele vechi rămân în baza de date până le șterge garbage collection.

Consecințe practice:

  • două repository-uri cu același hash de vârf au garantat același istoric;
  • rescrierea istoricului deja publicat obligă colegii să se resincronizeze;
  • poți folosi prefixe scurte (git show 8f3a1c2) cât timp sunt neambigue.

Implicit Git folosește SHA-1, într-o variantă întărită împotriva atacului de coliziune cunoscut (SHAttered). Începând cu Git 2.29 există și formatul de obiecte SHA-256 (git init --object-format=sha256), dar compatibilitatea cu platformele de găzduire e încă limitată.

Ce urmărește intervievatorul: Verifică înțelegerea de ce rescrierea istoricului creează commit-uri noi. Fără asta, regula „nu rescrie istoric public” rămâne o regulă memorată.

7 Junior

Cum îți configurezi identitatea în Git și ce diferență e între --global, --local și --system?

Răspuns scurt: Setezi user.name și user.email cu git config. --system se aplică tuturor utilizatorilor mașinii, --global utilizatorului tău, --local doar repository-ului curent; nivelul mai specific câștigă.

Fiecare commit înregistrează numele și emailul autorului, așa că primul lucru pe un calculator nou este:

BASH
git config --global user.name "Ana Pop"
git config --global user.email "ana@exemplu.ro"

Nivelurile de configurare, de la general la specific:

  • --system: fișierul de sistem (de exemplu /etc/gitconfig), pentru toți utilizatorii;
  • --global: ~/.gitconfig sau ~/.config/git/config, pentru utilizatorul tău;
  • --local (implicit când ești într-un repository): .git/config.

Valoarea de la nivelul cel mai specific o suprascrie pe cea generală. Un caz frecvent: pe laptopul de serviciu ai emailul firmei global, iar într-un proiect personal setezi local alt email:

BASH
cd proiect-personal
git config user.email "ana.personal@exemplu.ro"
git config --list --show-origin   # vezi de unde vine fiecare valoare

Pentru multe proiecte se poate folosi includeIf în ~/.gitconfig, care încarcă automat altă configurație pentru toate repository-urile dintr-un folder.

De ce contează emailul: GitHub și GitLab leagă commit-urile de contul tău după email. Dacă emailul e greșit, commit-urile nu apar pe profil și nu sunt atribuite corect. Pentru a corecta ultimul commit: git commit --amend --reset-author --no-edit. Pentru commit-uri mai vechi, deja publicate, corectarea înseamnă rescrierea istoricului, deci de obicei nu merită.

Ce urmărește intervievatorul: Întrebare simplă, dar arată dacă ai configurat Git de mână. Mulți nu știu de nivelul local și ajung cu emailul firmei pe proiecte personale.

Eroarea, în practică:Please tell me who you areerror: key does not contain a section

8 Junior

Git stochează diferențele dintre versiuni sau versiuni complete ale fișierelor?

Răspuns scurt: Conceptual, fiecare commit e un snapshot complet al proiectului: arborele tuturor fișierelor. Fișierele nemodificate nu se copiază, ci sunt referite prin același hash. Diferențele pe care le vezi în git diff sunt calculate la cerere.

Multe sisteme mai vechi (CVS, SVN în stocare) țin fiecare fișier ca un șir de diferențe. Git gândește altfel: un commit indică un tree, iar tree-ul descrie starea completă a proiectului în acel moment.

Asta nu înseamnă că fiecare commit copiază totul. Conținutul unui fișier e un blob identificat prin hash. Dacă README.md nu s-a schimbat în 50 de commit-uri, toate cele 50 de tree-uri indică același blob, stocat o singură dată.

Diferențele apar doar când le ceri:

BASH
git diff HEAD~1 HEAD     # Git compară cele două snapshot-uri
git show HEAD            # afișează diferența față de părinte

Avantajele modelului:

  • trecerea la orice commit e directă: Git citește tree-ul, nu aplică sute de diferențe;
  • compararea a două commit-uri oarecare e simplă;
  • redenumirile nu trebuie înregistrate: Git le deduce comparând conținutul.

Pe disc, Git economisește spațiu și altfel: obiectele sunt comprimate cu zlib, iar la git gc sau la transfer sunt împachetate în packfiles, unde versiuni asemănătoare se stochează ca delta una față de alta. Aceste delte sunt o optimizare de stocare, nu modelul logic: pentru tine, ca utilizator, un commit rămâne un snapshot complet.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul mental corect. Răspunsul „stochează diferențe” e greșeala clasică și duce la confuzii la rebase și cherry-pick.

9 Mid

Care sunt cele patru tipuri de obiecte din Git și cum le poți inspecta direct?

Răspuns scurt: Blob (conținutul unui fișier), tree (un director: nume, permisiuni și hash-uri de blob-uri sau tree-uri), commit (un tree, părinți, autor, mesaj) și tag adnotat (un obiect care indică un alt obiect, cu mesaj și autor). Le inspectezi cu git cat-file -t și -p.

Toate obiectele stau în .git/objects și sunt identificate prin hash-ul conținutului.

  • blob: doar conținutul unui fișier, fără nume și fără permisiuni. Două fișiere identice în foldere diferite sunt același blob.
  • tree: lista unui director. Fiecare intrare are mod (100644 fișier, 100755 executabil, 040000 director, 120000 link simbolic), tip, hash și nume.
  • commit: hash-ul tree-ului rădăcină, zero sau mai mulți părinți, autor, committer și mesaj.
  • tag adnotat: indică un obiect (de obicei un commit) și are nume, autor, dată, mesaj și opțional semnătură.
BASH
git cat-file -t HEAD            # commit
git cat-file -p HEAD            # tree, parent, author, mesaj
git cat-file -p HEAD^{tree}     # conținutul directorului rădăcină
git cat-file -p HEAD:src/app.js # blob-ul fișierului din acel commit
git rev-parse HEAD:src/app.js   # doar hash-ul lui

Primul commit dintr-un repository nu are părinte, un commit de merge are doi (sau mai mulți). Numele fișierului stă în tree, nu în blob, de aceea o redenumire fără modificare de conținut creează un tree nou, dar refolosește blob-ul.

Ramurile și tag-urile ușoare (lightweight) nu sunt obiecte: sunt referințe, adică fișiere text care conțin un hash. Asta explică de ce crearea unei ramuri e instantanee.

Ce urmărește intervievatorul: Separă candidații care au citit cum funcționează Git de cei care știu doar comenzi. Greșeala frecventă: a crede că blob-ul conține și numele fișierului.

10 Mid

Ce sunt referințele (refs) în Git și ce este, concret, o ramură?

Răspuns scurt: O referință e un nume care indică un hash: ramurile stau în refs/heads/, tag-urile în refs/tags/, ramurile de pe remote în refs/remotes/. O ramură e doar un fișier cu hash-ul ultimului ei commit, care se mută automat când faci commit pe ea.

Hash-urile sunt greu de ținut minte, așa că Git le dă nume prin refs:

  • refs/heads/main: ramura locală main;
  • refs/tags/v1.2.0: un tag;
  • refs/remotes/origin/main: ultima stare cunoscută a ramurii main de pe origin;
  • referințe speciale: HEAD, ORIG_HEAD (poziția dinainte de reset, merge sau rebase), FETCH_HEAD, MERGE_HEAD.
BASH
cat .git/refs/heads/main        # 8f3a1c2... (dacă nu e împachetată)
git rev-parse main              # metoda sigură
git show-ref                    # toate referințele
git update-ref refs/heads/test HEAD  # creează o ramură „de mână”

Pentru performanță, Git poate muta referințele în fișierul .git/packed-refs, de aceea nu te baza pe citirea directă a fișierelor; folosește rev-parse sau show-ref.

Ce înseamnă asta în practică:

  • o ramură nu „conține” commit-uri, ci indică un commit; commit-urile ramurii sunt cele accesibile pornind de la el prin părinți;
  • ștergerea unei ramuri șterge doar eticheta; commit-urile rămân până la garbage collection și pot fi recuperate prin reflog;
  • git commit creează un commit nou și mută referința ramurii curente pe el;
  • un tag e o referință care, prin convenție, nu se mută.

Ce urmărește intervievatorul: Verifică modelul mental care face ușor de înțeles merge-ul, reset-ul și recuperarea ramurilor. Candidații care văd ramura ca pe o „copie a codului” se încurcă la reset.

Eroarea, în practică:fatal: not a valid object name: 'main'cannot lock ref: 'refs/heads/feature' exists

11 Mid

Ce este HEAD și ce înseamnă HEAD~2, HEAD^2 și main@{1}? Ce arată fiecare comandă de mai jos într-un repository unde ultimul commit e un merge?

BASH
git show HEAD^1
git show HEAD^2
git show HEAD~2

Răspuns scurt: HEAD e poziția curentă, de obicei prin ramura pe care ești. ~n merge n generații înapoi pe primul părinte, ^n alege al n-lea părinte al unui merge, main@{1} e poziția anterioară din reflog. La un merge, HEAD^2 e vârful ramurii integrate.

HEAD este de obicei o referință simbolică: fișierul .git/HEAD conține ref: refs/heads/main. Când faci commit, Git mută main, iar HEAD îl urmează. Dacă HEAD conține direct un hash, ești în „detached HEAD”.

Notațiile relative:

  • HEAD~1 (sau HEAD~): primul părinte; HEAD~2: primul părinte al primului părinte, deci bunicul pe linia principală;
  • HEAD^1 (sau HEAD^): tot primul părinte; HEAD^2: al doilea părinte, care există doar la un commit de merge;
  • se pot combina: HEAD^2~1 e părintele vârfului ramurii integrate.

Într-un merge făcut cu git merge feature stând pe main:

  • HEAD^1 e commit-ul pe care era main înainte de merge;
  • HEAD^2 e vârful lui feature;
  • HEAD~2 merge pe linia lui main, ignorând commit-urile din feature.

Notațiile cu @{} folosesc reflog-ul local:

  • main@{1}: unde era main înainte de ultima mișcare;
  • HEAD@{2}: a doua poziție anterioară a lui HEAD;
  • main@{yesterday}: unde era ramura ieri, pe acest calculator;
  • @{u}: upstream-ul ramurii curente, de exemplu origin/main.

Atenție în zsh: ^ poate fi interpretat de shell, așa că pune expresia între ghilimele (git show "HEAD^2").

Ce urmărește intervievatorul: Testează dacă poți naviga precis prin istoric, lucru necesar la reset, rebase și revert pe merge. Confuzia dintre ~ și ^ e foarte frecventă.

Eroarea, în practică:You are in 'detached HEAD' stateambiguous argument: unknown revision or path

12 Senior

Dacă Git salvează snapshot-uri complete, cum rămâne folderul .git mic? Ce fac packfiles și git gc, și cum detectează Git redenumirile?

Răspuns scurt: Obiectele sunt comprimate și, la gc sau la transfer, împachetate în packfiles, unde versiuni asemănătoare se stochează ca delta una față de alta. gc mai șterge obiectele neaccesibile vechi. Redenumirile nu sunt stocate: Git le deduce la afișare, comparând similaritatea conținutului.

Un obiect nou e scris inițial ca loose object: un fișier comprimat cu zlib în .git/objects/ab/cdef.... Pentru mii de commit-uri ar fi ineficient, așa că Git îl împachetează:

  • un packfile (.pack) conține multe obiecte, iar un fișier .idx permite căutarea rapidă;
  • în pachet, un obiect poate fi stocat ca delta față de alt obiect asemănător, nu neapărat față de versiunea anterioară a aceluiași fișier; Git alege bazele după euristici (tip, nume, dimensiune);
  • git push și git fetch trimit tot packfiles, cu delte, de aceea transferul e eficient.

git gc (rulat automat din când în când de comenzi obișnuite) împachetează obiectele, comprimă referințele în packed-refs, curăță reflog-ul expirat și șterge obiectele neaccesibile mai vechi decât gc.pruneExpire (implicit două săptămâni). În versiunile recente, git maintenance poate rula aceste sarcini programat, plus commit-graph pentru log rapid.

BASH
git count-objects -vH    # câte obiecte loose și cât ocupă pachetele
git verify-pack -v .git/objects/pack/*.idx | sort -k3 -n | tail

Redenumirile nu există în model: un commit are doar un tree nou. La diff, log sau merge, Git caută perechi șterse și adăugate cu conținut asemănător; implicit pragul e 50% similaritate (-M50%). git log --follow fisier urmărește un singur fișier peste redenumiri. Dacă în același commit redenumești și rescrii masiv un fișier, detecția eșuează și istoricul pare întrerupt, de aceea se recomandă commit-uri separate pentru mutare și modificare.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a internelor, utilă la depanarea repository-urilor mari. Candidații seniori ar trebui să explice și de ce mutarea plus rescrierea în același commit strică blame și log --follow.

Commit-uri, diff și istoric

13 Junior

Ce înseamnă un commit bun? Scrie un exemplu de mesaj de commit bine făcut.

Răspuns scurt: Un commit bun e atomic (o singură schimbare logică, care compilează și trece testele) și are un mesaj clar: un subiect scurt la imperativ, iar în corp de ce s-a făcut schimbarea. Așa istoricul poate fi citit, revizuit și anulat bucată cu bucată.

Criteriile pe care le caută un intervievator:

  • atomic: o singură schimbare logică. Nu amesteci repararea unui bug cu o reformatare a întregului fișier;
  • complet: proiectul compilează și testele trec după fiecare commit; asta face posibile bisect și revert fără surprize;
  • mesaj care explică de ce: diff-ul arată deja ce s-a schimbat.

Convenția clasică de format:

Corectează calculul TVA pentru facturile în euro

Cursul BNR era aplicat de două ori când factura avea
moneda EUR și client din România. Calculul se face acum
o singură dată, în FacturaService, iar testul nou acoperă
cazul care producea dublarea.

Refs: #482

Reguli practice:

  • subiectul are în jur de 50 de caractere, maxim 72, fără punct la final;
  • imperativ, ca o comandă: „Adaugă”, „Corectează”, nu „Am adăugat”;
  • o linie goală între subiect și corp; corpul rupt la circa 72 de caractere;
  • referința la ticket sau issue, dacă echipa o cere.

Mesaje de evitat: „fix”, „update”, „wip”, „modificări”. Peste șase luni, cineva care rulează git blame pe o linie ciudată trebuie să găsească în mesaj motivul. Dacă ai lucrat dezordonat, poți curăța commit-urile înainte de PR cu rebase interactiv.

Ce urmărește intervievatorul: Arată disciplina de lucru în echipă. Candidații juniori spun des „commit des” fără să explice ce face un commit util pentru review și depanare.

Eroarea, în practică:Aborting commit due to empty commit messageerror: switch `m' requires a value

14 Junior

Ce este Conventional Commits și de ce îl folosesc unele echipe?

Răspuns scurt: Conventional Commits e o convenție de mesaje de forma tip(scope): descriere, de exemplu feat(auth): adaugă login cu Google. Tipurile standard (feat, fix, plus marcajul de breaking change) permit generarea automată a changelog-ului și a numărului de versiune.

Formatul de bază:

<tip>[(scope)][!]: <descriere>

[corp opțional]

[footer opțional, de ex. BREAKING CHANGE: ...]

Exemple:

feat(cos): permite aplicarea a două coduri de reducere
fix(api): returnează 404 în loc de 500 pentru produs lipsă
docs: actualizează pașii de instalare
refactor!: elimină endpointul /v1/comenzi

Specificația definește explicit feat (funcționalitate nouă) și fix (corectare de bug); restul tipurilor (docs, style, refactor, test, chore, ci, build, perf) vin din convenții răspândite, de exemplu cea folosită de commitlint. Un ! după tip sau footer-ul BREAKING CHANGE: marchează o schimbare incompatibilă.

De ce merită:

  • versionare semantică automată: fix crește versiunea patch, feat minor, breaking change major; unelte ca semantic-release sau release-please fac asta din istoric;
  • changelog generat automat, grupat pe tipuri;
  • istoric ușor de filtrat: git log --oneline --grep "^fix";
  • review mai rapid, pentru că tipul spune din titlu ce fel de schimbare urmează.

Convenția se impune de obicei cu un hook commit-msg (de exemplu commitlint rulat prin husky) sau verificând titlul PR-ului în CI, când echipa folosește squash merge. Dezavantajul: e încă o regulă de învățat, iar fără unelte care o folosesc devine doar formalitate.

Ce urmărește intervievatorul: Verifică dacă știi convenții reale din echipe. Un plus este legătura cu versionarea semantică, nu doar „arată frumos”.

15 Junior

Care e diferența dintre git diff, git diff --staged și git diff HEAD?

Răspuns scurt: git diff compară working tree-ul cu indexul (ce n-ai adăugat încă), git diff --staged compară indexul cu ultimul commit (ce va intra în commit), iar git diff HEAD compară working tree-ul cu ultimul commit (toate modificările, adăugate sau nu).

Cele trei comenzi compară perechi diferite de zone:

git diff            working tree  vs  index
git diff --staged   index         vs  HEAD    (sinonim: --cached)
git diff HEAD       working tree  vs  HEAD

Exemplu concret: modifici app.js, dai git add app.js, apoi mai adaugi o linie.

  • git diff arată doar linia adăugată după add;
  • git diff --staged arată modificările din momentul add, adică exact ce va conține commit-ul;
  • git diff HEAD arată ambele.

O greșeală frecventă: rulezi git diff după git add ., nu vezi nimic și crezi că nu ai modificări. De fapt totul e în staging și trebuie --staged.

Opțiuni utile:

BASH
git diff --stat             # doar fișierele și numărul de linii
git diff --name-only        # doar numele fișierelor
git diff -w                 # ignoră diferențele de spații
git diff --word-diff        # diferențe la nivel de cuvânt, util pentru text
git diff main -- src/       # doar un folder, față de altă ramură

Fișierele untracked nu apar în niciun git diff, pentru că nu există nici în index, nici în HEAD. Obiceiul bun înainte de fiecare commit: git diff --staged, ca să verifici că nu trimiți loguri de test sau parole.

Ce urmărește intervievatorul: Testează înțelegerea practică a celor trei zone. Mulți candidați cunosc doar git diff și nu știu cum văd ce intră efectiv în commit.

16 Junior

Ce include git commit -am "mesaj" și ce lasă pe dinafară?

Răspuns scurt: Opțiunea -a pune automat în staging toate fișierele deja urmărite care au fost modificate sau șterse, apoi face commit. Fișierele noi (untracked) nu sunt incluse, deci trebuie adăugate separat cu git add.

git commit -a echivalează aproximativ cu git add -u urmat de git commit: actualizează în index fișierele pe care Git le cunoaște deja.

BASH
echo "x" >> app.js        # fișier urmărit, modificat
rm vechi.js               # fișier urmărit, șters
touch nou.js              # fișier nou, untracked
git commit -am "Actualizează"
git status -s
# ?? nou.js               # a rămas pe dinafară

În commit intră modificarea din app.js și ștergerea lui vechi.js; nou.js rămâne neurmărit. E o capcană clasică: commit-ul compilează la tine, dar pe CI lipsește fișierul nou.

Când e potrivit -am:

  • modificări mici în fișiere existente, când știi exact ce ai atins;
  • după ce ai verificat cu git status că nu există fișiere noi relevante.

Când e de evitat:

  • când ai fișiere noi;
  • când ai modificări care nu țin de același commit, pentru că -a le ia pe toate; aici e mai bun git add -p, care te întreabă pentru fiecare bucată.

Alternative înrudite: git add . adaugă tot din folderul curent, inclusiv fișiere noi (respectând .gitignore), iar git add -A adaugă tot din repository. Indiferent de variantă, un git status înainte de commit evită majoritatea surprizelor.

Ce urmărește intervievatorul: Verifică atenția la detalii. Commit-ul căruia îi lipsește fișierul nou e o greșeală pe care intervievatorii au văzut-o des la juniori.

Eroarea, în practică:no changes added to commit

17 Junior

Care dintre fișierele de mai jos sunt ignorate de acest .gitignore?

*.log
/build
dist/
!important.log
**/temp/*.tmp

Fișiere: server.log, logs/important.log, build/app.js, src/build/x.js, src/dist/a.js, a/temp/b.tmp, a/temp/sub/c.tmp.

Răspuns scurt: Sunt ignorate server.log, build/app.js, src/dist/a.js și a/temp/b.tmp. Nu sunt ignorate logs/important.log (negat cu !), src/build/x.js (/build se aplică doar la rădăcină) și a/temp/sub/c.tmp (* nu trece de /).

Regulile care contează:

  • *.log: un tipar fără / se potrivește cu numele oriunde în arbore, deci server.log e ignorat;
  • !important.log: negarea reinclude fișierul, pentru că vine după *.log; ordinea liniilor contează, ultima regulă care se potrivește câștigă;
  • /build: / la început ancorează tiparul de folderul în care se află .gitignore, deci se ignoră doar build de la rădăcină, nu src/build;
  • dist/: / la final înseamnă „doar directoare” și, fără alt /, se potrivește la orice nivel, deci src/dist/ e ignorat;
  • **/temp/*.tmp: **/ înseamnă orice adâncime, dar * nu trece de /, așa că a/temp/sub/c.tmp nu se potrivește. Pentru toate nivelurile ar trebui /temp//*.tmp.

O capcană importantă: nu poți reinclude un fișier dacă un director părinte e exclus. Cu logs/ urmat de !logs/important.log, fișierul rămâne ignorat, pentru că Git nici nu intră în folder. Varianta corectă e logs/* plus !logs/important.log.

Ca să verifici în loc să ghicești:

BASH
git check-ignore -v src/dist/a.js
# .gitignore:3:dist/   src/dist/a.js

.gitignore poate exista în orice subfolder; pentru reguli personale (fișiere ale editorului) folosește .git/info/exclude sau un fișier global setat cu core.excludesFile.

Ce urmărește intervievatorul: Întrebare de cod tipică pentru Git. Capcanele / de la început, negarea în folder exclus și * față de ** arată dacă ai scris efectiv reguli sau doar ai copiat un template.

Eroarea, în practică:paths are ignored by one of your .gitignore files

18 Junior

Ai adăugat config.local.json în .gitignore, dar Git încă arată că fișierul e modificat. De ce și cum rezolvi?

Răspuns scurt: .gitignore afectează doar fișierele neurmărite. Fișierul a fost deja commituit, deci Git continuă să-l urmărească. Rulezi git rm --cached config.local.json și faci commit: fișierul rămâne pe disc, dar iese din repository.

Git verifică .gitignore doar când decide dacă un fișier nou apare ca untracked sau poate fi adăugat cu git add .. Un fișier deja în index și în istoric e urmărit indiferent de regulile de ignorare.

Soluția:

BASH
git rm --cached config.local.json   # scoate din index, păstrează pe disc
git commit -m "Nu mai urmări config.local.json"

Pentru un folder întreg: git rm -r --cached build/.

Ce trebuie să știi despre efecte:

  • fișierul rămâne în commit-urile vechi; dacă conține parole sau chei, rm --cached nu ajunge, trebuie rotite cheile și, eventual, rescris istoricul;
  • când colegii fac pull, Git vede o ștergere și le șterge fișierul de pe disc. Anunță-i sau păstrează un config.example.json urmărit, din care fiecare își creează varianta locală.

Alternativa des recomandată greșit este git update-index --assume-unchanged fișier: îi spune lui Git să nu mai verifice fișierul, ca optimizare de performanță, dar nu e o ignorare reală și se pierde la unele operații. Pentru „vreau fișierul în repo, dar modificările mele locale să nu apară” există --skip-worktree, tot cu limitări. Soluția curată rămâne un fișier exemplu urmărit și unul local ignorat.

Ce urmărește intervievatorul: Situație foarte frecventă la juniori. Intervievatorul vrea rm --cached și, ideal, observația despre colegii cărora li se șterge fișierul la pull.

Eroarea, în practică:paths are ignored by one of your .gitignore files

19 Junior

Scrie comanda care afișează compact commit-urile din ultimele 7 zile ale autoarei „Ana” care au atins folderul src/plati, cu graficul ramurilor.

Răspuns scurt: git log --oneline --graph --author="Ana" --since="7 days ago" -- src/plati. --author filtrează după autor (regex), --since după dată, iar calea de după -- limitează la commit-urile care modifică acel folder.

BASH
git log --oneline --graph --author="Ana" --since="7 days ago" -- src/plati

Ce face fiecare parte:

  • --oneline: hash scurt și subiectul pe o linie;
  • --graph: desenează ramurile și merge-urile în ASCII;
  • --author="Ana": regex aplicat pe nume și email; se pot da mai multe --author, combinate cu SAU;
  • --since="7 days ago": acceptă și date (2026-10-01) sau --until;
  • -- src/plati: limitează la commit-urile care modifică acea cale. -- separă clar căile de ramuri, util când un fișier are același nume ca o ramură.

Alte opțiuni pe care merită să le știi:

BASH
git log --oneline --graph --all          # toate ramurile, inclusiv remote
git log --stat -3                        # ultimele 3, cu fișierele modificate
git log -p -- src/plati/factura.js       # cu diff-ul complet
git log --follow -- src/plati/factura.js # urmărește și redenumirile
git log --no-merges main..feature        # doar commit-urile din feature
git log --pretty=format:"%h %an %ar %s"  # format personalizat
git shortlog -sn --since="1 month ago"   # numărul de commit-uri pe autor

Un alias des folosit:

BASH
git config --global alias.lg "log --oneline --graph --decorate --all"

Atenție la date: --since filtrează după data committer-ului, care după un rebase poate fi mai nouă decât data autorului afișată implicit în git log.

Ce urmărește intervievatorul: Verifică familiaritatea cu filtrarea istoricului, folosită zilnic la depanare. Candidații care știu doar git log simplu pierd timp derulând.

20 Mid

Ce face de fapt git commit --amend și când devine periculos?

Răspuns scurt: --amend nu modifică ultimul commit: creează unul nou, cu conținutul indexului și mesajul (eventual editat), care îl înlocuiește pe vârful ramurii. Hash-ul se schimbă, deci dacă vechiul commit era deja împins, ai rescris istoric public.

Cazuri tipice de folosire:

BASH
git commit --amend -m "Mesaj corectat"       # doar mesajul
git add uitat.js && git commit --amend --no-edit  # adaugi un fișier uitat
git commit --amend --reset-author --no-edit  # corectezi autorul

Intern, Git construiește un commit nou care are același părinte ca cel vechi, cu tree-ul din indexul curent, și mută ramura pe el. Commit-ul vechi nu dispare imediat: rămâne în reflog (HEAD@{1}), deci un amend greșit se poate anula:

BASH
git reset --soft HEAD@{1}

Când devine periculos:

  • dacă ai dat deja push, ramura locală și cea de pe server au divergat; un push normal va fi respins, iar push --force le strică istoria colegilor care au tras commit-ul vechi;
  • pe o ramură comună (main, develop) nu faci amend după push;
  • pe ramura ta de feature, singur, e acceptabil cu git push --force-with-lease, mai ales când echipa e obișnuită cu asta în PR-uri.

O capcană mai subtilă: --amend ia tot ce e în index. Dacă ai alte fișiere în staging fără să-ți dai seama, intră și ele în commit. Verifică git diff --staged înainte. Pentru corectarea unui commit mai vechi decât ultimul, unealta potrivită e git commit --fixup urmat de rebase interactiv cu --autosquash.

Ce urmărește intervievatorul: Verifică înțelegerea faptului că orice „modificare” a unui commit e de fapt o înlocuire. Mulți mid-uri folosesc amend zilnic fără să știe că pot reveni prin reflog.

Eroarea, în practică:fatal: You have nothing to amend.

21 Mid

Cum găsești commit-ul în care a apărut sau a dispărut o anumită funcție sau constantă din cod? Ce diferență e între git log -S, -G și --grep?

Răspuns scurt: git log -S text (pickaxe) găsește commit-urile care schimbă numărul de apariții ale textului, adică îl adaugă sau îl șterg. -G regex găsește commit-urile al căror diff conține linii modificate care se potrivesc cu regex-ul. --grep caută doar în mesajele de commit.

Trei căutări diferite:

BASH
git log -S "calculeazaTVA" --oneline          # când a apărut sau a dispărut
git log -G "TVA_[0-9]+" --oneline             # orice linie modificată cu tiparul
git log --grep "TVA" -i --oneline             # mesaje care conțin TVA

Diferența dintre -S și -G contează:

  • -S compară numărul de apariții înainte și după commit. Dacă o linie care conține calculeazaTVA e doar mutată sau modificată în altă parte, numărul nu se schimbă și commit-ul nu apare. E ideal pentru „când a fost adăugată sau ștearsă funcția”;
  • -G se uită la liniile adăugate sau șterse din diff. Prinde și modificările din linii care conțin tiparul, deci e mai larg;
  • -S acceptă și regex cu --pickaxe-regex.

Combinații utile:

BASH
git log -S "calculeazaTVA" -p -- src/         # vezi și diff-ul
git log -L :calculeazaTVA:src/factura.js      # istoria unei funcții
git log -L 40,60:src/factura.js               # istoria unor linii
git grep "calculeazaTVA" v1.4.0               # caută în codul dintr-un tag

git log -L e foarte util în debugging: arată fiecare commit care a modificat corpul funcției, cu diff-urile, fără să te uiți la tot fișierul. git grep caută în conținutul unei versiuni, nu în istoric, și e de obicei mai rapid decât grep -r, pentru că ignoră fișierele neurmărite.

Ce urmărește intervievatorul: Separă candidații care investighează istoricul eficient de cei care derulează manual git log -p. Diferența -S față de -G e un detaliu care arată experiență reală.

22 Mid

Cum vezi conținutul unui fișier așa cum era acum 10 commit-uri și cum îl readuci în working tree fără să schimbi ramura?

Răspuns scurt: Pentru vizualizare: git show HEAD~10:cale/fisier. Pentru restaurare: git restore --source=HEAD~10 cale/fisier (Git 2.23+) sau varianta veche git checkout HEAD~10 -- cale/fisier. Ramura și HEAD rămân pe loc; doar fișierul se schimbă.

Sintaxa rev:cale identifică un blob dintr-un commit:

BASH
git show HEAD~10:src/config.js            # afișează conținutul
git show v1.2.0:src/config.js > /tmp/vechi.js   # salvează-l separat
git diff HEAD~10 HEAD -- src/config.js    # doar diferențele

Calea e relativă la rădăcina repository-ului; pentru o cale relativă la folderul curent se scrie ./: git show HEAD~10:./config.js.

Pentru a readuce versiunea veche:

BASH
git restore --source=HEAD~10 src/config.js            # doar în working tree
git restore --source=HEAD~10 --staged --worktree src/config.js  # și în index
git checkout HEAD~10 -- src/config.js                 # varianta veche: index + working tree

Diferențele de efect:

  • restore --source fără --staged modifică doar fișierul de pe disc; apare ca M în git status;
  • checkout rev -- fișier modifică și indexul, deci fișierul apare direct în staging;
  • în ambele cazuri, ce aveai necommitted în acel fișier se pierde fără confirmare.

Apoi faci commit normal, cu un mesaj care explică readucerea. Spre deosebire de git revert, care anulează un commit întreg, metoda aceasta e potrivită când vrei doar un fișier dintr-o versiune anterioară, iar restul proiectului rămâne cum e.

Dacă nu știi în ce commit era versiunea bună, începe cu git log --oneline -- src/config.js, care listează doar commit-urile ce au atins fișierul.

Ce urmărește intervievatorul: Situație practică frecventă. Verifică dacă știi să lucrezi la nivel de fișier fără să muți HEAD sau să faci reset pe tot proiectul.

Eroarea, în practică:fatal: path does not exist in 'HEAD'

23 Mid

Ce înseamnă main..feature și main...feature în git log și în git diff? Diferă sensul între cele două comenzi?

Răspuns scurt: În log, main..feature înseamnă commit-urile din feature care lipsesc din main, iar main...feature pe cele aflate doar într-una dintre ramuri. În diff, .. echivalează cu două argumente, iar ... compară baza comună cu feature: doar ce a adus feature.

Pentru log, punctele lucrează cu mulțimi de commit-uri:

BASH
git log --oneline main..feature    # în feature, nu în main: ce va intra la merge
git log --oneline feature..main    # ce s-a adăugat pe main între timp
git log --oneline --left-right main...feature
# < a1b2c3 commit doar pe main
# > d4e5f6 commit doar pe feature

A..B e prescurtarea pentru ^A B: accesibil din B, dar nu din A. A...B e diferența simetrică.

Pentru diff, sensul e altul, pentru că diff-ul compară două snapshot-uri, nu mulțimi:

BASH
git diff main..feature     # identic cu: git diff main feature
git diff main...feature    # git diff $(git merge-base main feature) feature

Cazul practic: ramura ta a pornit din main acum o săptămână, iar între timp pe main au intrat alte modificări. git diff main feature arată și modificările colegilor, inversate, ca și cum le-ai fi șters. git diff main...feature arată doar ce ai schimbat tu, exact ce afișează un pull request pe GitHub.

Câteva forme înrudite:

  • git log origin/main..HEAD: ce ai local și nu ai împins încă;
  • git log HEAD..origin/main: ce au adus colegii după fetch;
  • git merge-base main feature: hash-ul strămoșului comun.

Ce urmărește intervievatorul: Notația e folosită constant, dar sensul diferit în log și diff îi prinde chiar și pe developerii cu experiență. Greșeala tipică: git diff main feature la review, care amestecă schimbările altora.

24 Senior

Într-o echipă cu Windows, macOS și Linux, la fiecare commit apar fișiere modificate integral, deși nimeni nu le-a schimbat. Ce se întâmplă și cum rezolvi pentru tot repository-ul?

Răspuns scurt: Aproape sigur sunt terminatorii de linie (CRLF pe Windows, LF pe Unix) sau bitul executabil. Soluția stabilă e un .gitattributes commituit, cu * text=auto și reguli explicite, urmat de git add --renormalize ., nu setări locale diferite.

Simptomul: git diff arată fiecare linie schimbată, dar textul pare identic. Cu git diff --stat vezi sute de linii; cu git diff -w sau cat -A vezi ^M la final, adică \r.

Cauza: editorii de pe Windows salvează cu CRLF, iar cei de pe Unix cu LF. Setarea core.autocrlf (true pe Windows, input pe Unix) ajută, dar e locală fiecărui developer și nu poate fi impusă.

Soluția la nivel de repository este .gitattributes:

* text=auto
*.sh   text eol=lf
*.bat  text eol=crlf
*.png  binary
*.pdf  binary
  • text=auto: Git detectează fișierele text și le stochează normalizate cu LF în repository;
  • eol=lf sau eol=crlf: forțează terminatorul la checkout, util pentru scripturi care nu pornesc altfel;
  • binary: fără conversie și fără diff textual.

După ce adaugi fișierul, normalizezi o singură dată:

BASH
git add --renormalize .
git commit -m "Normalizează terminatorii de linie"

Commit-ul acesta atinge multe linii, așa că îl adaugi în .git-blame-ignore-revs ca să nu strice blame, și îl anunți ca să nu creeze conflicte în ramurile deschise.

Cealaltă cauză frecventă e bitul executabil (old mode 100644, new mode 100755), din sisteme de fișiere care nu-l păstrează. Acolo se folosește core.fileMode false local, iar permisiunea corectă se setează explicit cu git update-index --chmod=+x script.sh.

Ce urmărește intervievatorul: Problemă reală de echipă, unde contează soluția la nivel de repository, nu „la mine merge”. Un candidat senior menționează renormalizarea și efectul asupra ramurilor deschise.

Eroarea, în practică:LF will be replaced by CRLF

Ramuri, HEAD și merge

Exersează capitolul cu exerciții reale: Curs Git online →
25 Junior

Ce este o ramură (branch) în Git și de ce crearea ei e practic instantanee?

Răspuns scurt: O ramură e o referință mobilă care indică un commit; la fiecare commit nou pe ramura curentă, referința avansează. Crearea ei înseamnă doar scrierea unui fișier mic cu un hash, nu copierea fișierelor, de aceea e instantanee indiferent de mărimea proiectului.

Mulți își imaginează o ramură ca pe o copie a proiectului. În Git, ramura e doar un nume pentru un commit:

BASH
git branch feature/login      # creează referința, pe commit-ul curent
cat .git/refs/heads/feature/login
# 8f3a1c2e...  (40 de caractere)

Commit-urile „ramurii” sunt cele accesibile pornind de la acel commit, mergând înapoi prin părinți. Același commit poate aparține simultan mai multor ramuri.

De ce contează modelul acesta:

  • crearea, ștergerea și redenumirea ramurilor sunt operații ieftine, deci poți avea câte o ramură pentru fiecare task, experiment sau bug;
  • git switch schimbă doar fișierele care diferă între cele două commit-uri;
  • un merge fast-forward înseamnă doar mutarea etichetei;
  • ștergerea unei ramuri nu șterge commit-uri; cele neintegrate devin neaccesibile, dar pot fi recuperate un timp prin reflog.

În SVN, o ramură era o copie a unui director pe server, iar crearea și integrarea erau operații rare și grele. Git a făcut ramurile o unealtă zilnică.

Ramura curentă e cea indicată de HEAD. git branch listează ramurile locale și o marchează cu * pe cea curentă; git branch -a include și ramurile remote-urilor.

Ce urmărește intervievatorul: Verifică modelul mental de bază. Dacă un candidat crede că ramura copiază fișierele, va avea dificultăți să înțeleagă merge-ul, reset-ul și recuperarea.

26 Junior

Care e diferența dintre git switch și git checkout? De ce a apărut switch?

Răspuns scurt: git switch (Git 2.23) face un singur lucru: schimbă ramura, iar switch -c creează una nouă. git checkout schimbă ramuri, dar și restaurează fișiere, ceea ce făcea ușor de confundat cele două operații. Pentru fișiere a apărut în paralel git restore.

git checkout are două roluri foarte diferite:

BASH
git checkout feature        # schimbă ramura
git checkout -b feature     # creează și schimbă
git checkout -- app.js      # aruncă modificările din app.js
git checkout a1b2c3         # detached HEAD pe un commit

Problema: git checkout nume poate însemna o ramură sau un fișier, în funcție de ce există. Dacă ai un fișier și o ramură cu același nume, sau greșești o literă, poți arunca modificări în loc să schimbi ramura.

Din Git 2.23 rolurile sunt separate:

BASH
git switch feature            # schimbă ramura
git switch -c feature/plata   # creează din HEAD și schimbă
git switch -c fix origin/fix  # creează din ramura remote, cu tracking
git switch -                  # revine la ramura anterioară
git switch --detach v1.2.0    # detached HEAD explicit

git restore app.js            # aruncă modificările din fișier
git restore --staged app.js   # scoate din staging

switch refuză să intre în detached HEAD fără --detach, ceea ce previne o confuzie frecventă la începători. Dacă ramura nu există local, dar există origin/feature, git switch feature o creează automat cu tracking.

checkout nu e eliminat și apare în multe tutoriale și scripturi vechi, așa că trebuie să-l recunoști. În cod nou și în explicații pentru colegi, switch și restore sunt mai clare.

Ce urmărește intervievatorul: Verifică dacă folosești Git modern și înțelegi de ce comenzile au fost separate. Un candidat care explică riscul ambiguității cu checkout a avut probabil o surpriză reală.

Eroarea, în practică:missing branch or commit argument

27 Junior

Când face Git un merge fast-forward? Ce se întâmplă cu istoricul în acest caz?

Răspuns scurt: Fast-forward are loc când ramura pe care ești nu are commit-uri noi față de punctul din care a pornit ramura integrată. Git doar mută referința înainte, pe vârful celeilalte ramuri, fără commit de merge, iar istoricul rămâne liniar.

Situația înainte de merge:

main:     A---B
               \
feature:        C---D

main e încă pe B, strămoșul lui D. Pentru a include C și D, Git nu trebuie să combine nimic: mută eticheta main pe D.

BASH
git switch main
git merge feature
# Updating b2c3d4e..d4e5f6a
# Fast-forward

După:

main, feature:  A---B---C---D

Caracteristici:

  • nu se creează un commit nou și nu pot apărea conflicte;
  • istoricul e liniar, ca și cum ai fi lucrat direct pe main;
  • dispare informația că a existat o ramură separată; nu mai poți spune ulterior ce commit-uri au venit împreună din acel feature.

Dacă între timp cineva a făcut commit pe main (de exemplu E după B), fast-forward nu mai e posibil și Git face un three-way merge, cu un commit de merge.

Același mecanism apare la git pull când nu ai commit-uri locale: ramura ta e doar avansată la origin/main. Opțiunile --ff-only și --no-ff controlează explicit comportamentul. Pentru a vedea dacă un merge va fi fast-forward, verifică dacă git log feature..main e gol.

Ce urmărește intervievatorul: Întrebare clasică. Intervievatorul vrea condiția exactă (ramura curentă e strămoș) și consecința asupra istoricului.

Eroarea, în practică:Not possible to fast-forward, abortingYour branch is behind 'origin/main'

28 Junior

Ce este un three-way merge și ce rol are merge base?

Răspuns scurt: Când ambele ramuri au commit-uri noi, Git compară trei versiuni: strămoșul comun (merge base) și vârfurile celor două ramuri. Modificările fiecărei ramuri față de bază se combină automat, iar rezultatul devine un commit de merge cu doi părinți.

Situația:

          C---D   feature
         /
A---B---E---F     main

Merge base este B, ultimul commit comun. Pentru fiecare fișier, Git se uită la trei versiuni:

  • baza (B);
  • ours: vârful ramurii curente (F);
  • theirs: vârful ramurii integrate (D).

Regula, aplicată pe bucăți de text:

  • dacă doar o ramură a schimbat o zonă față de bază, se ia schimbarea ei;
  • dacă ambele au făcut aceeași schimbare, se ia o dată;
  • dacă ambele au schimbat diferit aceeași zonă, apare conflict.

De aceea baza e esențială: comparând doar F și D, Git n-ar ști cine a adăugat și cine a șters o linie.

BASH
git merge-base main feature   # afișează B
git switch main
git merge feature             # creează commit-ul de merge M
          C---D
         /     \
A---B---E---F---M   main

M are doi părinți: F (primul, ramura pe care erai) și D. Asta păstrează explicit faptul că a existat o ramură, iar git log --first-parent main arată doar commit-urile de pe linia principală, câte unul pentru fiecare feature integrat.

Implicit, Git folosește strategia ort (din Git 2.34; înainte recursive), care tratează și cazurile cu mai multe merge base-uri.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce unele merge-uri trec automat și altele nu. Candidații care nu știu de merge base nu pot explica de ce apare un conflict.

Eroarea, în practică:CONFLICT (content): Merge conflict inrefusing to merge unrelated histories

29 Junior

Ce fac git merge --no-ff și git merge --ff-only și când ai folosi fiecare?

Răspuns scurt: --no-ff creează mereu un commit de merge, chiar dacă fast-forward era posibil, ca să păstreze vizibil grupul de commit-uri al ramurii. --ff-only acceptă doar fast-forward și eșuează altfel, ca să nu apară merge-uri neplanificate.

Cele două opțiuni sunt opuse.

--no-ff forțează commit de merge:

BASH
git switch main
git merge --no-ff feature/plata -m "Merge feature/plata"
A---B-------M   main
     \     /
      C---D     feature/plata

Avantaje: istoricul arată clar că C și D au venit împreună; git revert -m 1 M anulează tot feature-ul dintr-o dată; git log --first-parent arată doar merge-urile. Git flow îl folosește la integrarea ramurilor de feature.

--ff-only refuză orice merge real:

BASH
git merge --ff-only origin/main
# fatal: Not possible to fast-forward, aborting.

E util când vrei doar să aduci ramura la zi și nu te aștepți la commit-uri locale; dacă ai, preferi să le rebazezi conștient. Mulți setează:

BASH
git config --global pull.ff only

astfel încât git pull să nu creeze în mod surprinzător commit-uri „Merge branch 'main' of ...”.

Varianta implicită (fără opțiuni) face fast-forward când poate și merge real altfel. Pe GitHub, butonul „Create a merge commit” se comportă ca --no-ff, iar „Rebase and merge” și „Squash and merge” produc istoric liniar. Alegerea ține de convenția echipei: important e să fie consecventă.

Ce urmărește intervievatorul: Verifică dacă știi să controlezi forma istoricului. Un candidat bun leagă --ff-only de evitarea merge-urilor automate la pull.

Eroarea, în practică:You have divergent branchesNot possible to fast-forward, aborting

30 Junior

Cum ștergi o ramură local și pe server? Ce diferență e între git branch -d și -D?

Răspuns scurt: Local: git branch -d nume șterge doar dacă ramura e integrată, iar -D șterge forțat, chiar dacă are commit-uri neintegrate. Pe server: git push origin --delete nume. Ștergerea elimină doar referința; commit-urile se pot recupera un timp prin reflog.

BASH
git branch -d feature/login
# error: the branch 'feature/login' is not fully merged.
git branch -D feature/login     # forțat
# Deleted branch feature/login (was 3f2a9c1).
git push origin --delete feature/login

-d verifică dacă vârful ramurii e accesibil din ramura curentă sau din upstream-ul ei. E o plasă de siguranță: nu pierzi din greșeală muncă neintegrată. -D (prescurtare pentru --delete --force) sare peste verificare.

Capcana frecventă: după un squash merge pe GitHub, -d spune că ramura nu e integrată. E adevărat din punctul de vedere al lui Git: commit-urile tale nu sunt în main, doar un commit nou cu același conținut. Aici -D e corect, după ce verifici că PR-ul a fost integrat.

Nu poți șterge ramura pe care ești; mută-te întâi pe alta.

Ștergerea pe server nu șterge copiile origin/feature/login de pe calculatoarele colegilor. Ei le curăță cu:

BASH
git fetch --prune
# sau permanent:
git config --global fetch.prune true

Dacă ai șters greșit, Git a afișat hash-ul (was 3f2a9c1), deci poți recrea ramura:

BASH
git branch feature/login 3f2a9c1

Dacă nu mai ai mesajul, găsești hash-ul în git reflog.

Ce urmărește intervievatorul: Verifică grija pentru munca neintegrată și cunoașterea cazului squash merge. Mulți juniori folosesc -D din reflex, fără să înțeleagă avertismentul.

Eroarea, în practică:the branch '...' is not fully mergederror: branch not found

31 Junior

Ce este starea „detached HEAD”, cum ajungi în ea și cum nu pierzi commit-urile făcute acolo?

Răspuns scurt: În detached HEAD, HEAD indică direct un commit, nu o ramură. Ajungi aici când faci checkout pe un hash, un tag sau o ramură remote. Commit-urile noi nu aparțin niciunei ramuri, așa că înainte să pleci creezi una: git switch -c nume.

Normal, .git/HEAD conține ref: refs/heads/main. În detached HEAD conține un hash:

BASH
git switch --detach v1.2.0
git checkout a1b2c3d
git checkout origin/main
# You are in 'detached HEAD' state...

Starea e utilă pentru a inspecta o versiune veche, a rula testele pe un tag sau a încerca ceva rapid. Problema apare când faci commit-uri:

A---B---C   main
     \
      X---Y   (HEAD)

Dacă acum faci git switch main, nimic nu mai indică spre Y. Git te avertizează și îți arată hash-ul, dar commit-urile devin neaccesibile și vor fi șterse de garbage collection după expirarea reflog-ului.

Cum le păstrezi:

BASH
git switch -c experiment       # înainte să pleci
# sau, dacă ai plecat deja:
git branch experiment Y_hash
git reflog                      # dacă nu mai ai hash-ul

Alte situații în care apare: în mijlocul unui rebase sau al unui git bisect, Git e intenționat în detached HEAD. În CI, multe sisteme fac checkout direct pe un commit, de aceea git branch --show-current returnează gol acolo.

git status îți spune mereu dacă ești detașat: HEAD detached at v1.2.0.

Ce urmărește intervievatorul: Verifică dacă înțelegi legătura dintre HEAD, ramuri și commit-uri accesibile. E o sursă clasică de „mi-au dispărut commit-urile”.

Eroarea, în practică:You are in 'detached HEAD' statefatal: You are not currently on a branch.

32 Mid

Ce face git merge --squash și care sunt avantajele și dezavantajele lui?

Răspuns scurt: --squash aplică toate modificările ramurii în working tree și index, fără să facă commit și fără să înregistreze ramura ca părinte. Faci apoi un singur commit nou. Istoricul principal rămâne curat, dar se pierde legătura cu commit-urile originale.

BASH
git switch main
git merge --squash feature/raport
git commit -m "feat(raport): exportă raportul lunar în CSV"
A---B---S   main          (S conține C+D+E, un singur părinte)
     \
      C---D---E   feature/raport

Avantaje:

  • un commit pe feature în main, cu un mesaj bun, chiar dacă pe ramură erau commit-uri ca „wip” sau „fix typo”;
  • git revert S anulează tot feature-ul;
  • istoric liniar, ușor de citit și de folosit cu bisect la nivel de feature.

Dezavantaje:

  • commit-urile C, D, E nu ajung în main; Git nu știe că ramura e integrată, deci git branch -d refuză, iar git branch --merged nu o listează;
  • dacă mai lucrezi pe aceeași ramură și o integrezi din nou, Git încearcă să aplice iar modificările vechi și pot apărea conflicte inutile; după squash, ramura ar trebui închisă;
  • pentru PR-uri mari, se pierde istoria pașilor intermediari, utilă la blame și bisect fin.

Pe GitHub și GitLab, „Squash and merge” face același lucru, plus completează automat mesajul cu titlul PR-ului și lista commit-urilor. E o alegere bună pentru PR-uri mici. Pentru feature-uri mari, cu commit-uri bine gândite, un merge normal sau rebase păstrează mai multă informație.

Ce urmărește intervievatorul: Verifică înțelegerea consecințelor, nu doar a comenzii. Cazul „ramura nu apare ca integrată după squash” arată experiența reală.

Eroarea, în practică:Squash commit -- not updating HEAD

33 Mid

Ai modificări necommitted și încerci git switch alta-ramura. Când te lasă Git să schimbi și când refuză? Ce opțiuni ai?

Răspuns scurt: Git te lasă dacă fișierele modificate sunt identice în ambele ramuri, iar modificările tale vin cu tine. Refuză dacă un fișier modificat diferă între ramuri, ca să nu-ți suprascrie munca. Opțiunile: commit, git stash, git switch -m sau git worktree.

Git încearcă să păstreze modificările locale. Pentru fiecare fișier modificat local:

  • dacă fișierul e la fel în ramura curentă și în ramura țintă, modificarea rămâne în working tree și „te urmează” pe noua ramură;
  • dacă fișierul diferă între ramuri, Git ar trebui să-l suprascrie și refuză:
error: Your local changes to the following files would be overwritten by checkout:
        src/app.js
Please commit your changes or stash them before you switch branches.

Același lucru e valabil pentru fișiere untracked care există ca urmărite în ramura țintă.

Opțiuni, în ordinea folosirii obișnuite:

BASH
git stash push -m "lucru la filtru"   # pui deoparte
git switch alta-ramura
# ... apoi înapoi
git switch -
git stash pop

git commit -m "wip: filtru"           # commit temporar, curățat apoi la rebase

git switch -m alta-ramura             # încearcă un merge al modificărilor locale

git worktree add ../hotfix main       # al doilea director, fără să atingi lucrul curent

switch -m face un three-way merge între modificările tale și ramura țintă; dacă apar conflicte, le rezolvi acolo, dar nu ai o copie de siguranță ca la stash.

O capcană: modificările care „te urmează” pot ajunge din greșeală în commit-ul de pe altă ramură. Uită-te la git status imediat după schimbare. Pentru întreruperi frecvente, git worktree e cea mai curată soluție.

Ce urmărește intervievatorul: Situație zilnică. Verifică dacă înțelegi regula după care Git refuză și dacă știi mai mult decât „dau stash”.

Eroarea, în practică:local changes would be overwritten by checkoutuntracked files would be overwritten by checkout

34 Mid

Cum afli ce ramuri locale sunt deja integrate în main și cum le ștergi pe toate dintr-o comandă?

Răspuns scurt: git branch --merged main listează ramurile ale căror vârfuri sunt accesibile din main, iar --no-merged pe cele cu muncă neintegrată. Le ștergi filtrând lista, de exemplu git branch --merged main | grep -vE '^\*|main|develop' | xargs git branch -d.

BASH
git branch -vv                   # fiecare ramură, ultimul commit, upstream, ahead/behind
git branch --merged main         # integrate în main
git branch --no-merged main      # cu commit-uri care nu sunt în main
git branch -r --merged origin/main  # la fel pentru ramurile remote

Ștergerea ramurilor integrate, protejând ramurile principale:

BASH
git switch main && git pull --ff-only
git branch --merged main \
  | grep -vE '^\*|^\s*(main|develop)$' \
  | xargs -r git branch -d

Folosim -d, nu -D: dacă filtrul scapă ceva, Git refuză să șteargă o ramură neintegrată. -r la xargs (GNU) nu rulează comanda dacă lista e goală; pe macOS e implicit.

Limita importantă: --merged verifică accesibilitatea commit-urilor. Ramurile integrate prin squash sau rebase and merge pe GitHub nu apar, pentru că în main au ajuns commit-uri noi, cu alt hash. Pentru ele există alte semnale:

BASH
git fetch --prune
git branch -vv | grep ': gone]'

gone înseamnă că upstream-ul a fost șters pe server, de obicei după închiderea PR-ului. Le verifici și le ștergi cu -D.

Pentru a vedea rapid ce ramuri sunt vechi:

BASH
git for-each-ref --sort=-committerdate refs/heads \
  --format='%(committerdate:short) %(refname:short)'

Ce urmărește intervievatorul: Verifică dacă poți automatiza sarcini de întreținere și dacă înțelegi limita lui --merged la squash merge.

Eroarea, în practică:the branch '...' is not fully merged

35 Mid

Ce arată git log --oneline --graph după comenzile de mai jos? A fost merge-ul fast-forward?

BASH
git init -b main demo && cd demo
echo a > f && git add f && git commit -m A
git switch -c feature
echo b >> f && git commit -am B
git switch main
echo c > g && git add g && git commit -m C
git merge feature -m M

Răspuns scurt: Nu a fost fast-forward: după ce feature a pornit din A, pe main s-a făcut commit-ul C, deci ramurile au divergat. Git a făcut un three-way merge fără conflict (fișiere diferite), iar graficul arată M cu doi părinți, C și B, deasupra lui A.

Urmărim pas cu pas:

  • A pe main;
  • feature pornește din A, iar B modifică f;
  • înapoi pe main, C adaugă fișierul g;
  • git merge feature: main (pe C) nu e strămoș al lui B, deci nu se poate face fast-forward.

Merge base e A. Față de bază, feature a modificat f, iar main a adăugat g. Zone diferite, deci merge automat, fără conflict. Rezultatul arată aproximativ așa (hash-urile diferă):

*   e5f6a7b (HEAD -> main) M
|\
| * c3d4e5f (feature) B
* | b2c3d4e C
|/
* a1b2c3d A

Ordinea exactă a lui B și C în grafic depinde de datele commit-urilor, dar structura e aceeași: M are ca prim părinte C (ramura pe care erai) și ca al doilea părinte B.

Verificări:

BASH
git cat-file -p HEAD | grep parent   # două linii parent
git log --first-parent --oneline     # M, C, A: fără B
cat f g                              # a, b  și  c

Dacă ai fi rulat merge-ul înainte de commit-ul C, ar fi fost fast-forward și nu ar fi existat M. Cu git merge --ff-only feature, comanda ar fi eșuat. Opțiunea -m M dă mesajul commit-ului de merge; fără ea, Git deschide editorul cu mesajul implicit „Merge branch 'feature'”.

Ce urmărește intervievatorul: Întrebare de cod: verifică dacă poți simula mental istoricul. Greșeala tipică e să crezi că merge-ul e fast-forward doar pentru că nu au apărut conflicte.

36 Senior

Ce strategii de merge are Git? Care e diferența dintre -s ours și -X ours?

Răspuns scurt: Implicită e ort (din Git 2.34, în locul lui recursive); mai există resolve, octopus, subtree și ours. -s ours ignoră complet ramura integrată și doar o marchează ca integrată. -X ours îmbină normal și rezolvă în favoarea ta doar bucățile în conflict.

Strategiile se aleg cu -s:

  • ort (Ostensibly Recursive's Twin): implicită din Git 2.34. Ca și recursive, tratează cazul cu mai multe merge base-uri construind o bază virtuală, dar e mai rapidă și gestionează mai corect redenumirile;
  • recursive: implicită înainte de 2.34, încă disponibilă;
  • resolve: varianta simplă cu o singură bază;
  • octopus: implicită când integrezi mai mult de două ramuri (git merge a b c); refuză dacă apar conflicte care ar cere rezolvare manuală;
  • ours: rezultatul e exact tree-ul ramurii curente;
  • subtree: pentru proiecte incluse într-un subdirector.

Diferența cerută e o capcană clasică:

BASH
git merge -s ours vechi-experiment

Creează un commit de merge cu doi părinți, dar codul nu se schimbă deloc. Se folosește rar, de exemplu pentru a marca o ramură veche ca integrată, ca să nu mai fie propusă la merge, sau la ramuri de release la care vrei să păstrezi istoricul fără modificări.

BASH
git merge -X ours feature
git merge -X theirs feature

Aici merge-ul e normal: modificările care nu se suprapun se combină. Doar bucățile care ar fi intrat în conflict se rezolvă automat cu varianta ta (ours) sau a lor (theirs). Riscul: poți obține cod incoerent, pentru că alegerea e mecanică, bucată cu bucată.

Nu există -s theirs; efectul se obține altfel, de exemplu cu git merge -s ours stând pe cealaltă ramură.

Ce urmărește intervievatorul: Întrebare senior care verifică dacă știi că există mai multe moduri de a combina istoricul. Confuzia dintre -s ours și -X ours poate șterge silențios munca unei echipe.

Conflicte

37 Junior

Când apare un conflict de merge și când Git reușește să combine automat două modificări ale aceluiași fișier?

Răspuns scurt: Conflictul apare când ambele ramuri au schimbat diferit aceeași zonă de linii față de strămoșul comun, sau când una modifică un fișier pe care cealaltă îl șterge. Modificări în zone diferite ale aceluiași fișier se combină automat.

Git combină modificările pe bucăți de text (hunks), comparând fiecare ramură cu merge base-ul.

Fără conflict:

  • Ana schimbă funcția de la începutul fișierului, Mihai pe cea de la final;
  • ambele ramuri fac exact aceeași modificare;
  • o ramură modifică un fișier, cealaltă nu îl atinge.

Cu conflict:

  • ambele ramuri modifică aceleași linii sau linii adiacente, în moduri diferite;
  • o ramură modifică un fișier, cealaltă îl șterge (modify/delete);
  • ambele adaugă un fișier nou cu același nume și conținut diferit (add/add);
  • ambele redenumesc același fișier diferit (rename/rename);
  • fișiere binare modificate de ambele părți: Git nu le poate îmbina pe linii.

„Linii adiacente” contează: dacă două modificări sunt imediat una după alta, Git nu poate decide ordinea și raportează conflict, chiar dacă logic nu se ating.

Important de spus la interviu: absența conflictului nu garantează cod corect. Dacă Ana redenumește o funcție, iar Mihai adaugă în alt fișier un apel la numele vechi, merge-ul trece fără conflict, dar codul nu compilează. De aceea CI rulează testele pe rezultatul merge-ului, iar GitHub poate cere ramura actualizată înainte de integrare.

Conflictele apar la merge, rebase, cherry-pick, revert, stash pop și pull, pentru că toate aplică modificări peste altă bază.

Ce urmărește intervievatorul: Verifică dacă înțelegi că Git lucrează pe text, nu pe sens. Partea despre conflictul semantic fără conflict textual îl diferențiază pe candidatul atent.

Eroarea, în practică:CONFLICT (content): Merge conflict in

38 Junior

Explică markerii de conflict din fișierul de mai jos. Ce variantă vine de unde și cum arată fișierul după rezolvare, dacă vrei ambele reduceri?

JavaScript
function pret(total) {
<<<<<<< HEAD
  return total * 0.9;
=======
  return total - 20;
>>>>>>> feature/voucher
}

Răspuns scurt: Între <<<<<<< HEAD și ======= e varianta ramurii curente (ours), între ======= și >>>>>>> feature/voucher e varianta ramurii integrate (theirs). Rezolvi scriind codul final dorit, ștergi toți markerii, apoi git add și finalizezi merge-ul.

Structura:

  • <<<<<<< HEAD: începe varianta ta, de pe ramura pe care erai la merge;
  • =======: separatorul;
  • >>>>>>> feature/voucher: se termină varianta din ramura integrată.

Git nu alege nimic: tu decizi ce înseamnă rezultatul corect. Uneori e una dintre variante, alteori o combinație. Dacă regula de business spune „întâi 10%, apoi voucherul de 20”:

JavaScript
function pret(total) {
  return total * 0.9 - 20;
}

Pașii de după editare:

BASH
git diff                  # verifici că nu mai sunt markeri
git add src/pret.js       # marchezi conflictul ca rezolvat
git commit                # finalizezi merge-ul (mesajul e precompletat)

Greșeli frecvente:

  • markerii rămân în cod și ajung în commit; git diff --check și majoritatea linterelor îi detectează;
  • alegi o variantă fără să înțelegi intenția celeilalte; când nu știi, întreabă autorul;
  • rezolvi textual, dar nu rulezi testele după.

Editorii (VS Code, IntelliJ) afișează butoane ca „Accept Current”, „Accept Incoming”, „Accept Both”. „Accept Both” aici ar produce două return, deci cod mort: butoanele nu înlocuiesc gândirea. Pentru mai mult context, configurează merge.conflictStyle zdiff3, care arată și varianta din strămoșul comun.

Ce urmărește intervievatorul: Întrebare practică de bază. Intervievatorul vrea să vadă că știi care parte e care și că rezolvarea e o decizie de cod, nu doar ștergerea markerilor.

Eroarea, în practică:CONFLICT (content): Merge conflict inerror: path 'pret.txt' is unmerged

39 Junior

Ești în mijlocul unui merge cu conflicte. Cum vezi ce fișiere mai sunt nerezolvate și cum renunți complet la merge?

Răspuns scurt: git status listează fișierele la „Unmerged paths”, iar git diff --name-only --diff-filter=U doar numele lor. Pentru a renunța, git merge --abort readuce repository-ul la starea dinainte de merge.

În timpul unui merge, Git e într-o stare intermediară: a creat .git/MERGE_HEAD (vârful ramurii integrate) și a pus în index trei versiuni pentru fiecare fișier în conflict.

BASH
git status
# You have unmerged paths.
#   (fix conflicts and run "git commit")
#   (use "git merge --abort" to abort the merge)
# Unmerged paths:
#         both modified:   src/pret.js
#         deleted by them: src/vechi.js

git diff --name-only --diff-filter=U   # doar fișierele nerezolvate
git ls-files -u                        # versiunile 1 (bază), 2 (ours), 3 (theirs)
git show :1:src/pret.js                # versiunea din strămoșul comun

Ce poți face:

  • rezolvi fișier cu fișier, apoi git add; când nu mai e niciunul, git commit (sau git merge --continue);
  • renunți: git merge --abort readuce HEAD, indexul și fișierele la starea dinainte;
  • reiei un singur fișier: git checkout -m src/pret.js recreează markerii, dacă ai stricat rezolvarea.

Atenție la --abort: încearcă să păstreze modificările locale necommitted care existau înainte de merge, dar dacă ele se suprapun cu fișierele în conflict, reconstrucția poate eșua. De aceea e bine să pornești un merge cu working tree curat.

Comenzile echivalente pentru celelalte operații: git rebase --abort, git cherry-pick --abort, git revert --abort. La rebase există și --skip, care sare peste commit-ul curent.

Ce urmărește intervievatorul: Verifică dacă știi să ieși dintr-o situație care pare blocată. Juniorii panicați fac uneori rm -rf și reclonează, pierzând munca locală.

Eroarea, în practică:you need to resolve your current index firstCommitting is not possible: unmerged files

40 Junior

Cum rezolvi un conflict de tip modify/delete și unul pe un fișier binar, de exemplu o imagine?

Răspuns scurt: La modify/delete decizi dacă fișierul rămâne (git add fișier) sau dispare (git rm fișier). La un binar Git nu poate pune markeri, deci alegi o versiune întreagă: git checkout --ours fișier sau --theirs, apoi git add.

Modify/delete: o ramură a șters fișierul, cealaltă l-a modificat.

CONFLICT (modify/delete): src/vechi.js deleted in feature and modified in HEAD.

Git lasă în working tree versiunea modificată. Întrebarea e de business: ștergerea a fost intenționată (codul s-a mutat în altă parte)? Atunci modificarea ta poate trebui portată în locul nou.

BASH
git rm src/vechi.js     # accepți ștergerea
git add src/vechi.js    # păstrezi fișierul modificat

Binar (imagini, PDF, fișiere Excel):

warning: Cannot merge binary files: logo.png (HEAD vs. feature)

Nu există markeri, deci alegi una dintre versiuni:

BASH
git checkout --ours  assets/logo.png    # versiunea ramurii curente
git checkout --theirs assets/logo.png   # versiunea ramurii integrate
git add assets/logo.png

Sintaxa modernă e git restore --ours assets/logo.png sau --theirs. Dacă îți trebuie ceva combinat, deschizi ambele versiuni în unealta potrivită și salvezi rezultatul:

BASH
git show :2:assets/logo.png > logo-ours.png
git show :3:assets/logo.png > logo-theirs.png

Pentru fișierele generate (de exemplu bundle-uri compilate) soluția corectă e să nu le ții în repository. Lockfile-urile (package-lock.json) se regenerează de obicei rulând instalarea după ce rezolvi package.json, nu se editează de mână.

Ce urmărește intervievatorul: Verifică dacă știi tipurile de conflict care nu au markeri. Mulți candidați cunosc doar cazul textual standard.

Eroarea, în practică:Cannot merge binary files

41 Mid

Ce este merge.conflictStyle diff3 (sau zdiff3) și de ce îl recomandă mulți developeri?

Răspuns scurt: Cu diff3, markerii de conflict includ și versiunea din strămoșul comun, între ||||||| și =======. Vezi astfel ce a schimbat fiecare parte față de original, nu doar două rezultate finale. zdiff3 (Git 2.35+) face același lucru, dar scoate din conflict liniile comune de la margini.

Stilul implicit arată doar două variante:

<<<<<<< HEAD
  const limita = 50;
=======
  const limita = 100;
>>>>>>> feature

Nu știi dacă ambele au schimbat valoarea sau doar una. Cu diff3:

BASH
git config --global merge.conflictStyle zdiff3   # sau diff3 pe Git mai vechi
<<<<<<< HEAD
  const limita = 50;
||||||| merged common ancestors
  const limita = 20;
=======
  const limita = 100;
>>>>>>> feature

Acum e clar: valoarea originală era 20, ambele ramuri au schimbat-o, deci trebuie să afli ce intenție are fiecare. Într-un caz mai subtil, baza îți arată că o ramură a adăugat o linie, iar cealaltă a reformatat blocul, și poți reconstrui manual ambele intenții.

De ce ajută:

  • vezi schimbarea, nu doar rezultatul, pentru fiecare parte;
  • eviți greșeala de a „alege una”, pierzând modificarea celeilalte;
  • conflictele aparent identice (ambele au adăugat aceeași linie cu mici diferențe) devin evidente.

zdiff3 mută liniile identice de la începutul și finalul conflictului în afara markerilor, deci blocurile sunt mai scurte. Uneltele grafice de merge (git mergetool cu vimdiff, meld, IntelliJ) arată de obicei trei sau patru panouri pe aceeași idee: bază, ours, theirs și rezultat.

Ce urmărește intervievatorul: Verifică dacă ai rezolvat conflicte serioase. Un candidat care folosește diff3 înțelege că rezolvarea corectă pornește de la ce a vrut fiecare parte.

42 Mid

În timpul unui git rebase main, ai un conflict și folosești git checkout --ours fișier. Ce versiune primești? De ce e diferit față de merge?

Răspuns scurt: La rebase primești versiunea de pe main, nu pe a ta. Rebase-ul îți reaplică commit-urile peste main, deci „ours” e baza pe care se construiește (main plus commit-urile deja reaplicate), iar „theirs” e commit-ul tău care se aplică acum.

La merge, stând pe feature:

  • ours = feature (ramura curentă);
  • theirs = ramura integrată.

La rebase, comanda git rebase main stând pe feature face, intern:

  • detașează HEAD pe vârful lui main;
  • reaplică pe rând fiecare commit din feature, ca un cherry-pick.

În timpul fiecărui cherry-pick, ramura „curentă” este cea nouă, construită pe main. Deci:

  • ours = main plus commit-urile tale deja reaplicate;
  • theirs = commit-ul tău care se aplică acum.
BASH
git rebase main
# CONFLICT (content): Merge conflict in src/app.js
git checkout --theirs src/app.js   # păstrezi varianta TA din acel commit
git add src/app.js
git rebase --continue

Aceeași inversare apare la git pull --rebase și la opțiunile -X ours și -X theirs date la rebase: git rebase -X theirs main favorizează commit-urile tale în conflicte.

Markerii arată și ei asta: în loc de HEAD, vei vedea ceva de genul <<<<<<< HEAD pentru baza nouă și >>>>>>> a1b2c3d (Adaugă filtrul) pentru commit-ul tău.

Sfat practic: în loc să memorezi, citește etichetele markerilor sau rulează git status, care la rebase arată ce commit se aplică. Și verifică rezultatul cu git diff înainte de --continue.

Ce urmărește intervievatorul: Capcană cunoscută care produce pierderi de cod la candidații care aplică reflexul de la merge. Întrebarea verifică înțelegerea mecanismului rebase-ului.

Eroarea, în practică:could not apply ... (conflict la rebase)You must edit all merge conflicts (rebase)

43 Mid

Ce face git rerere și când ți-e util?

Răspuns scurt: rerere (reuse recorded resolution) memorează cum ai rezolvat un conflict și aplică automat aceeași rezolvare când întâlnește din nou exact același conflict. E util la rebase-uri repetate ale unei ramuri lungi sau când refaci un merge.

Se activează o dată:

BASH
git config --global rerere.enabled true

De acum, la fiecare conflict, Git salvează în .git/rr-cache forma conflictului (cele două părți), iar după ce îl rezolvi și dai git add, salvează și rezultatul. Când apare din nou un conflict identic, Git aplică rezultatul memorat:

Resolved 'src/app.js' using previous resolution.

Fișierul rămâne totuși nemarcat ca rezolvat, ca să-l poți verifica; adaugi cu git add (sau setezi rerere.autoUpdate true ca să se facă automat).

Scenarii tipice:

  • ai o ramură de lungă durată pe care o rebazezi des peste main; fără rerere, rezolvi aceleași conflicte la fiecare rebase;
  • ai făcut un merge de test ca să vezi conflictele, l-ai anulat, iar mai târziu îl faci pe bune;
  • ai rezolvat conflicte la un merge, apoi decizi să faci rebase în loc;
  • integrezi aceeași corecție în mai multe ramuri de release.

Comenzi utile:

BASH
git rerere status        # fișierele cu rezolvări înregistrate
git rerere diff          # ce rezolvare ar aplica
git rerere forget src/app.js  # uită o rezolvare greșită

Riscul: dacă ai rezolvat greșit o dată, rerere va repeta greșeala silențios. De aceea, după orice rezolvare automată, testele rămân obligatorii.

Ce urmărește intervievatorul: Unealtă mai puțin cunoscută care arată experiență cu ramuri lungi și rebase-uri repetate. Un candidat bun menționează și riscul repetării unei rezolvări greșite.

44 Senior

Echipa ta pierde ore pe săptămână cu conflicte de merge. Ce măsuri tehnice și de proces ai propune?

Răspuns scurt: Integrare frecventă cu ramuri scurte și PR-uri mici, formatare automată identică pentru toți, evitarea reformatărilor masive amestecate cu logica, structură de cod care reduce fișierele „fierbinți”, plus unelte: zdiff3, rerere, CODEOWNERS și regenerarea fișierelor generate în loc de merge manual.

Conflictele cresc cu durata ramurilor și cu suprapunerea zonelor modificate. Măsurile atacă ambele.

Proces:

  • ramuri scurte, de una-două zile, și PR-uri mici; cu cât integrezi mai rar, cu atât diferențele sunt mai mari;
  • actualizarea zilnică a ramurii din main, nu doar înainte de PR;
  • comunicare pe zonele grele: cine lucrează la un refactor mare anunță și îl integrează rapid;
  • refactorizările mari (redenumiri, mutări de foldere) se fac într-un PR separat, integrat repede, când ceilalți au puține ramuri deschise.

Tehnic:

  • un formatter (Prettier, Black, gofmt, ktlint) rulat automat în pre-commit și verificat în CI, ca să nu existe diferențe de spații sau ordinea importurilor;
  • commit-ul de reformatare inițial adăugat în .git-blame-ignore-revs;
  • fișiere „fierbinți”, unde toți adaugă la final (registre de rute, constante, fișiere de traduceri), sparte pe module sau sortate alfabetic, ca adăugările să nu fie adiacente;
  • fișierele generate (lockfile-uri, cod compilat) regenerate, nu rezolvate manual; pentru unele formate se poate configura un merge driver în .gitattributes;
  • merge.conflictStyle zdiff3 și rerere.enabled recomandate în ghidul echipei;
  • CODEOWNERS, ca review-ul pe zone sensibile să ajungă la cine le cunoaște.

Ca să știi ce merită făcut întâi, uită-te la fișierele cele mai des modificate:

BASH
git log --since="3 months ago" --name-only --pretty=format: \
  | sort | uniq -c | sort -rn | head -20

Fișierele din vârful listei sunt candidații pentru restructurare.

Ce urmărește intervievatorul: Întrebare de senior: verifică dacă vezi conflictele ca simptom al procesului și al arhitecturii, nu ca problemă de unealtă. Răspunsurile bune combină cauze și măsuri concrete.

Rebase, cherry-pick și rescrierea istoricului

45 Junior

Ce se întâmplă concret cu commit-urile tale când rulezi git rebase main pe ramura feature? De ce se schimbă hash-urile?

Răspuns scurt: Git găsește commit-urile din feature care nu sunt în main, le pune deoparte, mută ramura pe vârful lui main și le reaplică pe rând, ca pe niște commit-uri noi. Au alt părinte și deci alt hash; originalele rămân neaccesibile, dar recuperabile prin reflog.

Pornim de la:

A---B---E---F   main
     \
      C---D     feature

git rebase main (stând pe feature) face, pe scurt:

  • calculează commit-urile de mutat: main..feature, adică C și D;
  • trece HEAD pe F;
  • aplică diferența introdusă de C peste F, creând C'; apoi D peste C', creând D';
  • mută feature pe D'.
A---B---E---F         main
             \
              C'---D'  feature

C' are același mesaj, autor și modificări ca C, dar alt părinte (F în loc de B) și alt tree (conține și modificările din E, F). Pentru că hash-ul se calculează din toate acestea, C' are hash nou. Data autorului rămâne, data committer-ului devine cea de acum.

Consecințe:

  • istoricul devine liniar, ca și cum ai fi început lucrul de pe F;
  • fiecare commit reaplicat poate produce conflict, deci poți rezolva conflicte de mai multe ori, câte unul pentru fiecare commit;
  • C și D nu sunt șterse imediat; ORIG_HEAD și git reflog îți permit să revii;
  • dacă feature era deja pe server, ramura locală și cea remote au divergat și ai nevoie de push --force-with-lease.

Commit-urile din feature care există deja în main cu aceeași modificare (de exemplu prin cherry-pick) sunt sărite automat.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului, nu doar „rebase face istoric liniar”. Explicația hash-urilor noi pregătește întrebarea despre regula de aur.

Eroarea, în practică:could not apply ... (conflict la rebase)

46 Junior

Care este „regula de aur” a rebase-ului și ce se întâmplă dacă o încalci?

Răspuns scurt: Nu face rebase pe commit-uri pe care alții le-au preluat deja, adică pe ramuri publice, comune. Rebase-ul înlocuiește commit-urile cu altele noi; colegii care aveau versiunea veche vor avea commit-uri duplicate, conflicte ciudate și riscul de a reintroduce codul rescris.

Rebase-ul, --amend și rebase-ul interactiv creează commit-uri noi în locul celor vechi. Pe calculatorul tău nu e o problemă. Problema apare când altcineva a construit deja peste commit-urile vechi.

Scenariul clasic:

  • tu și Mihai lucrați pe develop, care conține C;
  • Mihai face commit-ul M peste C;
  • tu rescrii C în C' cu rebase și dai push --force;
  • Mihai face git pull: Git vede că C (la el) și C' (pe server) sunt commit-uri diferite și le îmbină. Rezultatul conține ambele versiuni, posibil conflicte pe cod pe care niciunul nu l-a schimbat, iar dacă Mihai face push, C revine pe server.

Mai rău, dacă Mihai dă tot push --force fără să tragă întâi, șterge commit-urile tale.

Regula practică:

  • rebase pe ramura ta, nelucrată de alții: oricând, inclusiv după push, cu git push --force-with-lease;
  • rebase pe main, develop, ramuri de release sau ramuri comune: niciodată;
  • pentru a aduce main în ramura ta, rebase-ul ramurii tale peste main e în regulă, pentru că rescrii doar commit-urile tale.

Dacă ai încălcat totuși regula, colegii se pot resincroniza cu git fetch urmat de git rebase origin/develop (Git detectează deseori commit-urile echivalente) sau, dacă nu au muncă locală, cu git reset --hard origin/develop. Branch protection pe server, care interzice force push pe ramurile principale, previne situația.

Ce urmărește intervievatorul: Întrebare obligatorie la orice discuție despre rebase. Răspunsul bun explică mecanismul problemei, nu doar „nu se face”.

47 Junior

Ce face git pull --rebase față de un git pull simplu și cum îl setezi ca implicit?

Răspuns scurt: git pull simplu face fetch și apoi merge, putând crea commit-uri „Merge branch 'main' of...”. git pull --rebase face fetch și apoi rebase al commit-urilor tale locale peste ramura de pe server, păstrând istoricul liniar. Îl faci implicit cu git config --global pull.rebase true.

Situația: ai două commit-uri locale pe main, iar colegii au împins între timp altele.

local:   A---B---L1---L2
server:  A---B---S1

Cu git pull (merge):

A---B---L1---L2---M
     \           /
      S1---------

Apare un commit de merge fără valoare informativă. Repetat zilnic de mai mulți oameni, istoricul devine greu de citit.

Cu git pull --rebase:

A---B---S1---L1'---L2'

Commit-urile tale sunt reaplicate după S1. E sigur pentru că rescrii doar commit-uri care nu au ajuns încă pe server.

Configurare:

BASH
git config --global pull.rebase true     # rebase implicit
git config --global rebase.autoStash true  # stash automat dacă ai modificări necommitted
# alternativ, doar fast-forward:
git config --global pull.ff only

Din Git 2.27, dacă nu ai setat nimic și ramurile au divergat, Git afișează un avertisment care îți cere să alegi. Din Git 2.33, cazul în care nu e posibil fast-forward și nu ai ales o strategie se termină cu eroare, nu cu merge implicit.

Dacă apar conflicte în timpul pull-ului cu rebase, le rezolvi ca la orice rebase: editezi, git add, git rebase --continue, sau renunți cu git rebase --abort.

Ce urmărește intervievatorul: Verifică obiceiurile zilnice și grija pentru istoric. Mulți juniori nu știu de unde vin commit-urile de merge automate din istoricul lor.

Eroarea, în practică:You have divergent branchescannot pull with rebase: You have unstaged changes

48 Junior

Ai lista de mai jos într-un git rebase -i HEAD~4. Ce commit-uri vor rămâne și cum arată istoricul?

pick a1 Adaugă formularul de contact
fixup b2 typo
reword c3 validare
drop d4 console.log de test

Răspuns scurt: Rămân două commit-uri: „Adaugă formularul de contact”, care include și corectura din b2 (fixup îi aruncă mesajul), și commit-ul c3 cu un mesaj nou, pe care Git te pune să-l scrii. Commit-ul d4 dispare complet.

Rebase-ul interactiv execută lista de sus în jos, de la cel mai vechi commit la cel mai nou:

  • pick a1: păstrează commit-ul așa cum e;
  • fixup b2: îl lipește de commit-ul anterior (a1) și îi aruncă mesajul; rezultatul e un singur commit cu mesajul lui a1;
  • reword c3: păstrează modificările, dar se deschide editorul ca să schimbi mesajul, de exemplu în „Validează emailul în formularul de contact”;
  • drop d4: commit-ul e eliminat, iar modificările lui nu mai apar nicăieri.

Rezultat:

* 9f8e7d6 Validează emailul în formularul de contact
* 5c4b3a2 Adaugă formularul de contact

Toate cele două au hash-uri noi. Celelalte comenzi disponibile:

  • squash: ca fixup, dar combină mesajele și te lasă să le editezi;
  • edit: se oprește după commit, ca să-l modifici (git commit --amend) sau să-l spargi;
  • exec: rulează o comandă de shell, de exemplu testele;
  • break: se oprește într-un punct, fără modificări;
  • schimbarea ordinii liniilor reordonează commit-urile;
  • ștergerea unei linii are același efect ca drop.

Atenție la ordine: fixup pe prima linie nu are cu ce să se combine și Git dă eroare. Dacă ceva iese prost, git rebase --abort în timpul operației, sau git reset --hard ORIG_HEAD după.

Ce urmărește intervievatorul: Întrebare de cod despre rebase interactiv, folosit des înainte de PR. Verifică dacă știi exact ce face fiecare comandă și în ce ordine se aplică.

Eroarea, în practică:cannot 'squash' without a previous commit

49 Mid

Cum combini ultimele trei commit-uri într-unul singur? Dă două metode și spune când alegi fiecare.

Răspuns scurt: Metoda 1: git rebase -i HEAD~3 și marchezi ultimele două cu squash sau fixup. Metoda 2: git reset --soft HEAD~3 urmat de un git commit nou. Rebase-ul interactiv e mai controlat, reset-ul soft e mai rapid când vrei oricum un mesaj nou.

Rebase interactiv:

BASH
git rebase -i HEAD~3
pick   a1 Adaugă exportul CSV
squash b2 Corectează separatorul
squash c3 Adaugă testele

Git combină modificările și deschide editorul cu toate cele trei mesaje, ca să compui unul final. Cu fixup în loc de squash, păstrează doar mesajul primului. Avantaje: poți alege ce combini, poți reordona, poți combina doar o parte; păstrează autorul și data primului commit.

Reset soft:

BASH
git reset --soft HEAD~3
git commit -m "feat(export): exportă comenzile în CSV"

--soft mută ramura cu trei commit-uri înapoi, dar lasă toate modificările în index. Commit-ul nou le conține pe toate. E rapid și nu produce conflicte, pentru că nu se reaplică nimic.

Alte detalii:

  • ambele metode creează un commit nou; dacă cele trei erau deja împinse pe ramura ta, ai nevoie de git push --force-with-lease;
  • cu HEAD~3, verifică întâi cu git log --oneline -4 că nu prinzi și un commit care nu e al tău, de exemplu un merge din main;
  • dacă ramura conține merge-uri, reset --soft e mai previzibil;
  • alternativa fără rescriere locală: „Squash and merge” la integrarea PR-ului pe GitHub.

Dacă te-ai răzgândit, git reset --hard ORIG_HEAD (după rebase) sau git reset --soft HEAD@{1} te întorc la starea anterioară.

Ce urmărește intervievatorul: Verifică dacă ai mai multe unelte și știi efectele lor. Candidații mid ar trebui să știe ambele variante și riscul de a prinde commit-uri străine.

Eroarea, în practică:cannot 'squash' without a previous commit

50 Mid

Ce sunt git commit --fixup și git rebase --autosquash? Arată fluxul pentru a corecta un commit mai vechi din ramura ta.

Răspuns scurt: git commit --fixup <hash> creează un commit cu mesajul „fixup! <subiect>”, legat de commit-ul țintă. git rebase -i --autosquash mută automat aceste commit-uri lângă țintă și le marchează cu fixup, deci corectezi un commit vechi fără să editezi manual lista.

Scenariul: ramura are trei commit-uri, iar reviewerul cere o modificare în primul.

BASH
git log --oneline
# c3 Adaugă testele pentru export
# b2 Adaugă butonul de export
# a1 Adaugă serviciul de export      <- aici e problema

Faci modificarea, apoi:

BASH
git add src/export.js
git commit --fixup a1
# creează: fixup! Adaugă serviciul de export
git rebase -i --autosquash main

Lista din editor e deja aranjată:

pick  a1 Adaugă serviciul de export
fixup f9 fixup! Adaugă serviciul de export
pick  b2 Adaugă butonul de export
pick  c3 Adaugă testele pentru export

Salvezi și corecția e topită în a1. Variante:

  • git commit --squash a1: la fel, dar păstrează și mesajul ca să-l poți edita;
  • git commit --fixup=amend:a1 (Git 2.32+): înlocuiește și mesajul țintei;
  • git config --global rebase.autoSquash true: activează --autosquash la orice rebase -i.

Avantaj în code review: poți împinge commit-urile fixup! ca reviewerul să vadă exact ce ai schimbat, iar înainte de merge faci rebase-ul cu autosquash. Unele echipe blochează în CI integrarea dacă ramura încă are commit-uri fixup!.

Rebase-ul rescrie commit-urile ramurii, deci urmează git push --force-with-lease.

Ce urmărește intervievatorul: Arată un flux de lucru matur pentru istoric curat. Intervievatorii apreciază candidații care știu să răspundă la review fără să strice structura commit-urilor.

51 Mid

Un commit din ramura ta conține două schimbări care nu au legătură. Cum îl împarți în două commit-uri separate?

Răspuns scurt: Pornești git rebase -i, marchezi commit-ul cu edit, iar când Git se oprește rulezi git reset HEAD^. Modificările revin necommitted; le adaugi pe rând cu git add -p și faci două commit-uri, apoi git rebase --continue.

BASH
git rebase -i main
pick a1 Adaugă exportul
edit b2 Validare email și refactor logger   <- de spart
pick c3 Teste

Git aplică a1, apoi b2 și se oprește. Acum:

BASH
git reset HEAD^          # anulează commit-ul b2, păstrează modificările necommitted
git status               # vezi fișierele modificate

git add -p src/form.js   # alegi doar bucățile de validare
git commit -m "Validează emailul în formular"

git add src/logger.js
git commit -m "Refactorizează loggerul"

git rebase --continue    # se aplică c3 peste

Detalii importante:

  • git reset HEAD^ e implicit --mixed: mută ramura cu un commit înapoi și golește indexul, dar nu atinge fișierele;
  • git add -p îți arată fiecare hunk și răspunzi y, n sau s (split, pentru a sparge bucata mai fin); e permite editarea manuală a hunk-ului;
  • dacă o bucată amestecă cele două schimbări în aceleași linii, o rezolvi temporar în editor, faci primul commit, apoi restul;
  • verifică cu git stash -k și rularea testelor că primul commit compilează singur.

Dacă e vorba de ultimul commit, nu ai nevoie de rebase: direct git reset HEAD^ și refaci commit-urile.

Totul se petrece pe ramura ta; după rescriere, git push --force-with-lease. Commit-urile atomice fac review-ul mai ușor și permit revert-ul separat al fiecărei schimbări.

Ce urmărește intervievatorul: Verifică stăpânirea instrumentelor de rescriere și a lui add -p. Candidații care pot face asta lucrează de obicei cu commit-uri atomice.

52 Mid

Ce face git cherry-pick, când îl folosești și ce probleme poate crea?

Răspuns scurt: Cherry-pick aplică modificările unui commit existent peste ramura curentă, ca un commit nou, cu alt hash. Util pentru a porta un fix pe o ramură de release sau a muta un commit făcut pe ramura greșită. Riscul: aceeași schimbare apare de două ori în istoric.

BASH
git switch release/2.3
git cherry-pick -x a1b2c3d
# commit nou, cu mesajul original plus:
# (cherry picked from commit a1b2c3d...)

Cazuri potrivite:

  • backport: bug-ul a fost reparat pe main, iar fix-ul trebuie și în versiunea 2.3 deja lansată;
  • ai făcut commit pe main în loc de ramura de feature: îl cherry-pick-uiești pe feature, apoi îl scoți de pe main;
  • iei un singur commit util dintr-o ramură abandonată.

Variante:

BASH
git cherry-pick a1..c3        # de la commit-ul după a1 până la c3
git cherry-pick a1^..c3       # inclusiv a1
git cherry-pick -n a1         # aplică fără commit
git cherry-pick -m 1 M        # dintr-un commit de merge, față de primul părinte
git cherry-pick --continue / --abort

Probleme:

  • commit-ul nou e diferit de original pentru Git. La un merge ulterior, Git compară conținutul și de obicei nu raportează conflict pentru modificări identice, dar dacă între timp codul a evoluat diferit, pot apărea conflicte neașteptate;
  • un fix care depinde de alte commit-uri anterioare nu se aplică curat sau, mai rău, se aplică dar nu funcționează;
  • cherry-pick-ul folosit în locul merge-ului pentru a „sincroniza” ramuri duce la istorii greu de urmărit.

-x e recomandat pe ramurile publice: notează proveniența, iar git log --grep o poate găsi ulterior.

Ce urmărește intervievatorul: Verifică dacă știi când e potrivit cherry-pick și când e un semn de proces defect. Opțiunea -x și problema dependențelor arată experiență cu release-uri.

Eroarea, în practică:The previous cherry-pick is now emptyerror: cherry-pick is already in progress

53 Mid

Ai pornit feature-b din feature-a, dar feature-a a fost abandonată. Cum muți doar commit-urile din feature-b direct pe main?

A---B   main
     \
      C---D   feature-a
           \
            E---F   feature-b

Răspuns scurt: git rebase --onto main feature-a feature-b. Git ia commit-urile din feature-b care nu sunt în feature-a (E și F) și le reaplică pe main, lăsând C și D pe dinafară.

Forma generală:

BASH
git rebase --onto <baza-noua> <exclus> <ramura>

Git ia commit-urile accesibile din <ramura>, dar nu din <exclus> (feature-a..feature-b, adică E și F) și le reaplică pe <baza-noua>:

BASH
git rebase --onto main feature-a feature-b
A---B   main
     \
      E'---F'   feature-b

Un git rebase main simplu ar fi mutat C, D, E, F, pentru că toate patru lipsesc din main, deci codul abandonat ar fi intrat în PR.

Alte utilizări ale lui --onto:

BASH
# elimini commit-urile C și D din mijlocul ramurii, păstrând E și F
git rebase --onto B D feature-b

# după ce feature-a a fost integrată prin squash în main,
# muți feature-b fără commit-urile vechi ale lui feature-a
git rebase --onto main feature-a feature-b

Al doilea caz e foarte frecvent cu PR-uri înlănțuite (stacked): după squash merge, commit-urile lui feature-a nu sunt în main cu același hash, iar un rebase simplu ar încerca să le aplice din nou și ar produce conflicte.

Ca orice rebase, rezultatul are hash-uri noi; dacă feature-b era pe server, urmează git push --force-with-lease. Înainte, verifică ce va fi mutat cu git log --oneline feature-a..feature-b.

Ce urmărește intervievatorul: Întrebare de cod pentru nivel mid. Verifică dacă înțelegi rebase-ul ca operație pe intervale de commit-uri, nu doar „mută ramura”.

54 Senior

Lucrezi cu PR-uri înlănțuite (stacked): feat-1 → feat-2 → feat-3. Cum le actualizezi pe toate după o modificare în feat-1 fără trei rebase-uri manuale?

Răspuns scurt: Din Git 2.38, git rebase --update-refs mută automat și ramurile intermediare care indică commit-uri din intervalul rebazat. Faci rebase o dată pe feat-3, iar feat-1 și feat-2 sunt actualizate odată cu el; apoi le împingi pe toate cu --force-with-lease.

Situația: trei PR-uri dependente, fiecare pornind din precedentul, pentru că o schimbare mare a fost spartă în bucăți revizuibile.

main --- a1 --- a2 (feat-1) --- b1 (feat-2) --- c1 --- c2 (feat-3)

Reviewerul cere o modificare în a1. Fără ajutor, ai face: amend pe feat-1, apoi git rebase --onto feat-1 <vechiul feat-1> feat-2, apoi la fel pentru feat-3, cu riscul de a greși baza.

Cu Git 2.38+:

BASH
git switch feat-3
git commit --fixup a1          # corectura, pe vârful stivei
git rebase -i --autosquash --update-refs main

Lista de rebase conține acum linii update-ref refs/heads/feat-1 și update-ref refs/heads/feat-2 în pozițiile potrivite. După rebase, toate trei ramurile indică noile commit-uri.

BASH
git config --global rebase.updateRefs true
git push --force-with-lease origin feat-1 feat-2 feat-3

Când feat-1 e integrată prin squash merge în main, restul stivei se mută cu:

BASH
git rebase --onto main feat-1 feat-3 --update-refs

Considerente:

  • fiecare PR țintește ramura anterioară, nu main, ca diff-ul din review să fie doar al lui;
  • după integrarea primului PR, baza celui următor trebuie schimbată pe main (GitHub face asta automat când ramura de bază e ștearsă la merge);
  • unelte dedicate (de exemplu Graphite, ghstack sau git-branchless) automatizează fluxul, dar --update-refs acoperă cazul de bază fără nimic instalat.

Ce urmărește intervievatorul: Verifică experiența cu fluxuri avansate de review în echipe mari. Un senior ar trebui să știe atât problema, cât și soluția nativă din Git modern.

55 Senior

Cum te asiguri că fiecare commit dintr-o ramură compilează și trece testele, nu doar ultimul? De ce contează?

Răspuns scurt: Rulezi git rebase -i --exec "npm test" main (sau -x): după fiecare commit reaplicat, Git rulează comanda și se oprește la primul eșec, ca să repari exact commit-ul stricat. Contează pentru git bisect, pentru revert-uri parțiale și pentru deploy-uri care pot porni din orice commit.

BASH
git rebase --exec "npm ci && npm test" main
# sau: git rebase -x "make test" HEAD~5

Git inserează o linie exec după fiecare pick. Dacă o comandă se termină cu cod diferit de 0, rebase-ul se oprește exact după commit-ul vinovat:

Executing: npm test
...
warning: execution failed: npm test
You can fix the problem, and then run
  git rebase --continue

Repari, git commit --amend, apoi git rebase --continue, iar testele continuă cu următorul commit.

De ce contează commit-urile verzi:

  • bisect: dacă unele commit-uri intermediare nu compilează, git bisect trebuie să le sară (git bisect skip), iar căutarea devine ambiguă;
  • revert: un commit care se bazează pe un fix din commit-ul următor nu poate fi revertat sau cherry-pick-uit singur;
  • merge cu --no-ff sau rebase and merge: toate commit-urile ajung în main, deci și cele stricate;
  • review: un istoric în care fiecare pas are sens poate fi citit commit cu commit.

Pentru verificare fără rescriere, poți rula testele în afara rebase-ului:

BASH
for c in $(git rev-list --reverse main..HEAD); do
  git checkout -q "$c" && npm test --silent || { echo "Eșec la $c"; break; }
done
git switch -

Echipele care folosesc squash merge pot sări peste această disciplină, pentru că în main ajunge un singur commit. Totuși, pentru ramuri mari integrate cu merge, verificarea cu --exec evită commit-uri moarte în istoric.

Ce urmărește intervievatorul: Verifică dacă gândești istoricul ca pe o unealtă de depanare. Seniorii care au folosit bisect pe un istoric cu commit-uri stricate știu de ce contează.

56 Senior

Ai terminat un rebase mare, cu conflicte, iar acum testele nu mai trec. Cum revii exact la starea dinainte și cum compari cele două versiuni ale ramurii?

Răspuns scurt: Starea anterioară e în ORIG_HEAD și în reflog: git reset --hard ORIG_HEAD sau git reset --hard feature@{1}. Pentru a compara versiunile ramurii, folosești git range-diff, care pune față în față commit-urile vechi și cele rebazate.

Rebase-ul salvează vârful vechi al ramurii în două locuri:

  • ORIG_HEAD: setat de rebase, reset și merge; e suprascris de următoarea astfel de operație;
  • reflog-ul ramurii: feature@{1} e poziția anterioară, git reflog show feature le arată pe toate.
BASH
git reflog show feature -5
# 9f8e7d6 feature@{0}: rebase (finish): refs/heads/feature onto 1a2b3c4
# 5c4b3a2 feature@{1}: commit: Adaugă testele
git reset --hard feature@{1}       # sau ORIG_HEAD imediat după rebase

Înainte de reset, ca să nu pierzi nici rezultatul rebase-ului (poate vrei să-l repari, nu să-l arunci):

BASH
git branch feature-rebazat         # păstrezi varianta nouă
git reset --hard feature@{1}

Compararea celor două versiuni:

BASH
git range-diff main feature@{1} feature-rebazat
# 1:  5c4b3a2 = 1:  9f8e7d6 Adaugă serviciul
# 2:  6d5e4f3 ! 2:  aa11bb2 Adaugă filtrul

= înseamnă commit identic ca modificare, ! că rezolvarea conflictelor l-a schimbat, iar dedesubt apare diferența dintre diff-uri. Așa găsești exact commit-ul în care rezolvarea conflictului a stricat ceva, fără să recitești toată ramura.

Pentru rebase-uri riscante, obiceiul bun e un tag sau o ramură de backup înainte: git branch backup/feature. Și dacă ai împins deja varianta stricată, aceeași recuperare urmată de git push --force-with-lease readuce serverul la versiunea bună.

Ce urmărește intervievatorul: Verifică dacă poți lucra fără frică cu operații care rescriu istoricul. range-diff e unealta care distinge un senior: comparația versiunilor unei ramuri e frecventă în review.

Anulare și recuperare: restore, reset, revert, reflog, stash

Exersează capitolul cu exerciții reale: Curs Git online →
57 Junior

Cum renunți la modificările necommitted dintr-un fișier și ce trebuie să știi înainte să o faci?

Răspuns scurt: git restore fișier (sau varianta veche git checkout -- fișier) readuce fișierul la versiunea din index, deci la ultimul commit dacă nu ai făcut add. Modificările nesalvate în niciun commit sau stash se pierd definitiv: Git nu le are nicăieri.

BASH
git restore src/app.js           # working tree <- index
git restore .                    # toate fișierele din folderul curent
git restore -p src/app.js        # alegi bucată cu bucată ce arunci
git restore --source=HEAD --staged --worktree src/app.js  # index și working tree <- HEAD

Ce trebuie să știi:

  • git restore fără opțiuni copiază versiunea din index, nu din ultimul commit. Dacă ai dat git add și apoi ai modificat din nou, revii la versiunea din momentul add;
  • modificările aruncate nu pot fi recuperate prin reflog, pentru că nu au fost niciodată commit-uri. Singura plasă de siguranță ar fi istoricul local al editorului (VS Code Timeline, IntelliJ Local History);
  • fișierele untracked nu sunt atinse de restore; pentru ele există git clean.

Obiceiul sigur, când nu ești convins:

BASH
git stash push -m "backup inainte de restore" -- src/app.js

Așa poți reveni dacă te răzgândești.

Varianta veche, întâlnită în tutoriale și răspunsuri vechi:

BASH
git checkout -- src/app.js

-- e important: separă numele fișierului de numele unei ramuri. Fără el, dacă există o ramură cu același nume, Git ar schimba ramura. Tocmai această ambiguitate a dus la apariția comenzii restore în Git 2.23.

Ce urmărește intervievatorul: Verifică dacă știi că aceasta e una dintre puținele operații Git cu adevărat ireversibile. Candidații care spun „recuperez cu reflog” aici au o lacună.

Eroarea, în practică:fatal: Cannot do hard reset with paths.you must specify path(s) to restore

58 Junior

Ai dat git add . și ai pus în staging și un fișier care nu trebuia. Cum îl scoți fără să-i pierzi modificările?

Răspuns scurt: git restore --staged fișier (sau git reset fișier) scoate fișierul din index și îl readuce la versiunea din HEAD acolo, dar modificările rămân în working tree. Pentru un fișier nou, rămâne untracked.

BASH
git add .
git status -s
# M  src/app.js
# A  secrete.env        <- nu trebuia

git restore --staged secrete.env
git status -s
# M  src/app.js
# ?? secrete.env

Ce se întâmplă: indexul primește pentru acel fișier versiunea din HEAD. Dacă fișierul nu exista în HEAD, e scos complet din index și redevine untracked. Fișierul de pe disc nu e atins.

Alternative echivalente:

BASH
git reset secrete.env           # reset pe un fișier = doar index
git reset                       # scoate tot din staging
git rm --cached secrete.env     # pentru un fișier deja urmărit: îl scoate și din următorul commit

Diferența importantă față de git rm --cached: restore --staged anulează doar add-ul de acum. rm --cached pune în staging ștergerea fișierului din repository, folosit când un fișier deja commituit nu mai trebuie urmărit.

Pentru a evita situația:

  • adaugi fișierul în .gitignore (*.env, .env.local);
  • folosești git add -p sau adaugi fișierele explicit;
  • verifici cu git status sau git diff --staged înainte de commit.

Dacă fișierul conținea o parolă și a ajuns deja în commit sau pe server, scoaterea din staging nu mai ajunge: secretul trebuie considerat compromis și rotit.

Ce urmărește intervievatorul: Întrebare simplă de bază. Verifică dacă știi diferența dintre a scoate din index și a șterge, două lucruri pe care începătorii le confundă.

Eroarea, în practică:Unstaged changes after reset:

59 Junior

Explică diferența dintre git reset --soft, --mixed și --hard pe exemplul git reset <mod> HEAD~1.

Răspuns scurt: Toate trei mută ramura curentă cu un commit înapoi. --soft păstrează modificările în staging, --mixed (implicit) le păstrează în working tree dar golește staging-ul, iar --hard le aruncă din index și de pe disc.

git reset face până la trei pași, iar modul spune unde se oprește:

  • mută ramura (și HEAD) pe commit-ul indicat;
  • copiază acel commit în index (--mixed, --hard);
  • copiază indexul în working tree (--hard).
                ramura   index    working tree
--soft          mutată   neatins  neatins
--mixed         mutată   resetat  neatins
--hard          mutată   resetat  resetat

Pe exemplu, după git reset <mod> HEAD~1:

  • --soft: ultimul commit „dispare”, dar modificările lui sunt în staging, gata pentru un commit nou. Util pentru refacerea mesajului sau combinarea mai multor commit-uri;
  • --mixed: modificările sunt în fișiere, dar neadăugate. Util când vrei să le împarți în mai multe commit-uri;
  • --hard: ramura și fișierele arată exact ca la HEAD~1. Ultimul commit e recuperabil prin git reflog, dar modificările necommitted din acel moment se pierd definitiv.
BASH
git reset --soft HEAD~1    # refaci ultimul commit
git reset HEAD~1           # --mixed implicit
git reset --hard HEAD~1    # arunci tot
git reset --hard origin/main  # aliniezi ramura locală cu serverul

Regula de siguranță: înainte de --hard, rulează git status. Dacă ai modificări de care nu ești sigur, fă git stash întâi.

reset rescrie istoricul ramurii, deci pe commit-uri deja împinse pe o ramură comună e de evitat; acolo se folosește git revert.

Ce urmărește intervievatorul: Întrebare de bază pentru repararea greșelilor. Intervievatorul vrea tabelul exact și avertismentul legat de --hard și modificările necommitted.

Eroarea, în practică:Unstaged changes after reset:

60 Junior

Ce face concret git revert și cum anulezi trei commit-uri consecutive cu un singur commit de revert?

Răspuns scurt: git revert creează un commit nou care aplică inversul modificărilor unui commit existent, fără să rescrie istoricul. Pentru mai multe commit-uri: git revert --no-commit A^..C, apoi un singur git commit cu un mesaj care explică anularea.

Dacă commit-ul a1b2c3 a adăugat o linie, git revert a1b2c3 creează un commit care o șterge:

BASH
git revert a1b2c3
# [main 9f8e7d6] Revert "Adaugă reducerea de Black Friday"
#  This reverts commit a1b2c3...

Istoricul doar crește, deci colegii fac pull normal, fără conflicte de rescriere. De aceea e varianta sigură pe ramurile comune.

Pentru trei commit-uri consecutive A, B, C (C cel mai nou):

BASH
git revert --no-commit A^..C
git status                       # modificările inverse, combinate, în staging
git commit -m "Revert: dezactivează modulul de reduceri (A..C)

Modulul calcula greșit prețurile pentru produsele la pachet."

--no-commit (-n) aplică inversul fără să facă commit-uri separate. Git le aplică în ordine inversă, de la C la A, ca să nu apară conflicte inutile. Fără -n, obții trei commit-uri de revert, câte unul pentru fiecare.

De reținut:

  • revert-ul poate produce conflicte, dacă după commit-ul anulat au urmat alte modificări în aceleași linii; le rezolvi ca la merge, apoi git revert --continue;
  • un revert nu „șterge” commit-ul din istoric: codul rămâne vizibil în git log, deci nu e o metodă pentru a elimina parole commituite;
  • pentru commit-uri de merge e nevoie de opțiunea -m, cu particularități proprii.

Ce urmărește intervievatorul: Verifică înțelegerea faptului că revert adaugă, nu șterge, și dacă știi să-l folosești pe intervale. Varianta cu --no-commit arată practică reală.

Eroarea, în practică:error: could not revert

61 Junior

Ce face git clean și de ce rulezi întâi git clean -n?

Răspuns scurt: git clean șterge fișierele untracked din working tree. -n (dry run) arată ce ar șterge, fără să șteargă; -f șterge efectiv, -d include folderele, -x include și fișierele ignorate. Fișierele șterse nu sunt în Git, deci nu pot fi recuperate din reflog.

BASH
git clean -n          # ce ar șterge (fișiere untracked)
git clean -nd         # inclusiv foldere
git clean -fd         # șterge efectiv fișiere și foldere untracked
git clean -fdx        # plus fișierele ignorate (node_modules, build, .env)
git clean -fdX        # doar fișierele ignorate
git clean -i          # mod interactiv, alegi ce ștergi

Implicit, Git refuză git clean fără -f (setarea clean.requireForce e activă), tocmai pentru că operația e ireversibilă: fișierele untracked nu au fost niciodată în index sau într-un commit, deci Git nu le are nicăieri.

Diferența dintre -x și varianta fără:

  • fără -x, fișierele din .gitignore sunt protejate. .env cu configurația locală rămâne;
  • cu -x, se șterg și ele. Util când vrei un working tree perfect curat, de exemplu pentru a reproduce un build de CI, dar îți poate șterge configurații locale și dependențe care durează mult la reinstalare.

Situații tipice:

  • după un merge sau un rebase anulat, au rămas fișiere .orig;
  • un generator de cod a creat fișiere în locuri greșite;
  • vrei să verifici că proiectul pornește de la zero.

Combinația „reset total la starea de pe server”:

BASH
git fetch origin
git reset --hard origin/main
git clean -fd

Rulează mereu -n întâi și citește lista.

Ce urmărește intervievatorul: Verifică respectul pentru operațiile ireversibile. Un candidat care rulează direct git clean -fdx poate șterge într-o secundă configurații și fișiere de lucru nesalvate.

Eroarea, în practică:clean.requireForce ... refusing to clean

62 Junior

Ce face git stash și care e diferența dintre stash pop și stash apply? Ce se întâmplă cu fișierele noi?

Răspuns scurt: git stash salvează modificările necommitted (working tree și index) într-o stivă și curăță working tree-ul. pop le reaplică și șterge intrarea din stivă, apply le reaplică dar păstrează intrarea. Fișierele untracked nu sunt incluse decât cu -u.

Fluxul tipic, când trebuie să schimbi rapid contextul:

BASH
git stash push -m "filtru produse, pe jumătate"
git switch main        # lucrezi la altceva
git switch -
git stash pop          # revii unde erai

Comenzile de bază:

BASH
git stash list                 # stash@{0}: On feature: filtru produse...
git stash show -p stash@{1}    # conținutul unui stash
git stash apply stash@{1}      # aplică, păstrează în stivă
git stash pop                  # aplică stash@{0} și îl șterge
git stash drop stash@{1}       # șterge unul
git stash clear                # le șterge pe toate, atenție

Diferența practică dintre pop și apply: dacă vrei să aplici aceleași modificări pe două ramuri, folosești apply. Dacă pop dă conflict, stash-ul nu e șters, ca să nu pierzi nimic; după rezolvare, îl ștergi cu git stash drop.

Fișierele noi:

  • implicit, stash-ul ia doar fișierele urmărite (modificate sau în index);
  • git stash -u (--include-untracked) include fișierele untracked;
  • git stash -a include și fișierele ignorate.

Capcana clasică: dai git stash, crezi că ai „curățat” tot, schimbi ramura, iar fișierul nou rămâne în working tree și ajunge într-un commit pe altă ramură.

Implicit, pop nu restaurează și starea indexului (ce era în staging redevine doar modificat); git stash pop --index o păstrează.

Ce urmărește intervievatorul: Verifică stăpânirea unei unelte zilnice. Detaliile despre -u și comportamentul la conflict separă utilizatorul ocazional de cel obișnuit.

Eroarea, în practică:local changes would be overwritten by checkoutlocal changes would be overwritten by merge

63 Junior

Ai șters din greșeală cu rm un fișier urmărit și încă nu ai făcut commit. Cum îl recuperezi? Dar dacă ștergerea a fost commituită acum trei commit-uri?

Răspuns scurt: Dacă ștergerea nu e commituită, git restore fișier îl readuce din index. Dacă a fost commituită, îl iei din commit-ul de dinaintea ștergerii: git restore --source=<hash>^ fișier, unde hash-ul îl găsești cu git log -- fișier.

Ștergere necommitted:

BASH
rm src/raport.js
git status -s
#  D src/raport.js
git restore src/raport.js       # sau: git checkout -- src/raport.js

Dacă ai dat și git rm (ștergerea e în staging, D ), ai nevoie de ambele zone:

BASH
git restore --staged --worktree src/raport.js

Ștergere commituită mai demult:

BASH
git log --oneline -1 -- src/raport.js
# 7c6b5a4 Elimină raportul vechi      <- commit-ul care l-a șters

git restore --source=7c6b5a4^ src/raport.js
git add src/raport.js
git commit -m "Readuce raportul lunar"

7c6b5a4^ înseamnă părintele commit-ului care l-a șters, deci ultima versiune în care fișierul exista. Dacă nu știi exact numele:

BASH
git log --diff-filter=D --name-only --oneline   # toate fișierele șterse

De ce merge: fișierul nu a dispărut din repository, doar din ultimele snapshot-uri. Orice versiune commituită rămâne accesibilă cât timp commit-ul e accesibil.

Alternativa, dacă tot commit-ul de ștergere a fost o greșeală și nu conținea altceva, e git revert 7c6b5a4. Dacă fișierul nu a fost niciodată commituit sau pus în staging, Git nu te poate ajuta; rămân doar istoricul local al editorului sau backup-urile sistemului.

Ce urmărește intervievatorul: Verifică dacă înțelegi că tot ce a fost commituit poate fi readus. Diferența dintre cazul commituit și cel necommitted arată dacă ai modelul celor trei zone clar.

64 Junior

Ai rulat git reset --hard HEAD~3 și ți-ai dat seama că ai nevoie de cele trei commit-uri. Cum le recuperezi?

Răspuns scurt: Folosești reflog-ul: git reflog arată pozițiile anterioare ale lui HEAD. Găsești intrarea dinainte de reset (de obicei HEAD@{1}) și rulezi git reset --hard HEAD@{1} sau creezi o ramură pe acel hash.

Reset-ul a mutat doar ramura. Commit-urile există în continuare în baza de obiecte, doar că nimic nu mai indică spre ele. Reflog-ul ține minte unde a fost HEAD:

BASH
git reflog
# 1a2b3c4 HEAD@{0}: reset: moving to HEAD~3
# 9f8e7d6 HEAD@{1}: commit: Adaugă testele
# 8e7d6c5 HEAD@{2}: commit: Adaugă butonul
# 7d6c5b4 HEAD@{3}: commit: Adaugă serviciul

Recuperarea:

BASH
git reset --hard HEAD@{1}       # ramura revine unde era
# sau, mai prudent:
git branch recuperare 9f8e7d6   # creezi o ramură, apoi decizi

Imediat după reset funcționează și git reset --hard ORIG_HEAD.

Variante ale reflog-ului:

BASH
git reflog show main            # doar mișcările ramurii main
git log -g --oneline            # reflog-ul în format log
git reflog --date=iso           # cu ora, util pentru „ce aveam azi la 10”

Limitele, importante de spus:

  • reflog-ul e local: nu există pe server și nici în clonele colegilor;
  • intrările expiră (implicit 90 de zile, 30 pentru commit-urile neaccesibile), după care git gc poate șterge commit-urile;
  • modificările necommitted din momentul reset --hard nu sunt în reflog și sunt pierdute.

De aceea reflog-ul te salvează după aproape orice greșeală cu commit-uri, dar nu după aruncarea unor fișiere nesalvate niciodată.

Ce urmărește intervievatorul: Întrebare clasică de „ziua greșelilor”. Verifică dacă știi de reflog și ce poate și ce nu poate recupera.

65 Mid

Ai șters cu git branch -D o ramură cu muncă neintegrată, iar terminalul s-a închis. Cum o recuperezi? Ce faci dacă nu o mai găsești nici în reflog?

Răspuns scurt: Cauți ultimul commit al ramurii în git reflog (intrările „checkout: moving from nume” sau commit-urile tale) și recreezi ramura cu git branch nume <hash>. Dacă reflog-ul nu ajută, git fsck --lost-found listează commit-urile neaccesibile (dangling), pe care le inspectezi cu git show.

Reflog-ul ramurii șterse dispare odată cu ea, dar reflog-ul lui HEAD rămâne. Dacă ai lucrat pe acea ramură, HEAD a trecut prin commit-urile ei:

BASH
git reflog | grep -A1 "moving from feature/raport"
# 1a2b3c4 HEAD@{5}: checkout: moving from feature/raport to main
# 3f2a9c1 HEAD@{6}: commit: Adaugă exportul raportului
git log --oneline -3 3f2a9c1      # verifici că e ce cauți
git branch feature/raport 3f2a9c1

Intrarea „moving from feature/raport to main” are hash-ul de după mutare, adică al lui main. Vârful ramurii e intrarea imediat mai veche (HEAD@{6}), ultimul commit făcut pe ea; verifică-l cu git show înainte să recreezi ramura.

Dacă ramura a fost doar descărcată și nu ai lucrat pe ea (HEAD n-a trecut prin ea), sau reflog-ul a fost curățat, rămâne baza de obiecte:

BASH
git fsck --lost-found
# dangling commit 3f2a9c1...
git show --stat 3f2a9c1

fsck găsește commit-urile la care nu mai indică nimic. Comanda pentru a le vedea pe toate, cu datele și mesajele:

BASH
git fsck --no-reflogs --unreachable | grep commit | cut -d' ' -f3 \
  | xargs git log --no-walk --oneline --date=iso

Alte surse:

  • dacă ramura a fost împinsă, există încă origin/feature/raport sau o poți readuce din PR (GitHub păstrează ramura PR-ului ca ref refs/pull/<n>/head);
  • un coleg care a făcut fetch o are local în origin/....

Odată ce git gc a șters obiectele neaccesibile (după expirarea reflog-ului și a termenului de prune), munca nu mai poate fi recuperată din Git.

Ce urmărește intervievatorul: Verifică capacitatea de a recupera date în situații dificile și cunoașterea limitelor. Candidații mid ar trebui să știe de fsck ca ultimă soluție.

66 Mid

Cum faci revert la un commit de merge? Ce problemă apare dacă mai târziu vrei să integrezi din nou aceeași ramură?

Răspuns scurt: Cu git revert -m 1 <merge>: -m 1 alege primul părinte ca linie principală, deci anulezi ce a adus ramura. Un merge ulterior al aceleiași ramuri nu mai aduce commit-urile vechi, considerate deja integrate; întâi trebuie să faci revert la revert.

Un commit de merge are doi părinți, deci „inversul” lui e ambiguu: față de care părinte? -m alege linia principală:

BASH
git log --oneline -1 M
git revert -m 1 M        # anulează ce a adus feature în main

-m 1 e aproape mereu corect când ai făcut merge stând pe main: primul părinte e main dinainte, deci revert-ul readuce codul la acea stare.

Problema de mai târziu: revert-ul anulează codul, nu și istoricul. Commit-urile ramurii rămân în main ca strămoși ai merge-ului. Echipa repară bug-ul pe feature și face din nou merge:

git merge feature

Git vede că C, D sunt deja în istoric și aplică doar commit-urile noi de pe feature. Modificările din C și D lipsesc în continuare, pentru că revert-ul le-a anulat. Rezultatul e o funcționalitate incompletă, fără niciun conflict.

Soluția este să anulezi revert-ul înainte de noul merge:

BASH
git revert R             # R = commit-ul de revert; readuce codul din C, D
git merge feature        # aduce corecturile noi

Alternativa: rebazezi ramura feature pe main cu commit-uri noi (de exemplu cu git rebase --no-ff sau --force-rebase), ca să aibă alte hash-uri, și o integrezi ca pe o ramură nouă.

Pe GitHub, butonul „Revert” de pe un PR integrat creează un PR cu acest revert; aceeași capcană se aplică la redeschiderea feature-ului.

Ce urmărește intervievatorul: Întrebare mid cu o capcană reală din producție. Candidatul care știe de „revert la revert” a trecut probabil prin situația asta.

Eroarea, în practică:commit ... is a merge but no -m option was given

67 Mid

Cum folosești stash-ul în situații mai complicate: doar o parte din fișiere, crearea unei ramuri dintr-un stash, conflicte la aplicare?

Răspuns scurt: Pentru o parte: git stash push -- cale sau git stash -p. Pentru o ramură: git stash branch nume stash@{n}, care pornește din commit-ul original al stash-ului, deci fără conflicte. La conflict, stash-ul rămâne în stivă până îl ștergi.

Doar anumite fișiere sau bucăți:

BASH
git stash push -m "doar CSS" -- src/styles/
git stash push -p                  # alegi interactiv hunk-urile
git stash push --staged            # doar ce e în index (Git 2.35+)
git stash push --keep-index        # salvează tot, dar lasă indexul neatins

--keep-index e util ca să testezi exact ce urmează să commit-uiești: modificările nepregătite dispar temporar, rulezi testele, apoi git stash pop.

Ramură dintr-un stash:

BASH
git stash branch feature/filtre stash@{2}

Creează ramura din commit-ul pe care erai când ai făcut stash, aplică modificările și șterge stash-ul dacă a mers. Pentru că baza e cea originală, nu apar conflicte, chiar dacă între timp main s-a schimbat mult. Soluția perfectă pentru un stash vechi de câteva săptămâni.

Conflicte la pop:

BASH
git stash pop
# CONFLICT (content): Merge conflict in src/app.js
# The stash entry is kept in case you need it again.

Rezolvi markerii, git add (sau git restore --staged dacă nu vrei fișierul în index), apoi git stash drop.

Recuperarea unui stash șters cu drop: stash-urile sunt commit-uri, deci un drop greșit se poate recupera:

BASH
git fsck --unreachable | grep commit
git stash apply <hash>

Pentru lucruri care trăiesc mai mult de o zi, un commit „wip” pe o ramură e mai sigur decât stash-ul: e vizibil, poate fi împins și nu se pierde într-o stivă.

Ce urmărește intervievatorul: Verifică stăpânirea stash-ului dincolo de push și pop. stash branch și recuperarea unui stash pierdut sunt detalii pe care le cunosc cei care l-au folosit intens.

Eroarea, în practică:could not restore untracked files from stash

68 Mid

Ce face git reset când îi dai un fișier, de exemplu git reset HEAD~2 -- config.js? De ce nu merge git reset --hard HEAD~2 -- config.js?

Răspuns scurt: Pe un fișier, reset nu mută ramura: copiază doar versiunea fișierului din commit-ul indicat în index, iar working tree-ul rămâne neatins. --hard și --soft nu au sens pe căi, deci Git refuză; pentru index și disc folosești git restore --source.

git reset are două moduri complet diferite:

  • cu commit, fără cale: mută ramura curentă (plus index și working tree, după mod);
  • cu cale: nu mută nimic; actualizează doar intrarea din index pentru acel fișier.
BASH
git reset HEAD~2 -- config.js
git status -s
# MM config.js

Rezultatul: în index e versiunea de acum două commit-uri, iar pe disc e versiunea ta curentă. git diff --staged arată diferența față de HEAD (revenirea la versiunea veche), iar git diff arată că fișierul de pe disc e încă cel nou. Un commit acum ar readuce versiunea veche, deși pe disc vezi alta.

Cazul cel mai folosit e git reset config.js (implicit HEAD), adică scoaterea din staging.

BASH
git reset --hard HEAD~2 -- config.js
# fatal: Cannot do hard reset with paths.

--soft cu cale nu are sens (nu ar face nimic), iar --hard ar însemna să suprascrii și fișierul, ceea ce Git consideră o operație de alt tip.

Echivalentele moderne, mai clare:

BASH
git restore --source=HEAD~2 --staged config.js            # ca reset pe fișier
git restore --source=HEAD~2 --staged --worktree config.js # index și disc
git checkout HEAD~2 -- config.js                           # varianta veche, index și disc

Pentru claritate în echipă: reset pentru ramuri, restore pentru fișiere.

Ce urmărește intervievatorul: Verifică înțelegerea fină a comenzii reset, care are comportamente diferite după argumente. Starea MM de după comandă îi surprinde pe mulți.

Eroarea, în practică:fatal: Cannot do hard reset with paths.

69 Senior

Un coleg a dat git push --force pe main și a șters commit-urile din ultimele două zile ale altor trei oameni. Cum gestionezi situația, tehnic și în echipă?

Răspuns scurt: Oprești push-urile pe main, identifici ultimul vârf bun din clonele cuiva (reflog-ul sau origin/main de dinainte de fetch) sau din platformă (evenimente, PR-uri integrate), restaurezi ramura cu push controlat, verifici cu CI și abia apoi pui branch protection care interzice force push pe main.

Model de răspuns în pași:

1. Stabilizare. Anunți echipa pe canalul comun: nimeni nu face pull, push sau fetch --prune pe main până la noi instrucțiuni. Un pull acum ar putea propaga starea greșită în clonele care încă au istoricul bun.

2. Găsirea vârfului corect. Orice clonă care a făcut fetch înainte de incident are vechiul vârf:

BASH
git reflog show origin/main
# a1b2c3d origin/main@{0}: fetch: forced-update
# 9f8e7d6 origin/main@{1}: fetch: fast-forward   <- starea bună

Alte surse: reflog-ul local al colegului care a dat force push (are ambele versiuni), commit-urile de merge ale PR-urilor din ultimele două zile (GitHub păstrează refs/pull/<n>/head și merge commit-urile), log-urile CI cu hash-ul ultimului build.

3. Reconstrucția. Dacă force push-ul conținea și commit-uri noi valide, faci o ramură din vârful vechi și integrezi peste ea commit-urile noi cu cherry-pick sau merge. Verifici cu git log vechi..nou și git log nou..vechi ce lipsește din fiecare.

4. Restaurarea. Pe o ramură temporară, cu CI verde, apoi:

BASH
git push --force-with-lease=main:a1b2c3d origin 9f8e7d6:main

Lease-ul garantează că suprascrii exact starea greșită cunoscută.

5. Resincronizarea colegilor: git fetch, apoi pentru cei cu muncă locală git rebase origin/main.

6. Prevenție, fără vinovați: branch protection pe main (fără force push, PR obligatoriu, status checks), --force-with-lease ca alias implicit, o scurtă analiză post-incident despre de ce a fost posibil.

Ce urmărește intervievatorul: Întrebare comportamentală și tehnică pentru senior. Verifică dacă poți coordona o recuperare calm, știi unde se află copiile istoricului și tratezi cauza prin proces, nu prin vină.

70 Senior

Ce poate și ce nu poate recupera Git? Explică limitele reflog-ului și ale garbage collection, plus cum recuperezi conținut care a fost doar în staging, niciodată commituit.

Răspuns scurt: Git recuperează orice obiect încă existent: commit-uri neaccesibile prin reflog sau fsck, chiar și blob-uri doar adăugate în index. Nu recuperează modificări care n-au ajuns niciodată în index sau într-un commit, nici obiecte deja șterse de gc.

Ce există în baza de obiecte:

  • orice commit făcut vreodată, inclusiv cele înlocuite prin amend, rebase, reset;
  • stash-urile (sunt commit-uri speciale);
  • orice blob creat de git add, chiar dacă nu a urmat niciun commit.

Limitele reflog-ului:

  • e local, pe fiecare clonă; serverul nu ți-l oferă;
  • gc.reflogExpire (implicit 90 de zile) pentru intrările accesibile și gc.reflogExpireUnreachable (implicit 30 de zile) pentru cele neaccesibile;
  • după expirare, git gc poate șterge obiectele neaccesibile mai vechi de gc.pruneExpire (implicit două săptămâni);
  • git gc --prune=now sau git reflog expire --expire=now --all șterg imediat, de aceea nu rulezi aceste comenzi în mijlocul unei recuperări.

Conținut doar în staging: ai dat git add, apoi git reset --hard. Blob-ul e încă în .git/objects, dar fără nume de fișier:

BASH
git fsck --lost-found
# dangling blob 4e5f6a7...
ls .git/lost-found/other/
git show 4e5f6a7 > recuperat.js

Trebuie să recunoști fișierul după conținut (grep -l prin lost-found/other/).

Ce nu poate recupera:

  • modificări niciodată adăugate în index sau într-un stash, pierdute prin restore, checkout --, reset --hard, clean -f;
  • obiecte deja curățate de gc.

Prima regulă la o recuperare serioasă: copiază întâi tot folderul .git (cp -r), ca să nu riști să declanșezi un gc automat care șterge exact ce cauți.

Ce urmărește intervievatorul: Întrebare senior despre modelul complet de date și siguranță. Detaliul cu blob-urile din staging recuperabile prin fsck e semnul unei înțelegeri profunde.

Eroarea, în practică:log for 'main' only has 4 entries

Remote-uri, fetch, pull, push și tag-uri

71 Junior

Ce este un remote și ce înseamnă origin? Cum vezi, adaugi și schimbi adresa unui remote?

Răspuns scurt: Un remote e un nume scurt pentru adresa altui repository, de obicei de pe GitHub sau GitLab. origin e numele dat implicit de git clone repository-ului din care ai clonat. Le gestionezi cu git remote -v, git remote add și git remote set-url.

Un remote e doar o intrare în .git/config:

[remote "origin"]
    url = git@github.com:firma/magazin.git
    fetch = +refs/heads/*:refs/remotes/origin/*

Linia fetch (refspec) spune că ramurile de pe server se copiază local ca origin/<nume>.

Comenzi:

BASH
git remote -v                               # lista, cu adresele de fetch și push
git remote add origin git@github.com:ana/proiect.git
git remote add upstream https://github.com/firma/proiect.git
git remote set-url origin git@github.com:firma/proiect-nou.git
git remote rename origin vechi
git remote remove vechi
git remote show origin                      # ramuri, tracking, stare

Situații tipice:

  • ai creat proiectul local cu git init și apoi un repository gol pe GitHub: git remote add origin <url>, apoi git push -u origin main;
  • repository-ul a fost mutat sau redenumit: set-url;
  • treci de la HTTPS la SSH: set-url cu adresa SSH;
  • la un fork: origin e copia ta, upstream e proiectul original.

origin nu are nimic special pentru Git în afară de faptul că e numele implicit la clonare. Poți avea oricâte remote-uri, iar un repository local fără niciun remote e perfect valid.

Remote-urile nu sunt sincronizate automat: nicio comandă nu contactează serverul în afară de fetch, pull, push, clone și ls-remote.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre repository-ul local și cel de pe server. Candidații care au lucrat doar cu clone nu știu de multe ori cum se conectează un proiect nou.

Eroarea, în practică:'origin' does not appear to be a git repositoryremote origin already exists

72 Junior

Ce face exact git clone? Ce ramuri locale ai după clonare?

Răspuns scurt: git clone creează un folder nou, copiază toate obiectele și referințele de pe server, configurează remote-ul origin, creează ramurile origin/* și face checkout pe o singură ramură locală, cea implicită a serverului (de obicei main), care urmărește origin/main.

BASH
git clone git@github.com:firma/magazin.git
git clone https://github.com/firma/magazin.git alt-nume

Pașii:

  • creează folderul și rulează git init în el;
  • adaugă remote-ul origin cu adresa dată;
  • face fetch: aduce toate commit-urile, ramurile (ca origin/main, origin/develop...) și tag-urile;
  • creează o ramură locală pentru ramura implicită a serverului și o leagă de origin/<ramura> (tracking);
  • face checkout pe ea.
BASH
git branch        # * main
git branch -a     # main, remotes/origin/HEAD -> origin/main, remotes/origin/develop ...

Ai deci o singură ramură locală, dar ai tot istoricul tuturor ramurilor. Pentru a lucra pe develop:

BASH
git switch develop   # creează automat develop din origin/develop, cu tracking

Opțiuni utile:

BASH
git clone -b release/2.3 <url>         # alt branch inițial
git clone --depth 1 <url>              # doar ultimul commit, rapid (shallow)
git clone --recurse-submodules <url>   # și submodulele
git clone --bare <url>                 # fără working tree, pentru servere sau mirror

Clonarea nu copiază: hook-urile locale, configurația locală a celui care a creat repository-ul, fișierele ignorate (de exemplu .env) și nimic din funcțiile platformei (issues, PR-uri). De aceea un proiect bun are un README cu pașii de configurare după clonare.

Ce urmărește intervievatorul: Verifică dacă înțelegi relația dintre ramurile locale și cele remote imediat după clonare. Greșeala tipică e să crezi că ai doar ramura main.

Eroarea, în practică:destination path already existsRemote branch not found in upstream origin

73 Junior

Care e diferența dintre git fetch și git pull? De ce mulți developeri preferă să facă fetch întâi?

Răspuns scurt: git fetch aduce commit-urile noi de pe server și actualizează ramurile origin/*, fără să atingă ramurile tale sau fișierele. git pull face fetch și apoi integrează imediat (merge sau rebase) în ramura curentă. Fetch întâi îți permite să vezi ce vine înainte să combini.

fetch e complet sigur: nu modifică nimic din ce lucrezi.

BASH
git fetch origin
git status
# Your branch is behind 'origin/main' by 3 commits, and can be fast-forwarded.

git log --oneline HEAD..origin/main     # ce au adus colegii
git diff HEAD...origin/main             # modificările lor, față de baza comună
git merge --ff-only origin/main         # sau git rebase origin/main

pull combină cei doi pași într-unul:

BASH
git pull               # fetch + merge (sau rebase, după configurare)
git pull --rebase
git pull --ff-only

De ce fetch întâi:

  • vezi ce s-a schimbat înainte să-ți afecteze ramura; dacă cineva a făcut un refactor mare, te pregătești pentru conflicte;
  • poți decide între merge, rebase sau așteptare;
  • git status arată „behind” corect doar după un fetch recent; fără el, Git compară cu ultima stare cunoscută, posibil veche de zile;
  • e potrivit în scripturi și CI, unde nu vrei integrări automate.

O confuzie frecventă: origin/main nu e serverul în timp real, ci o copie locală actualizată doar la fetch, pull sau push. Dacă un coleg a împins acum cinci minute și tu nu ai făcut fetch, git log origin/main nu arată commit-ul lui.

git fetch --all aduce de la toate remote-urile, iar git fetch --prune șterge copiile locale ale ramurilor șterse pe server.

Ce urmărește intervievatorul: Întrebare clasică de bază. Intervievatorul vrea să audă că fetch nu atinge munca locală și că origin/main e o copie locală.

Eroarea, în practică:Updates were rejected: remote contains workis not a commit and a branch cannot be created

74 Junior

Dai git push și primești ! [rejected] main -> main (fetch first). Ce înseamnă și care e soluția corectă?

Răspuns scurt: Serverul are commit-uri pe care tu nu le ai, iar push-ul tău le-ar șterge. Aduci întâi modificările (git pull --rebase sau fetch plus rebase ori merge), rezolvi conflictele, rulezi testele, apoi git push. Nu --force.

Mesajul complet:

! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'github.com:firma/magazin.git'
hint: Updates were rejected because the remote contains work that you do not have locally.

Serverul acceptă implicit doar push-uri fast-forward: vârful nou trebuie să conțină vârful vechi în istoric. Un coleg a împins între timp, deci istoriile au divergat:

server:  A---B---S1
local:   A---B---L1

Soluția:

BASH
git pull --rebase           # L1 devine L1' peste S1
# rezolvi conflictele, dacă apar, apoi git rebase --continue
npm test                    # verifici că totul merge și cu codul colegilor
git push

Sau, cu merge: git pull (creează un commit de merge), apoi git push.

Varianta (non-fast-forward) a mesajului apare când ai rescris local istoricul (amend, rebase) pe o ramură deja împinsă. Pe ramura ta de feature, rezolvarea e git push --force-with-lease. Pe o ramură comună, înseamnă că ai rescris istoric public și trebuie să te oprești.

Ce nu faci: git push --force ca reflex la orice respingere. Șterge commit-urile colegului (S1), iar el le va observa doar când nu le mai găsește.

Ca să eviți situația pe ramuri comune: integrezi prin pull request-uri, iar pe ramura ta faci fetch și rebase înainte de push.

Ce urmărește intervievatorul: Situație zilnică. Verifică dacă înțelegi de ce serverul refuză și dacă reflexul candidatului e să integreze, nu să forțeze.

Eroarea, în practică:Updates were rejected: remote contains worktip of your current branch is behind

75 Junior

Ce înseamnă că o ramură locală „urmărește” (tracking) o ramură remote? Ce face git push -u și ce înseamnă „ahead 2, behind 1”?

Răspuns scurt: O ramură cu upstream știe cu ce ramură de pe server se compară și unde fac push și pull fără argumente. git push -u origin feature împinge și setează upstream-ul. „Ahead 2, behind 1”: două commit-uri locale neîmpinse, unul nou pe server.

Prima publicare a unei ramuri noi:

BASH
git switch -c feature/cos
git push -u origin feature/cos     # -u = --set-upstream

De acum, în .git/config există:

[branch "feature/cos"]
    remote = origin
    merge = refs/heads/feature/cos

și poți scrie doar git push, git pull, git status.

BASH
git status -sb
# ## feature/cos...origin/feature/cos [ahead 2, behind 1]
git branch -vv
# * feature/cos 9f8e7d6 [origin/feature/cos: ahead 2, behind 1] Adaugă cuponul

Interpretare:

  • ahead 2: git log origin/feature/cos..HEAD are două commit-uri, de împins;
  • behind 1: git log HEAD..origin/feature/cos are un commit, de adus;
  • ambele în același timp: ramurile au divergat; rezolvi cu pull --rebase sau merge înainte de push.

Cifrele se bazează pe ultimul fetch, deci pot fi învechite.

Comenzi înrudite:

BASH
git branch -u origin/feature/cos       # setezi upstream unei ramuri existente
git branch --unset-upstream
git config --global push.autoSetupRemote true   # Git 2.37+: -u automat la primul push
git rev-parse --abbrev-ref @{u}        # numele upstream-ului

Cu push.autoSetupRemote, un simplu git push pe o ramură nouă creează ramura pe server și setează tracking-ul.

Ce urmărește intervievatorul: Verifică dacă știi să citești starea unei ramuri față de server, informație pe care o vezi zilnic în terminal și în IDE.

Eroarea, în practică:The current branch has no upstream branchThere is no tracking information

76 Junior

Ce diferență e între un tag lightweight și unul adnotat? Cum le trimiți pe server?

Răspuns scurt: Un tag lightweight e doar un nume care indică un commit. Unul adnotat (git tag -a) e un obiect separat, cu autor, dată, mesaj și opțional semnătură, recomandat pentru versiuni. Tag-urile nu se trimit automat: git push origin v1.2.0 sau git push --follow-tags.

BASH
git tag v1.2.0-test                         # lightweight: doar o referință
git tag -a v1.2.0 -m "Versiunea 1.2.0"      # adnotat: obiect tag
git tag -a v1.1.1 9f8e7d6 -m "Hotfix"       # pe un commit anume
git tag -s v1.2.0 -m "..."                  # adnotat și semnat (GPG sau SSH)

Diferența se vede cu:

BASH
git cat-file -t v1.2.0-test   # commit
git cat-file -t v1.2.0        # tag
git show v1.2.0               # autorul tag-ului, data, mesajul, apoi commit-ul

De ce adnotate pentru release-uri:

  • știi cine a marcat versiunea și când, separat de autorul commit-ului;
  • pot fi semnate, deci verificabile;
  • git describe le folosește implicit; tag-urile lightweight doar cu --tags;
  • multe unelte de release se bazează pe ele.

Lightweight sunt potrivite pentru marcaje temporare, personale.

Trimiterea pe server:

BASH
git push origin v1.2.0        # un tag
git push --follow-tags        # commit-urile plus tag-urile adnotate accesibile din ele
git push origin --tags        # toate tag-urile locale, inclusiv cele de test
git config --global push.followTags true

--tags e de evitat ca obicei, pentru că trimite și marcaje locale. Ștergerea:

BASH
git tag -d v1.2.0-test
git push origin --delete v1.2.0-test

Pe GitHub, un „Release” se construiește peste un tag și adaugă note și fișiere atașate.

Ce urmărește intervievatorul: Verifică practica de release. Faptul că tag-urile nu pleacă cu un push simplu îi surprinde pe mulți juniori.

Eroarea, în practică:the tag already exists in the remotefatal: tag already exists

77 Junior

Care e diferența dintre fork și clone? Cum îți ții fork-ul la zi cu proiectul original?

Răspuns scurt: Clone e o operație Git: copia unui repository pe calculatorul tău. Fork e o funcție a platformei: o copie a repository-ului în contul tău, unde ai drept de scriere. Îl ții la zi adăugând originalul ca remote upstream și aducând din el.

Fluxul de contribuție la un proiect în care nu ai drept de push:

  • faci fork pe GitHub: apare github.com/ana/proiect, copie a lui github.com/firma/proiect;
  • clonezi fork-ul tău local; origin indică fork-ul;
  • adaugi originalul ca upstream;
  • lucrezi pe o ramură, o împingi în fork și deschizi un pull request către proiectul original.
BASH
git clone git@github.com:ana/proiect.git
cd proiect
git remote add upstream https://github.com/firma/proiect.git
git remote -v

Sincronizarea:

BASH
git fetch upstream
git switch main
git merge --ff-only upstream/main     # main-ul tău nu trebuie să aibă commit-uri proprii
git push origin main

Pentru ramura de lucru, deschisă de mai mult timp:

BASH
git switch feature/doc
git rebase upstream/main
git push --force-with-lease origin feature/doc

Reguli bune:

  • nu faci commit-uri direct pe main în fork; îl păstrezi ca oglindă a lui upstream/main, ca sincronizarea să fie mereu fast-forward;
  • o ramură pentru fiecare PR;
  • GitHub are și butonul „Sync fork”, care face același lucru pe server.

În firme, fork-urile apar mai rar: echipa lucrează de obicei în același repository, cu ramuri și drepturi controlate prin branch protection. Fork-urile sunt specifice open source-ului și contribuțiilor externe.

Ce urmărește intervievatorul: Verifică dacă înțelegi separarea dintre unealtă și platformă și dacă ai contribuit vreodată la un proiect extern. Remote-ul upstream e detaliul așteptat.

Eroarea, în practică:error: No such remotePermission to ... denied to (403)

78 Mid

Care e diferența dintre git push --force și git push --force-with-lease? Ce adaugă --force-if-includes?

Răspuns scurt: --force suprascrie ramura de pe server indiferent ce e acolo. --force-with-lease o suprascrie doar dacă e încă unde o știi tu (origin/ramura), deci nu șterge munca altora. --force-if-includes (Git 2.30+) acoperă și cazul unui fetch făcut în fundal.

Ai făcut rebase pe ramura ta și trebuie să o rescrii pe server. Între timp, un coleg a împins un commit pe aceeași ramură.

BASH
git push --force

Commit-ul colegului dispare de pe server, fără avertisment.

BASH
git push --force-with-lease
# ! [rejected] feature -> feature (stale info)

Git a verificat: „ramura de pe server e la hash-ul pe care îl am în origin/feature?” Nu e, deci refuză. Faci git fetch, vezi commit-ul colegului, îl integrezi (rebase), apoi împingi din nou.

Breșa: dacă IDE-ul sau un alt proces face git fetch automat în fundal, origin/feature se actualizează la starea nouă, fără ca tu să fi integrat ceva. Lease-ul trece, iar commit-ul colegului e șters.

BASH
git push --force-with-lease --force-if-includes

--force-if-includes verifică în plus, prin reflog, că vârful de pe server a fost la un moment dat inclus în ramura ta locală, adică l-ai integrat efectiv.

Configurație recomandată:

BASH
git config --global alias.pushf "push --force-with-lease --force-if-includes"

Forma explicită, cea mai sigură, fixează hash-ul așteptat:

BASH
git push --force-with-lease=feature:9f8e7d6 origin feature

Indiferent de opțiune, pe ramurile comune (main, develop) force push-ul trebuie blocat de branch protection pe server.

Ce urmărește intervievatorul: Verifică dacă știi să rescrii istoric în siguranță. Detaliul cu fetch-ul în fundal și --force-if-includes distinge un mid atent.

Eroarea, în practică:tip of your current branch is behind

79 Mid

Ce sunt ramurile remote-tracking (origin/main) și de ce git branch -a arată ramuri care nu mai există pe server?

Răspuns scurt: origin/main e copia locală, read-only, a ultimei stări cunoscute a lui main de pe server, actualizată doar la fetch, pull sau push. Ramurile șterse pe server rămân local până la git fetch --prune, pentru că fetch-ul simplu nu șterge nimic.

Există trei lucruri cu nume asemănător:

  • main: ramura ta locală, pe care faci commit;
  • origin/main (refs/remotes/origin/main): copia locală a stării de pe server, mutată doar de comenzi de rețea;
  • main de pe server, pe care o vezi doar prin git ls-remote origin.

Nu poți face commit direct pe origin/main; git switch origin/main te pune în detached HEAD.

BASH
git branch -a
#   main
#   remotes/origin/feature/vechi     <- ștearsă pe server acum o lună
#   remotes/origin/main

git remote prune origin --dry-run
git fetch --prune
# - [deleted]  (none) -> origin/feature/vechi
git config --global fetch.prune true

De ce nu șterge implicit: fetch-ul a fost proiectat să fie aditiv și sigur, iar ștergerea automată a referințelor locale ar putea surprinde.

Atenție: --prune șterge doar origin/feature/vechi, nu și ramura ta locală feature/vechi. Pe cele locale al căror upstream a dispărut le găsești cu:

BASH
git branch -vv | grep ': gone]'

Pentru tag-uri, comportamentul diferă: fetch --prune nu le șterge implicit; există --prune-tags.

Câteva comenzi utile:

BASH
git ls-remote --heads origin        # ce ramuri sunt pe server acum
git remote show origin              # inclusiv „stale” pentru cele șterse

Ce urmărește intervievatorul: Verifică dacă înțelegi că ramurile remote sunt cache-uri locale. Mulți developeri au zeci de ramuri moarte în IDE și nu știu de ce.

Eroarea, în practică:is not a commit and a branch cannot be createdunable to delete: remote ref does not exist

80 Mid

Cum folosești tag-urile și git describe pentru versionare? De ce nu muți niciodată un tag deja publicat?

Răspuns scurt: Marchezi fiecare release cu un tag adnotat SemVer (v2.3.1), iar git describe dă pentru orice commit un identificator ca v2.3.1-4-g9f8e7d6, util în build-uri. Un tag publicat nu se mută: clonele care l-au preluat nu primesc versiunea nouă la fetch.

SemVer (MAJOR.MINOR.PATCH): MAJOR la schimbări incompatibile, MINOR la funcționalități compatibile, PATCH la corecturi.

BASH
git tag -a v2.3.1 -m "Corectează calculul TVA"
git push origin v2.3.1
git tag --list "v2.3.*" --sort=-v:refname   # sortare după versiune, nu alfabetic

git describe în build:

BASH
git describe --tags --always --dirty
# v2.3.1                      exact pe tag
# v2.3.1-4-g9f8e7d6           4 commit-uri după v2.3.1
# v2.3.1-4-g9f8e7d6-dirty     cu modificări necommitted

Ce înseamnă g: prefixul „git” dinaintea hash-ului. Acest șir intră în versiunea afișată în aplicație sau în numele artefactului, deci din orice bug report știi exact codul.

De ce nu muți un tag:

BASH
git tag -f v2.3.1 alt-commit
git push --force origin v2.3.1
  • cine a făcut deja fetch păstrează tag-ul vechi; Git nu suprascrie tag-uri existente la un fetch obișnuit;
  • două persoane, același nume de versiune, cod diferit; artefactele din registry nu mai corespund cu sursa;
  • sistemele de pachete (npm, Maven Central, Go proxy) și cache-urile CI păstrează versiunea veche.

Dacă release-ul a fost greșit, publici v2.3.2 cu corectura. GitHub și GitLab permit protejarea tag-urilor care respectă un tipar (v*) împotriva ștergerii și suprascrierii.

În CI, atenție: git clone --depth 1 nu aduce tag-urile vechi, iar describe eșuează; ai nevoie de fetch-depth: 0 sau git fetch --tags.

Ce urmărește intervievatorul: Verifică practica de release și trasabilitatea. Explicația „de ce nu muți tag-ul” separă pe cei care au gestionat versiuni reale.

Eroarea, în practică:the tag already exists in the remotefatal: tag already exists

81 Mid

Primești Permission denied (publickey) la git push. Ce diferență e între autentificarea prin SSH și HTTPS și cum depanezi?

Răspuns scurt: Eroarea e de SSH: serverul nu acceptă nicio cheie oferită. Verifici cu git remote -v adresa și cu ssh -T git@github.com dacă ai o cheie în agent, adăugată în cont. Pe HTTPS te autentifici cu un token, nu cu parola, salvat de un credential helper.

Două moduri de conectare:

  • SSH (git@github.com:firma/proiect.git): o pereche de chei; cea publică în contul tău de pe platformă, cea privată pe calculator. Fără parole la fiecare push;
  • HTTPS (https://github.com/firma/proiect.git): utilizator plus un personal access token (GitHub nu mai acceptă parola contului pentru Git din 2021) sau un login prin browser cu Git Credential Manager.

Depanarea erorii SSH, în ordine:

BASH
git remote -v                       # adresa e chiar SSH? către ce host?
ssh -T git@github.com               # „Hi ana! You've successfully authenticated”
ssh -vT git@github.com              # detaliat: ce chei încearcă
ls ~/.ssh                           # există id_ed25519 / id_ed25519.pub?
ssh-add -l                          # cheia e încărcată în agent?

Cauze frecvente:

  • nu există cheie: ssh-keygen -t ed25519 -C "ana@exemplu.ro", apoi adaugi conținutul .pub în setările contului;
  • cheia nu e în agent sau are alt nume: ssh-add ~/.ssh/cheia_mea sau o intrare în ~/.ssh/config;
  • ai două conturi (personal și firmă) și se oferă cheia greșită: aliasuri de host în ~/.ssh/config cu IdentityFile diferit;
  • firma cere SSO: cheia trebuie autorizată pentru organizație;
  • rețeaua blochează portul 22: GitHub acceptă SSH și pe ssh.github.com, portul 443.

Pentru HTTPS, tokenul se salvează cu git config --global credential.helper (osxkeychain pe macOS, manager pe Windows). Tokenul nu se pune niciodată în URL-ul remote-ului, unde ar apărea în .git/config și în loguri.

Ce urmărește intervievatorul: Problemă practică din prima zi la un job nou. Verifică dacă poți depana metodic, nu doar „regenerez cheia”.

Eroarea, în practică:Support for password authentication was removedPermission denied (publickey)

82 Senior

Repository-ul are câțiva GB și 15 ani de istoric, iar clonarea în CI durează minute. Ce opțiuni ai: shallow clone, partial clone, sparse-checkout? Ce compromisuri implică fiecare?

Răspuns scurt: Shallow clone (--depth 1) aduce doar ultimele commit-uri, rapid dar fără istoric, deci strică describe, merge-base și unele diff-uri. Partial clone (--filter=blob:none) aduce tot istoricul, dar descarcă fișierele la cerere. Sparse-checkout limitează working tree-ul la anumite foldere, util în monorepo-uri.

Shallow clone:

BASH
git clone --depth 1 --single-branch -b main <url>
git fetch --deepen 50          # mai adaugi istoric dacă e nevoie
git fetch --unshallow          # tot istoricul

Potrivit pentru build-uri care au nevoie doar de codul curent. Probleme: git describe nu găsește tag-uri, merge-base cu altă ramură poate eșua (contează la diff-uri de PR și la unelte care analizează doar fișierele schimbate), git log și blame sunt trunchiate. GitHub Actions face implicit fetch-depth: 1; pentru versionare din tag-uri ai nevoie de fetch-depth: 0.

Partial clone:

BASH
git clone --filter=blob:none <url>      # toate commit-urile și tree-urile, blob-uri la cerere
git clone --filter=tree:0 <url>         # și tree-urile la cerere (pentru CI efemer)

Istoricul e complet (log, merge-base, describe funcționează), iar conținutul fișierelor vechi se descarcă doar când îl ceri. Compromis: comenzi ca git log -p sau blame pe fișiere vechi fac cereri suplimentare la server. Necesită suport pe server (GitHub și GitLab îl au).

Sparse-checkout (cone mode):

BASH
git clone --filter=blob:none --sparse <url>
git sparse-checkout set services/plati libs/common

Working tree-ul conține doar folderele alese. Combinat cu partial clone, nici nu se descarcă blob-urile celorlalte foldere. Ideal în monorepo-uri, unde un serviciu are nevoie de o parte mică.

Complementar: cache-ul repository-ului pe runner, git maintenance pe mașinile de dezvoltare și, dacă dimensiunea vine din fișiere binare istorice, migrarea lor în Git LFS cu rescrierea istoricului.

Ce urmărește intervievatorul: Verifică experiența cu repository-uri mari și CI. Un senior știe ce comenzi se strică în fiecare variantă și alege după nevoile pipeline-ului.

Fluxuri de lucru, pull request-uri și code review

83 Junior

Descrie pașii GitHub Flow. De ce e potrivit pentru o aplicație web cu deploy continuu?

Răspuns scurt: O singură ramură permanentă, main, mereu gata de deploy. Pentru orice schimbare: ramură scurtă, commit-uri, pull request, review și teste verzi, merge în main, deploy. Se potrivește când ai o singură versiune în producție.

Pașii:

  • main e întotdeauna deployable; nimeni nu face commit direct pe ea;
  • creezi o ramură cu nume descriptiv: git switch -c fix/cos-gol;
  • faci commit-uri mici și împingi des (git push -u origin fix/cos-gol), ca munca să fie vizibilă;
  • deschizi devreme un pull request, eventual ca draft, ca să primești feedback din timp;
  • CI rulează testele, iar un coleg face review;
  • după aprobare, integrezi în main (merge, squash sau rebase, după convenția echipei);
  • main se publică automat sau imediat după;
  • ștergi ramura.

De ce se potrivește pentru aplicații web:

  • există o singură versiune în producție, deci nu ai nevoie de ramuri de release paralele;
  • schimbările mici și dese ajung repede la utilizatori și sunt ușor de anulat;
  • regulile sunt simple, așa că și juniorii le înțeleg în prima zi.

Când nu e de ajuns:

  • produse cu mai multe versiuni suportate simultan (aplicații instalabile, biblioteci): ai nevoie de ramuri de release sau de mentenanță;
  • echipe fără teste automate bune: „main mereu deployable” devine o promisiune goală.

Pentru funcționalități mari, care nu pot fi terminate într-o ramură scurtă, GitHub Flow se combină cu feature flags: codul ajunge în main dezactivat și se activează când e gata.

Ce urmărește intervievatorul: Verifică dacă știi un flux real de echipă și condițiile în care funcționează. Răspunsul bun leagă fluxul de tipul produsului.

84 Junior

Ce face un pull request bun? Ce scrii în descriere și cât de mare ar trebui să fie?

Răspuns scurt: Un PR bun face o singură schimbare logică, e destul de mic pentru un review atent și are titlu clar, descriere cu ce și de ce, pași de testare, link la ticket și capturi pentru UI. CI-ul e verde înainte să ceri review.

Ce urmărește un reviewer:

  • o singură temă: un bug, o funcționalitate, un refactor. Refactorul și funcționalitatea nouă în același PR fac review-ul aproape imposibil;
  • mărime rezonabilă: un PR mic primește un review atent; unul uriaș primește un „LGTM” superficial. Dacă schimbarea e mare, o spargi în PR-uri succesive sau înlănțuite;
  • istoric curat (dacă echipa nu folosește squash): commit-uri cu sens, fără „wip” și „fix typo”.

O descriere utilă:

Corectează totalul coșului când se aplică două vouchere

De ce: totalul putea deveni negativ (ticket SHOP-482).
Ce: reducerile se aplică în ordine fixă, iar totalul are minim 0.
Cum testezi: adaugă în coș produsul X, aplică VOUCHER10 și VOUCHER50.
Riscuri: atinge calculul comenzii; testele de integrare acoperă cazul.

Plus:

  • capturi de ecran sau un GIF pentru schimbări vizuale;
  • note pentru reviewer: „fișierul X e doar mutat, poți sări peste el”;
  • migrări de bază de date sau configurări noi menționate explicit.

Înainte să ceri review:

  • citești tu diff-ul complet în interfața platformei; prinzi loguri uitate și fișiere care nu trebuiau;
  • CI-ul e verde și ramura e la zi cu main;
  • folosești Draft PR cât timp lucrul nu e gata.

După comentarii, răspunzi la fiecare: fie modifici, fie explici de ce nu.

Ce urmărește intervievatorul: Verifică dacă ai lucrat în echipă și respecți timpul colegilor. PR-urile uriașe fără descriere sunt una dintre cele mai frecvente plângeri despre juniori.

85 Junior

Pe GitHub ai trei butoane la integrarea unui PR: „Create a merge commit”, „Squash and merge” și „Rebase and merge”. Ce produce fiecare în istoricul lui main?

Răspuns scurt: Merge commit păstrează commit-urile ramurii și adaugă un commit de merge cu doi părinți. Squash and merge le combină într-un singur commit nou. Rebase and merge le reaplică liniar pe main, fără commit de merge. Ultimele două creează hash-uri noi.

Ramura PR-ului are trei commit-uri: a, b, c.

Create a merge commit (ca git merge --no-ff):

---o---o-------M   main
        \     /
         a-b-c
  • păstrează tot istoricul și granițele PR-ului;
  • git revert -m 1 M anulează PR-ul întreg;
  • istoricul lui main devine mai greu de citit, dar git log --first-parent arată doar merge-urile.

Squash and merge:

---o---o---S   main
  • un commit pe PR, cu mesaj compus din titlu și descriere;
  • istoric liniar, ușor de revertat și de citit;
  • se pierd pașii intermediari; ramura locală nu apare ca integrată, deci o ștergi cu -D.

Rebase and merge:

---o---o---a'---b'---c'   main
  • istoric liniar, păstrând fiecare commit;
  • commit-urile au hash-uri noi, deci nu corespund cu cele din ramura ta;
  • are sens doar dacă fiecare commit e curat și compilează.

Cum alegi:

  • echipe cu PR-uri mici și commit-uri dezordonate: squash;
  • proiecte unde commit-urile atomice contează: rebase sau merge commit;
  • nevoie de urmărirea exactă a ce PR a adus ce: merge commit sau squash cu numărul PR-ului în mesaj.

Administratorii pot dezactiva unele variante din setările repository-ului, pentru un istoric consecvent.

Ce urmărește intervievatorul: Verifică dacă înțelegi efectele asupra istoricului ale opțiunilor folosite zilnic. Candidații trebuie să poată justifica alegerea pentru echipă.

86 Junior

Ți se cere să faci code review la PR-ul unui coleg mai experimentat. Cum procedezi și cum formulezi comentariile?

Răspuns scurt: Înțelegi întâi scopul din descriere și ticket, apoi citești codul în ordine logică, rulezi local dacă e nevoie. Verifici corectitudinea, testele, cazurile limită și lizibilitatea. Formulezi comentarii specifice și politicoase, sub formă de întrebări sau sugestii, marcând clar ce e blocant și ce e opțional.

Model de răspuns structurat:

1. Context. Citești descrierea PR-ului și ticket-ul. Fără să știi ce trebuie să facă codul, nu poți spune dacă e corect.

2. Imaginea de ansamblu. Te uiți la lista de fișiere și la structură: abordarea are sens? Dacă ai o obiecție de design, o spui întâi, înainte de detalii.

3. Detaliile. Pentru fiecare fișier:

  • face ce spune descrierea? cazuri limită (null, liste goale, erori de rețea)?
  • există teste pentru comportamentul nou?
  • nume clare, duplicare, cod mort, loguri uitate;
  • securitate: date de la utilizator, secrete, permisiuni.

4. Rulare locală când schimbarea e greu de evaluat din diff:

BASH
git fetch origin pull/482/head:pr-482    # pe GitHub
git switch pr-482

5. Comentariile. Despre cod, nu despre persoană; specifice; cu motivul:

nit: aș redenumi `d` în `dataLivrare`, e folosit în 3 locuri.

Întrebare: ce se întâmplă dacă API-ul întoarce 0 produse?
Nu văd un test pentru cazul ăsta.

Blocant: parola de test din config.js ajunge în repository.

Prefixe ca „nit” (detaliu minor) sau „blocant” arată importanța. Laudă ce e bine făcut. Dacă discuția se lungește, treci la o conversație directă.

Faptul că autorul are mai multă experiență nu înseamnă că nu poți comenta: întrebările unui junior găsesc des părți neclare. Review-ul e și o metodă de învățare.

Ce urmărește intervievatorul: Întrebare comportamentală despre colaborare. Verifică maturitatea și tonul, nu doar ochiul tehnic.

87 Mid

Cum funcționează Git flow? Ce rol au ramurile develop, release/* și hotfix/* și când e o alegere bună sau proastă?

Răspuns scurt: Git flow are două ramuri permanente: main, cu versiunile lansate și tag-uite, și develop, unde se integrează feature-urile. Din develop pornesc release/* pentru stabilizare, din main hotfix/* pentru urgențe. Potrivit pentru release-uri planificate, nu pentru deploy continuu.

Ramurile:

  • main: doar versiuni lansate; fiecare merge primește tag (v2.4.0);
  • develop: integrarea continuă a muncii;
  • feature/*: pornesc din develop și se întorc în develop;
  • release/2.4: pornește din develop când setul de funcționalități e complet; aici se fac doar corecturi, versiune, changelog; la final se integrează în main (cu tag) și în develop;
  • hotfix/2.4.1: pornește din main, repară o problemă din producție, se integrează în main (tag nou) și în develop (sau în release dacă există unul activ).
BASH
git switch -c release/2.4 develop
# corecturi, bump de versiune
git switch main && git merge --no-ff release/2.4 && git tag -a v2.4.0 -m "2.4.0"
git switch develop && git merge --no-ff release/2.4

Când are sens:

  • aplicații mobile sau desktop, cu release-uri planificate și o perioadă de testare;
  • produse livrate clienților, cu cicluri de versiuni;
  • echipe cu QA manual înainte de fiecare lansare.

Când e o alegere proastă:

  • aplicații web cu deploy de mai multe ori pe zi: develop și release adaugă întârziere fără beneficii;
  • ramuri de feature de lungă durată care duc la merge-uri dureroase;
  • dublarea fiecărui fix în mai multe ramuri crește riscul de a uita una.

Autorul modelului (Vincent Driessen) a adăugat el însuși în 2020 o notă că, pentru software livrat continuu, un flux mai simplu precum GitHub Flow e de preferat.

Ce urmărește intervievatorul: Verifică dacă știi structura detaliată a unui model clasic și, mai ales, dacă poți judeca potrivirea lui. Aplicarea Git flow peste tot e semn de lipsă de experiență.

88 Mid

În producție e versiunea v3.2.0, iar pe main sunt deja funcționalități neterminate pentru 3.3. Clienții raportează un bug grav. Cum livrezi fix-ul fără să lansezi și codul nou?

Răspuns scurt: Creezi o ramură de hotfix din tag-ul v3.2.0, repari bug-ul acolo cu un test, marchezi v3.2.1 și o publici. Apoi aduci fix-ul și pe main, prin cherry-pick sau merge, ca bug-ul să nu reapară în 3.3.

BASH
git fetch --tags
git switch -c hotfix/3.2.1 v3.2.0       # baza: exact ce e în producție
# reproduci bug-ul cu un test, apoi repari
git commit -am "fix(plata): evită dublarea plății la retry"
git tag -a v3.2.1 -m "Hotfix: dublarea plății"
git push origin hotfix/3.2.1 v3.2.1

Pipeline-ul construiește și publică v3.2.1 din tag. Producția primește doar fix-ul.

Aducerea pe main:

BASH
git switch main
git cherry-pick -x <hash-fix>
# sau, dacă hotfix-ul are mai multe commit-uri:
git merge --no-ff hotfix/3.2.1

Ordinea alternativă, preferată în multe echipe trunk-based: fix-ul se face întâi pe main (prin PR, cu review), apoi se cherry-pick-uiește pe ramura de release. Avantaj: nu uiți niciodată să-l aduci în main, cea mai frecventă greșeală a hotfix-urilor.

Detalii care contează:

  • verifici că fix-ul nu depinde de cod existent doar pe main; de aceea se scrie direct pe baza v3.2.0;
  • dacă există deja o ramură release/3.3 în stabilizare, fix-ul ajunge și acolo;
  • mesajul și changelog-ul menționează problema, pentru suport;
  • după lansare, monitorizezi că eroarea a dispărut.

Dacă echipa ține o ramură permanentă release/3.2, pornești de acolo în loc de tag. Esențial e principiul: baza hotfix-ului e codul aflat efectiv în producție, nu main.

Ce urmărește intervievatorul: Scenariu realist pentru mid. Verifică dacă alegi baza corectă și nu uiți să aduci fix-ul și pe linia principală.

89 Mid

Ramura ta de feature a rămas cu două săptămâni în urmă față de main, iar PR-ul are conflicte în fișiere modificate de alți doi colegi. Cum procedezi?

Răspuns scurt: Aduc main la zi, decid între rebase (dacă ramura e doar a mea) și merge (dacă e partajată), rezolv conflictele cu înțelegerea intenției colegilor, consultându-i unde nu e clar, rulez testele și împing cu --force-with-lease. Apoi integrez mai des pe viitor.

Model de răspuns:

1. Evaluez situația:

BASH
git fetch origin
git log --oneline HEAD..origin/main      # ce s-a schimbat pe main
git diff --stat HEAD...origin/main
git log origin/main -- src/cos/          # cine a atins fișierele în conflict

Citesc commit-urile și PR-urile colegilor care au atins aceleași fișiere, ca să le înțeleg intenția înainte de a vedea conflictele.

2. Aleg metoda:

  • ramura e doar a mea: git rebase origin/main. Rezolv conflictele commit cu commit; cu multe commit-uri, întâi le pot combina, ca să rezolv o dată;
  • ramura e folosită și de alții: git merge origin/main în ramură, fără rescriere.

merge.conflictStyle zdiff3 și rerere ajută.

3. Rezolv cu atenție: pentru fiecare conflict, mă întreb ce a vrut colegul și ce am vrut eu. Unde nu e clar, scriu colegului: „În CosService ai mutat calculul reducerii; am adaptat codul meu să-l folosească, poți să arunci o privire?”

4. Verific: build, teste, rulare locală a fluxului atins. Un merge fără conflicte textuale poate avea totuși conflicte semantice.

5. Public și comunic:

BASH
git push --force-with-lease     # după rebase

În PR scriu un comentariu scurt despre ce am adaptat și cer din nou review pentru zona afectată.

6. Prevenție: actualizez ramura de câteva ori pe săptămână, sparg funcționalitatea în PR-uri mai mici și, dacă e cazul, integrez codul neterminat în spatele unui feature flag.

Ce urmărește intervievatorul: Întrebare comportamentală cu componentă tehnică. Verifică dacă tratezi conflictele ca pe o problemă de comunicare, nu doar de text.

90 Senior

Ce reguli ai configura pe GitHub sau GitLab pentru ramura main a unui produs cu zece developeri? Explică rolul fiecăreia.

Răspuns scurt: Branch protection (rulesets) cu: PR obligatoriu, minim o aprobare și aprobare de la CODEOWNERS pentru zone sensibile, status checks obligatorii (build, teste, lint), ramura la zi sau merge queue, fără force push și fără ștergere, conversații rezolvate, opțional commit-uri semnate și istoric liniar.

Regulile, cu motivul fiecăreia:

  • PR obligatoriu, fără push direct: orice schimbare trece prin review și CI. Administratorii incluși, altfel regula are o ușă din spate;
  • aprobări: minim una; aprobările vechi se anulează la commit-uri noi („dismiss stale approvals”), ca să nu se strecoare cod nerevizuit după aprobare;
  • CODEOWNERS: fișierul definește cine aprobă obligatoriu anumite foldere:
/infra/            @firma/platform
/src/plati/        @firma/echipa-plati
*.sql              @firma/dba
  • status checks obligatorii: build, teste, lint, scanare de securitate; fără ele, butonul de merge e blocat;
  • ramura la zi înainte de merge sau, mai bine la volum mare, merge queue: PR-urile sunt testate pe rezultatul combinat cu main, în ordine, ca două PR-uri verzi separat să nu strice împreună build-ul;
  • fără force push și fără ștergere pe main;
  • conversații rezolvate înainte de merge;
  • istoric liniar (doar squash sau rebase), dacă echipa a ales asta;
  • commit-uri semnate (GPG, SSH sau S/MIME) în medii cu cerințe de audit;
  • protecția tag-urilor v*, ca versiunile publicate să nu poată fi mutate.

Pe lângă reguli:

  • CONTRIBUTING.md cu convențiile;
  • template de PR cu secțiunile cerute;
  • scanare de secrete (push protection pe GitHub) activată.

Regulile nu trebuie să devină birocrație: o aprobare e suficientă pentru majoritatea schimbărilor, iar situațiile de urgență au un proces documentat, nu dezactivarea temporară a protecției.

Ce urmărește intervievatorul: Verifică experiența de a configura procesul pentru o echipă. Un senior explică ce problemă rezolvă fiecare regulă, inclusiv merge queue și anularea aprobărilor vechi.

Eroarea, în practică:GH006: Protected branch update failed

91 Senior

Echipa vrea să treacă la trunk-based development, dar unele funcționalități durează câteva săptămâni. Cum integrezi zilnic cod neterminat în main fără să afectezi utilizatorii?

Răspuns scurt: Prin feature flags: codul nou ajunge în main, dar e oprit în producție până e gata, activat doar pentru echipă sau pentru un procent de utilizatori. Se completează cu tehnica branch by abstraction pentru refactorizări mari, ramuri foarte scurte și curățarea flag-urilor după lansare.

Principiul trunk-based: toată lumea integrează în main cel puțin zilnic, prin ramuri care trăiesc ore sau o zi. Problema e codul care nu e gata. Soluțiile:

Feature flags. Codul nou rulează doar dacă flag-ul e activ:

TypeScript
if (flags.isEnabled("checkout-nou", user)) {
  return renderCheckoutNou();
}
return renderCheckoutVechi();
  • flag-urile vin din configurație sau dintr-un serviciu dedicat (de exemplu LaunchDarkly, Unleash, OpenFeature ca standard);
  • activare treptată: echipa internă, apoi un procent, apoi toți;
  • dezactivare instantanee la probleme, fără revert și fără deploy.

Branch by abstraction, pentru înlocuirea unei componente mari: introduci o interfață, muți codul vechi în spatele ei, construiești implementarea nouă în paralel, comuți, apoi ștergi vechiul. Fiecare pas e un PR mic, integrat imediat.

Dark launching: codul nou rulează în paralel cu cel vechi, fără efect vizibil, ca să compari rezultatele.

Disciplina necesară:

  • teste rulate pe ambele stări ale flag-ului, cel puțin pentru căile critice;
  • fiecare flag are un responsabil și o dată de eliminare; flag-urile uitate devin datorie tehnică și combinații netestate;
  • PR-uri mici, review rapid (în aceeași zi), CI rapid; altfel ramurile se lungesc din nou;
  • main mereu verde: un build roșu se repară sau se revertează imediat.

Pentru lansări de versiuni, echipele trunk-based taie ramuri de release scurte din main și aplică doar cherry-pick-uri de fix-uri pe ele.

Ce urmărește intervievatorul: Verifică dacă poți face trunk-based development să funcționeze în practică, nu doar să-l definești. Feature flags și disciplina de curățare sunt ce caută intervievatorul.

92 Senior

Intri într-o echipă care face commit-uri direct pe main, cu mesaje ca „fix” și „update”, fără review. Cum ai introduce un flux de lucru mai bun fără să blochezi livrările?

Răspuns scurt: Încep prin a înțelege de ce lucrează așa, propun schimbări mici, una câte una, cu beneficiul explicat: întâi PR-uri și CI, apoi branch protection, apoi convenții de mesaje automatizate. Documentez, dau exemple prin propriul lucru și măsor dacă problemele (bug-uri, rollback-uri) scad.

Model de răspuns:

1. Observ înainte să schimb. Două-trei săptămâni lucrez ca ei și înțeleg constrângerile: deploy-uri urgente, oameni puțini, lipsă de teste. Adun exemple concrete de probleme cauzate de lipsa procesului: un bug ajuns în producție pe care un review l-ar fi prins, ore pierdute căutând ce commit a stricat ceva.

2. Propun puțin, cu beneficiu clar. Într-o discuție de echipă propun un singur pas: „Încercăm două săptămâni ca fiecare schimbare să treacă printr-un PR cu un review, chiar și scurt”. Ofer să fac eu primele review-uri rapid, ca să nu încetinesc pe nimeni.

3. Automatizez în loc să cer disciplină:

  • CI care rulează build-ul și testele existente pe fiecare PR;
  • branch protection pe main, după ce echipa a acceptat fluxul;
  • template de PR cu trei întrebări (ce, de ce, cum testezi);
  • formatter și linter în pre-commit;
  • convenția de mesaje verificată pe titlul PR-ului, cu squash merge, ca istoricul lui main să devină curat fără efort individual.

4. Documentez scurt. O pagină în CONTRIBUTING.md: cum numim ramurile, cum facem PR-ul, cine aprobă, ce facem în urgențe (un hotfix poate fi aprobat după merge, dar tot prin PR).

5. Dau exemplu. PR-urile mele sunt mici, cu descrieri bune, iar review-urile mele sunt rapide și respectuoase.

6. Revin după o lună cu echipa: ce a ajutat, ce a încurcat, ajustăm.

Ce evit: să impun peste noapte Git flow complet sau reguli fără explicație. Procesul e acceptat când oamenii simt că îi ajută.

Ce urmărește intervievatorul: Întrebare comportamentală de senior despre influență și schimbare. Verifică dacă poți îmbunătăți procesul gradual, cu empatie, nu prin impunere.

Unelte avansate: bisect, blame, hooks, submodule, fișiere mari, secrete

Exersează capitolul cu exerciții reale: Curs Git online →
93 Junior

Ce face git blame și cum îl folosești ca să afli de ce o linie de cod arată așa, nu doar cine a scris-o?

Răspuns scurt: git blame fișier arată, pentru fiecare linie, commit-ul, autorul și data ultimei modificări. Folosești hash-ul găsit cu git show ca să citești mesajul și diff-ul complet, eventual PR-ul. Opțiunile -w, -C și --ignore-revs-file sar peste reformatări și mutări de cod.

BASH
git blame src/plati/tva.js
git blame -L 40,60 src/plati/tva.js        # doar liniile 40-60
git blame -L :calculeazaTVA src/plati/tva.js  # doar o funcție

Fiecare linie arată hash-ul, autorul, data și conținutul. Scopul real e motivul, nu vinovatul:

BASH
git show 7c6b5a4               # mesajul și diff-ul complet
git log --oneline -1 7c6b5a4   # subiectul; deseori conține numărul PR-ului

Problema frecventă: blame-ul arată un commit de reformatare sau de mutare a codului, nu schimbarea reală. Opțiuni:

BASH
git blame -w fisier            # ignoră schimbările de spații
git blame -M fisier            # detectează linii mutate în același fișier
git blame -C fisier            # și linii mutate din alte fișiere
git blame --ignore-rev a1b2c3 fisier
git blame --ignore-revs-file .git-blame-ignore-revs fisier
git config blame.ignoreRevsFile .git-blame-ignore-revs

Fișierul .git-blame-ignore-revs conține hash-urile commit-urilor de formatare în masă; GitHub îl folosește automat în vizualizarea blame.

Ca să sari înapoi peste un commit și să vezi versiunea anterioară a liniei:

BASH
git blame 7c6b5a4^ -- src/plati/tva.js

IDE-urile (VS Code cu GitLens, IntelliJ „Annotate with Git Blame”) oferă același lucru vizual.

Numele comenzii sună acuzator, dar în echipele sănătoase e folosită pentru context: autorul îți poate explica decizia, iar mesajul de commit bun îți poate răspunde fără să-l mai întrebi.

Ce urmărește intervievatorul: Verifică dacă știi să investighezi istoria codului. Candidații care se opresc la „cine a scris” ratează scopul: înțelegerea motivului.

94 Mid

Știi că acum o lună versiunea v4.0.0 funcționa, iar acum un test de integrare pică. Între ele sunt 600 de commit-uri. Cum automatizezi găsirea commit-ului vinovat cu git bisect?

Răspuns scurt: Pornești git bisect start HEAD v4.0.0, apoi git bisect run ./test.sh: Git face căutare binară și rulează scriptul la fiecare pas, interpretând codul de ieșire (0 bun, 1–127 rău, 125 sari). În aproximativ 10 pași afli commit-ul care a introdus eroarea.

Căutarea binară înjumătățește intervalul la fiecare pas: pentru 600 de commit-uri sunt necesari în jur de 10 pași (log2 600 ≈ 9,2).

BASH
git bisect start HEAD v4.0.0      # rău, apoi bun
git bisect run ./scripts/bisect-test.sh

Scriptul:

BASH
#!/bin/sh
npm ci --silent || exit 125            # nu se poate construi: sari peste commit
npx jest tests/comanda.int.test.js     # 0 = bun, 1 = rău

Codurile de ieșire interpretate de bisect run:

  • 0: commit bun;
  • 1–127, cu excepția lui 125: commit rău;
  • 125: nu se poate testa, Git alege alt commit din apropiere;
  • peste 127 (sau semnal): bisect-ul se oprește.

La final:

9f8e7d6 is the first bad commit
git bisect log > bisect.log        # pașii, pentru colegi
git bisect reset                   # înapoi unde erai

Detalii care contează:

  • testul trebuie să fie determinist; un test instabil dă rezultate false și duce la commit-ul greșit;
  • dacă testul nu exista acum o lună, ține-l în afara repository-ului (de exemplu în /tmp), ca să nu dispară la checkout;
  • cu multe merge-uri, git bisect start --first-parent (Git 2.29+) testează doar commit-urile de pe linia principală, găsind PR-ul vinovat;
  • pentru o proprietate care nu e „bug”, poți folosi termeni proprii: git bisect start --term-old=lent --term-new=rapid.

Valoarea bisect-ului crește cu cât commit-urile sunt mai mici și fiecare compilează.

Ce urmărește intervievatorul: Verifică dacă știi să automatizezi depanarea în istoric. Codul de ieșire 125 și cerința testului determinist arată folosire reală.

95 Mid

Ce sunt Git hooks? Cum te asiguri că toată echipa rulează aceleași hook-uri, având în vedere că .git/hooks nu se versionează?

Răspuns scurt: Hook-urile sunt scripturi rulate la evenimente: pre-commit, commit-msg, pre-push pe client, pre-receive pe server. Cum .git/hooks nu se clonează, le ții într-un folder versionat, activat cu core.hooksPath, husky sau pre-commit, iar regulile critice le verifici și în CI.

Hook-uri client folosite des:

  • pre-commit: rulează înainte de commit; formatare, lint pe fișierele din staging, detectarea secretelor;
  • commit-msg: verifică mesajul (de exemplu Conventional Commits);
  • pre-push: teste rapide înainte de push;
  • post-checkout, post-merge: de exemplu reinstalarea dependențelor dacă s-a schimbat lockfile-ul.

Un hook e un fișier executabil cu numele evenimentului; dacă se termină cu cod diferit de 0, operația e oprită.

BASH
#!/bin/sh
# .githooks/pre-commit
files=$(git diff --cached --name-only --diff-filter=ACM -- '*.js')
[ -z "$files" ] && exit 0
npx eslint $files

Distribuirea în echipă:

BASH
git config core.hooksPath .githooks     # o dată, după clonare

sau unelte care fac configurarea automat:

  • husky (proiecte JavaScript), configurat la npm install, plus lint-staged pentru a rula doar pe fișierele modificate;
  • framework-ul pre-commit (Python, dar multi-limbaj), cu .pre-commit-config.yaml;
  • lefthook, independent de limbaj.

Limita importantă: hook-urile client pot fi ocolite cu git commit --no-verify sau pur și simplu neinstalate. Sunt o comoditate pentru feedback rapid, nu o garanție. Regulile obligatorii se verifică și în CI sau pe server: pre-receive pe un server propriu, ori rulesets și push protection pe GitHub și GitLab.

Hook-urile trebuie să fie rapide (câteva secunde); un pre-commit care rulează toate testele va fi ocolit de toată lumea.

Ce urmărește intervievatorul: Verifică dacă știi să automatizezi calitatea și înțelegi limita hook-urilor locale. Răspunsul fără mențiunea despre CI e incomplet.

96 Mid

Ce sunt submodulele Git, cum lucrezi cu ele și ce probleme apar des? Când ai alege altceva?

Răspuns scurt: Un submodul e alt repository inclus într-un folder și fixat la un commit; părintele reține doar hash-ul. Clonezi cu --recurse-submodules și actualizezi explicit. Probleme tipice: foldere goale, versiuni fixate greșit, detached HEAD. Alternative: pachete, subtree, monorepo.

BASH
git submodule add https://github.com/firma/design-tokens.git libs/tokens
git commit -m "Adaugă design-tokens ca submodul"

Se creează .gitmodules (adresa și calea) și o intrare specială în tree (mod 160000), care conține hash-ul unui commit din celălalt repository, nu fișierele.

Lucrul de zi cu zi:

BASH
git clone --recurse-submodules <url>
git submodule update --init --recursive   # dacă ai clonat fără
git submodule update --remote libs/tokens # aduce ultimul commit din ramura urmărită
git add libs/tokens && git commit -m "Actualizează tokens"
git config --global submodule.recurse true   # pull și switch actualizează submodulele

Probleme frecvente:

  • după clonare, folderul e gol: lipsește --init;
  • un coleg a actualizat submodulul, tu faci pull, dar fișierele rămân vechi până la submodule update; rezultatul e un git status care arată submodulul „modificat”, iar un git commit -a neatent fixează versiunea veche;
  • în submodul ești în detached HEAD; commit-urile făcute acolo fără o ramură se pot pierde;
  • ai modificat submodulul, dar ai împins doar părintele: ceilalți nu găsesc commit-ul referit.

Alternative:

  • pachete (npm, Maven, NuGet, pip) cu versiuni: soluția obișnuită pentru cod partajat;
  • git subtree: copiază codul în repository, cu istoric, fără pași speciali pentru cei care clonează;
  • monorepo: toate componentele în același repository, cu unelte de build adaptate.

Submodulele au sens pentru dependențe care trebuie fixate exact la sursă, fără un registry: firmware, biblioteci C/C++ vendored, teme.

Ce urmărește intervievatorul: Verifică experiența cu proiecte compuse și capacitatea de a cântări alternative. Mulți candidați au avut probleme cu submodulele, dar puțini știu de ce apar.

Eroarea, în practică:warning: adding embedded git repository

97 Mid

De ce sunt problematice fișierele binare mari în Git și cum funcționează Git LFS?

Răspuns scurt: Git păstrează pentru totdeauna fiecare versiune, iar binarele se comprimă prost ca delte, deci repository-ul crește permanent și fiecare clonă descarcă tot. Git LFS pune în repository pointeri mici și ține conținutul pe un server separat, descărcând doar ce folosești.

Probleme cu binarele mari (video, PSD, modele ML, dump-uri de baze de date, arhive):

  • fiecare modificare a unui fișier de 200 MB adaugă încă o copie aproape completă în istoric; ștergerea fișierului nu micșorează repository-ul;
  • clone și fetch devin lente pentru toată lumea, pentru totdeauna;
  • conflictele nu pot fi îmbinate;
  • platformele au limite: GitHub refuză fișiere peste 100 MB și avertizează peste 50 MB.

Git LFS (Large File Storage) e o extensie:

BASH
git lfs install                  # o dată pe calculator
git lfs track "*.psd" "modele/*.onnx"
git add .gitattributes           # regulile de tracking se versionează
git add design/home.psd
git commit -m "Adaugă macheta"

În repository ajunge un fișier pointer de câteva rânduri:

version https://git-lfs.github.com/spec/v1
oid sha256:4d7a2146...
size 184320512

Conținutul real se urcă pe serverul LFS la push și se descarcă la checkout, doar pentru versiunea de care ai nevoie.

Atenție:

  • colegii fără git lfs install văd pointerii, nu fișierele;
  • stocarea și transferul LFS au cote pe platforme;
  • git lfs track nu mută fișierele deja commituite; pentru istoricul existent e nevoie de git lfs migrate import --include="*.psd" --everything, care rescrie istoricul;
  • LFS permite blocarea fișierelor (git lfs lock) pentru binare care nu pot fi îmbinate.

Unele fișiere mari nu trebuie deloc în Git: artefactele de build merg într-un registry, datele în stocare de obiecte (S3), iar modelele ML în unelte dedicate (DVC).

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce dimensiunea istoricului contează și cunoști soluția standard. Mențiunea că track nu repară istoricul existent arată experiență.

Eroarea, în practică:File exceeds GitHub's file size limitCannot merge binary files

98 Mid

Ce este git worktree și când e mai bun decât stash sau decât o a doua clonă?

Răspuns scurt: git worktree creează încă un working tree al aceluiași repository, în alt folder, cu altă ramură scoasă. Lucrezi simultan pe două ramuri fără stash și fără a copia istoricul. Ideal pentru un hotfix urgent, un review local sau un build lung.

BASH
git worktree add ../magazin-hotfix -b hotfix/plata origin/main
cd ../magazin-hotfix
# repari, commit, push, la fel ca în folderul principal
cd ../magazin
git worktree list
git worktree remove ../magazin-hotfix

Ce împart worktree-urile:

  • aceeași bază de obiecte, aceleași ramuri, același reflog al ramurilor, aceeași configurație; un commit făcut într-unul e imediat vizibil în celălalt;
  • fiecare are propriul HEAD, propriul index și propriile fișiere.

Avantaje față de alternative:

  • față de stash: nu atingi lucrul curent; fișierele deschise în editor, procesul de dev server pornit și modificările rămân exact cum erau;
  • față de o a doua clonă: nu descarci din nou istoricul, nu ai remote-uri și ramuri de sincronizat, ocupă doar spațiul fișierelor;
  • poți rula testele lungi pe o ramură în timp ce lucrezi pe alta.

Restricții:

  • aceeași ramură nu poate fi scoasă în două worktree-uri simultan (Git refuză, ca să nu se strice indexurile);
  • fișierele ignorate (node_modules, .env) nu există în worktree-ul nou; trebuie reinstalate sau copiate;
  • dacă ștergi folderul manual, rulează git worktree prune.

Cazuri tipice: hotfix în timpul unui feature, review la PR-ul unui coleg rulat local, comparația a două versiuni ale aplicației rulând simultan, sau mai mulți agenți de cod care lucrează în paralel pe ramuri diferite ale aceluiași repository.

Ce urmărește intervievatorul: Unealtă mai puțin cunoscută care economisește mult timp. Verifică dacă candidatul își optimizează fluxul de lucru dincolo de comenzile de bază.

Eroarea, în practică:cannot delete branch used by worktreecannot force update the branch used by worktree

99 Senior

Un coleg a urcat pe GitHub, într-un repository privat, un commit care conține cheia de producție a API-ului de plăți. De atunci s-au mai făcut 20 de commit-uri. Care sunt pașii, în ordine?

Răspuns scurt: Întâi revoci și rotești cheia: e compromisă indiferent ce faci cu istoricul. Verifici logurile furnizorului. Apoi elimini secretul din istoric cu git filter-repo, faci force push coordonat, ceri curățarea cache-urilor platformei și activezi scanarea de secrete.

1. Rotirea, imediat. Generezi cheie nouă, o pui în managerul de secrete și în configurația aplicației, apoi o revoci pe cea veche. Ordinea contează: rescrierea istoricului durează și nu șterge copiile deja existente (clone, fork-uri, CI, cache-uri). Un git revert sau un commit care șterge fișierul nu ajută: cheia rămâne în istoric.

2. Investigația. Logurile furnizorului: a fost folosită cheia din alte locații? Cine are acces la repository? Dacă e cazul, se anunță echipa de securitate.

3. Curățarea istoricului, utilă ca igienă, nu ca măsură principală:

BASH
git clone --mirror git@github.com:firma/magazin.git
cd magazin.git
git filter-repo --replace-text ../secrete.txt     # linii: CHEIA_VECHE==>***REMOVED***
# sau eliminarea completă a fișierului:
git filter-repo --invert-paths --path config/prod.env
git push --force --mirror

git filter-repo e recomandat de proiectul Git în locul lui filter-branch; BFG Repo-Cleaner e o alternativă. Toate commit-urile de după prima apariție primesc hash-uri noi.

4. Coordonarea. Echipa oprește lucrul pe ramurile afectate, apoi reclonează sau face reset pe noile ramuri; o clonă veche împinsă din greșeală readuce secretul. PR-urile deschise trebuie refăcute. Pe GitHub, referințele PR-urilor vechi și cache-urile pot păstra commit-urile, deci se cere suportului platformei eliminarea lor.

5. Prevenția:

  • secretele doar în variabile de mediu sau manager de secrete, .env în .gitignore;
  • hook pre-commit cu gitleaks sau un scanner echivalent;
  • secret scanning și push protection activate pe platformă;
  • chei cu permisiuni minime și rotire periodică.

Ce urmărește intervievatorul: Întrebare de senior unde ordinea pașilor e totul. Greșeala gravă e să începi cu rescrierea istoricului și să consideri problema rezolvată fără rotirea cheii.

Eroarea, în practică:GH013: Push cannot contain secrets

100 Senior

Fără git add și git commit, doar cu comenzi plumbing, creează un commit care conține un fișier și mută main pe el. Ce arată exercițiul despre cum funcționează Git?

Răspuns scurt: Scrii blob-ul cu git hash-object -w, îl pui în index cu git update-index, faci tree-ul cu git write-tree, commit-ul cu git commit-tree și muți ramura cu git update-ref. Un commit e doar o înlănțuire de obiecte, iar ramura un pointer actualizat la final.

Comenzile „porcelain” (add, commit) sunt construite peste comenzi „plumbing”, gândite pentru scripturi.

BASH
# 1. blob: conținutul fișierului în baza de obiecte
blob=$(echo "Salut" | git hash-object -w --stdin)

# 2. index: intrare cu mod, hash și cale
git update-index --add --cacheinfo 100644,"$blob",salut.txt

# 3. tree: snapshot-ul directorului din index
tree=$(git write-tree)

# 4. commit: tree + părinte + mesaj (autorul vine din configurație)
parent=$(git rev-parse main)
commit=$(echo "Adaugă salut.txt" | git commit-tree "$tree" -p "$parent")

# 5. ramura: mutare atomică, cu verificarea valorii vechi
git update-ref refs/heads/main "$commit" "$parent"

git log --oneline -1 main
git cat-file -p "$commit"

Ultimul argument al lui update-ref face mutarea condiționată: reușește doar dacă main e încă la $parent, același principiu ca --force-with-lease. Fișierul nu apare pe disc dacă nu rulezi git checkout-index sau git restore, pentru că am lucrat doar cu index-ul și obiectele.

Ce demonstrează:

  • un commit e un obiect care indică un tree și părinți; nimic nu e „modificat”, totul e adăugat;
  • indexul e o structură independentă de working tree;
  • ramura e doar o referință actualizată la final; o operație întreruptă înainte de ultimul pas nu strică nimic, lasă doar obiecte neaccesibile, curățate de gc.

În practică, plumbing-ul apare în unelte de CI, în bot-uri care fac commit-uri fără working tree (de exemplu actualizarea unui fișier de versiune direct pe server) și în depanarea repository-urilor corupte.

Ce urmărește intervievatorul: Întrebare senior care verifică modelul intern complet. Cine poate construi un commit de mână înțelege de ce operațiile Git sunt sigure și recuperabile.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Git, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Git scriind cod, nu doar citind

Curs Git: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.