Comenzi

git-add

Adaugă fișiere (conținutul acestora) în index.

Opțiunea -n (--dry-run) simulează adăugarea, adică afișează informație de parcă ar adăuga fișiere, dar n-o face ca atare.

Index reprezintă ‘’fotografia’’ dosarului de lucru care va fi folosită drept conținut al următoarei comiteri. Din acest motiv după ce ați operat modificări asupra dosarului de lucru și înainte de a efectua comiterea trebuie să adăugați acest schimbări în index.

Sintaxa este:

git add [<opțiuni>] [<fișier>…​]

În cazul în care lista fișierelor care trebuie adăugate în Index este voluminoasă comanda git-add ne pune la dispoziție opțiuni de filtrare:

• -u (--update) - actualizează doar înregistrările existente din index, adică pentru orice fișier din index acesta este actualizat dacă fișierul din dosarul de lucru conține modificări sau este șters din index dacă acesta a fost șters din dosarul de lucru.
• -A (--all, --no-ignore-removal) - actualizează înregistrările existente, adăugă fișierele care n-au fost până acum în index [en. untracked] și șterge din index fișierele care au fost șterse din dosarul de lucru.
• --no-all (--ignore-removal) - adaugă fișierele noi (care încă n-au fost adăugate în index [en. untracked]), actualizează cele existente, dar ignoră cele șterse.

git-blame

Afișează autorii ultimilor modificări per rând.

Adnotează fiecare rând a fișierului cu informația din ultima comitere (autor, data etc) în care s-a modificat acest rând.

Putem limita raportul doar la un diapazon de rânduri cu opțiunea -L <început>,<sfârșit>.

git-branch

Comandă pentru manipularea ramurilor. De obicei se utilizează pentru:

Afișarea ramurilor existente

git branch

în rezultat se va afișa o listă ce va conține ramurile existente, iar ramura curentă va fi marcată cu ajutorul simbolului *:

  <ramura1>
  <ramura2>
* <ramura3>
  <ramura4>
  <ramura5>

Crearea unei ramuri noi

git branch <ramura nouă>

în rezultat se va crea <ramura nouă> care va avea drept punct de început comiterea curentă. Totodată această comandă nu schimbă ramura curentă.

Ștergerea unei ramuri

se realizează folosind opțiunea -d (--delete)

git branch -d <ramură existentă>

Redenumirea unei ramuri

se realizează folosind opțiunea -d (--delete)

git branch -m [<ramura veche>] <ramura nouă>

În cazul când <ramura veche> este ramura curentă (altfel spus se dorește redenumirea ramurii curente) aceasta poate fi omisă. Anume din acest motiv în comanda de mai sus parametrul <ramura veche> este opțional.

git-cat-file

Afișează conținutul, tipul sau mărimea obiectelor git.

Cum arată un arbore

De exemplu dosarul acestui proiect la un moment oarecare avea asociat arborele cu hash-ul c5e8251aaa20f5a822b3dc12d03d68c78e8ccd30, folosind comanda

git cat-file -p c5e8251aaa20f5a822b3dc12d03d68c78e8ccd30

se va afișa:

100644 blob d8539217c2eb6b51a86abe1279c37c8cc4139d22 .gitignore
100644 blob d45a907923f682f533128fb344c8eefde1fb81fd Makefile
100644 blob a1c4e80ac1142e3e4a35039478b9ff3b0afc94eb README.md
040000 tree 4a3d4ac761ee7eeb491e5cd33a91bf147bb25552 locale
100644 blob de2346e1cc0afae33b569cf12f2e9510dd422814 make.bat
040000 tree 5be6adfbe1e7b690cf5abe4d61aa211cf1f411bd source

Cum arată o comitere

De exemplu folosind comanda pe ultima comitere:

git cat-file -p HEAD

se va afișa:

tree c5e8251aaa20f5a822b3dc12d03d68c78e8ccd30
parent 9a7657e68c8c93f8944223175d855a8e2b8ccf2e
author Radu Dumbraveanu <rdumbraveanu@amsoft-group.com> 1447341585 +0200
committer Radu Dumbraveanu <rdumbraveanu@amsoft-group.com> 1447341585 +0200

Cum arată o etichetă adnotată

De exemplu folosind comanda pentru o anumită etichetă cu hash-ul b5b809ec5a83c0ebe15c41f4dacf61de9e12dd61 care se referă la comiterea 9afeed48d9654122a4c4f0f8e0ef0cd388550d7f:

git cat-file -p b5b809ec5a83c0ebe15c41f4dacf61de9e12dd61

se va afișa:

object 9afeed48d9654122a4c4f0f8e0ef0cd388550d7f
type commit
tag v999
tagger Radu Dumbraveanu <rdumbraveanu@amsoft-group.com> 1447411375 +0200

Un exemplu de etichetă

git-checkout

Comută poziția curentă a referinței HEAD.

Poate fi aplicată asupra fișierelor sau a întregului proiect.

Dacă este aplicată fișierelor:

git checkout <comitere> <fișier>...

atunci actualizează conținutul fișierelor cu cel din <comitere>.

Dacă nu este aplicată asupra fișierelor:

git checkout <comitere>

atunci schimbă (atualizează) întreg dosarul de lucru. Dacă <comiterea> reprezintă o ramură atunci are loc comutarea la acea ramură.

git-cherry-pick

Aplică doar modificările care rezidă într-o anumită comitere.

Pentru a copia comiterile se folosește sintaxa:

git cherry-pick <comitere>

după ce s-au soluționat conflictele de integrare trebuie de rulat:

git cherry-pick --continue

sau dacă se dorește anularea întregului proces:

git cherry-pick --abort

git-clean

Șterge fișierele neindexate (care nu-s supuse controlului versiunii).

Șterge recursiv fișierele care nu-s supuse controlului versiunii.

Pentru că reprezintă o operație într-un fel periculoasă are opțiunea de simulare -n (--dry-run).

git-clone

Copiază un proiect Git într-o altă locație (local sau la distanță).

Sintaxa este:

git clone [<opțiuni>] <URL proiect Git> <dosar destinație>

În cazul când copierea se face local, adică locația nouă se află pe același calculator ca și proiectul sursă, se poate salva din spațiul folosit (pe disc) utilizând opțiunea -l (--local):

git clone -l <URL proiect Git> <dosar destinație>

efectul utilizării acestei opțiuni este acela că dosarul .git/objects din <dosarul destinație> nu va conține obiectele Git ca atare ci doar legături tari către fișierele din proiectul sursă. Dacă nu folosim această opțiune atunci se creează copii ale fișierelor și nu legături, dar dacă dorim să ne asigurăm și să forțăm acest comportament în mod obligatoriu putem folosi opțiunea --no-hardlinks.

După clonare proiectul sursă devine upstream pentru <proiectul destinație> și respectiv referința origin a acestuia este modificată astfel încât să indice către proiectul sursă. Pentru a modifica puțin acest comportament putem folosi opțiunea -o (--origin) pentru a schimba numele referinței care va indica către proiectul sursă. De exemplu în rezultatul rulării comenzii:

git clone -o source <URL proiect Git> <dosar destinație>

în proiectul destinație va fi creată referința source în dosarul .git/refs/remotes care va indica către proiectul sursă. Deopotrivă cu această opțiune există și alte opțiuni pentru modificare anumitor lucruri din proiectul destinație cum ar fi:

• -b <nume ramură> (--branch <nume ramură>) – schimbă ramura curentă în proiectul destinație;
• -c <cheie>=<valoare> (--config <cheie>=<valoare>) – schimbă valori ale parametrilor în proiectul destinație;
• --depth <numărul de comiteri> – copiază doar ultimele comiteri în proiectul destinație (în așa caz acesta se numește clonă superficială).

git-commit

Înregistrează modificările în istoria proiectului.

Stochează conținutul indexului în istorie împreună cu un mesaj, autorul comiterii și data.

Cu -a (--all) automat actualizează index-ul pentru fișierele modificate sau șterse (dar nu și pentru cele noi).

Ne poate ușura puțin lucrul dacă vrem să folosim mesajul dintr-o altă comitere cu

• -c <comiterea> (--reedit-message=<comiterea>) – cu deschiderea editorul;
• -C <comiterea> (--reuse-message=<comiterea>) – fără a deschide editorul;

Mesajul -m <mesaj> (--message=<mesaj>).

Modificarea ultimei comiteri

Cu ajutorul opțiunii --amend avem posibilitatea să redactăm ultima comitere: începând cu mesajul, autorul și terminând cu conținutul acesteia. De notat însă că atunci când redactați ultima comitere se schimbă automat și hash-ul acesteia. Respectiv pot apărea situații neclare atunci când proiectul dvs. nu este doar local. De exemplu, să presupunem că proiectul local și cel de la distanță arată astfel

(A) -- (B) -- (C)
               |
            <master>
               |
              HEAD

după ce ați aplicat opțiunea --amend proiectul dvs local va arăta astfel

(A) -- (B) -- (C')
               |
            <master>
               |
              HEAD

unde (C') este comiterea (C) redactată respectiv cu alt hash. În așa fel dacă ar fi să comparăm proiectul local cu cel de la distanță situația e următoarea

         (C) - <origin/master>
         /
(A) -- (B)
         \
        (C')
         |
      <master>
         |
        HEAD

astfel dacă veți încerca să încărcați modificările să nu vă surprindă mesajul:

 ! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to '<proiectul dvs.>'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

git-config

Schimbă parametrii Git pentru proiectul curent (--local), pentru toate proiectele utilizatorului curent (--global) și pentru pentru toate proiectele din sistem (--system).

git-diff

Afișează diferențele dintre conținutul ultimei comiteri, index și dosarul de lucru.

git-fetch

Descarcă obiecte git și referințe din alt proiect git.

git-init

Creează un proiect Git nou sau reinițializează unul existent.

Pentru a inițializa proiectul Git în dosarul curent se rulează comanda:

git init

iar pentru a inițializa proiectul în alt dosar decât cel curent este nevoie de a indica calea spre acest dosar:

git init <dosarul proiectului>

Inițializarea proiectului Git din punct de vedere tehnic constă în crearea în dosarul destinație a unui dosar ascuns numit .git împreună cu subdosarele objects (unde se vor păstra obiectele git), refs/heads (pentru stocarea referințelor), refs/tags (pentru stocarea etichetelor) și fișierul HEAD (pentru stocarea referinței HEAD).

git-log

Afișează istoria.

git-ls-files

Afișează informații despre fișierele din index și dosarul de lucru.

De exemplu,

-u (--unmerged) fișierele care n-au fost integrate (cu conflicte).

git-merge

Integrează două sau mai multe ramuri.

Cum sunt prezentate conflictele; sun marcate prin <<<<<<<, =======, și >>>>>>>. Fragmentul până la ======= este cel din ramura sursă, și partea după - din ramura destinație.

git-merge-tool

Rulează instrumente pentru soluționarea conflictelor de integrare.

git-pull

Descarcă toate modificările operate asupra proiectului la distanță și le integrează în proiectul local. Altfel spus realizează sincronizarea proiectul local cu un proiect la distanță. Cel mai des se utilizează în formatul următor:

git push <proiect la distanță> <ramura la distanță>

Unde <proiect la distanță> poate fi specificat direct prin URL (https://git-scm.com/book/tr/v2/Git-on-the-Server-The-Protocols) sau printr-un nume creat cu ajutorul comenzii git-remote. În rezultat modificările din ramura din <proiect la distanță> sunt descărcate în ramura cu același nume din proiectul local. Dacă ramura locală are alt nume atunci va fi nevoie de schimbat puțin formatul comenzii:

git push <proiect la distanță> <ramura la distanță>:<ramura locală>

git-push

Încarcă toate modificările operate asupra proiectului local într-un alt proiect aflat de regulă la distanță. Altfel spus realizează sincronizarea unui proiect la distanță cu proiectul local. Cel mai des se utilizează în formatul următor

git push <proiect la distanță> <ramura locală>

Unde <proiect la distanță> poate fi specificat direct prin URL (https://git-scm.com/book/tr/v2/Git-on-the-Server-The-Protocols) sau printr-un nume creat cu ajutorul comenzii git-remote. În rezultat modificările din ramura locală sunt încărcate în ramura cu același nume din proiectul <proiect la distanță>. Dacă ramura de la distanță are alt nume atunci va fi nevoie de schimbat puțin formatul comenzii

git push <proiect la distanță> <ramura locală>:<ramura la distanță>

În cazul când nu este specificată ramura sursă (ramura locală>)

git push <proiect la distanță> :<ramura la distanță>

efectul rulării comenzii este ștergerea ramurii <ramura la distanță>.

Încărcare forțată

Modificările locale pot fi respinse de <proiect la distanță> atunci când acesta conține modificări mai proaspete decât cele locale. În așa caz fie că se integrează noile modificări și apoi se execută încă o dată git-push fie, dacă țineți cu tot adinsul, se suprascriu folosind opțiunea -f (--force)

git push -f <proiect la distanță> <ramura locală>

Warning

În rezultatul încărcării forțate toate modificările mai proaspete decât cele locale vor dispărea din proiectul de la distanță. Din acest motiv asigurați-vă că nu sunt modificări importante pe proiectul la distanță. Printre situațiile când este nevoie de încărcare forțată se numără: Cum să schimb mesajul ultimei comiteri? sau Cum să redenumesc o ramură?.

git-rebase

Schimbă punctele de început ale ramurilor.

git-reset

Schimbă index-ul pentru anumite fișiere sau în general schimbă ‘’poziția’’ referinței HEAD.

Sintaxa

git reset [-q] [<arbore git>] [--] <fișier>…​
git reset (--patch | -p) [<arbore git>] [--] [<fișier>…​]
git reset [--soft | --mixed [-N] | --hard | --merge | --keep] [-q] [<comitere>]

În prima și în a doua formă înlocuiește conținutul (versiunea) <fișier>… din index cu versiunea <fișier>… din <arbore git>. În a treia formă schimbă comiterea curentă, adică ‘’poziția’’ referinței HEAD.

Opțiunile: --soft, --mixed și --hard sunt într-o anumită relație și anume:

• --soft – schimbă valoarea referinței HEAD astfel încât să indice către comiterea <comitere>;
• --mixed – pe lângă faptul că schimbă valoarea referinței HEAD astfel încât să indice către comiterea <comitere> mai actualizează și index-ul ca să reflecte conținutul comiterii <comitere>;
• --hard – la fel ca și --mixed doar că mai actualizează și conținutul dosarului de lucru.

Warning

În caz că nu vă place ce a ieșit după schimbarea referinței HEAD puteți întotdeauna reveni la poziția inițială folosind referința ORIG_HEAD

Un articol în engleză în care se folosesc imagini vizuale pentru descrierea acestei comenzi: Reset Demystified

git-remote

Comandă pentru manipularea numelor asociate proiectelor la distanță conexe proiectului curent.

Adăugarea, redenumirea și ștergerea se fac cu ajutorul opțiunilor add, rename și rm (remove) în felul următor:

git remote add <nume> <URL-ul proiectului>

git remote rename <vechi> <nou>

și respectiv ștergerea:

git remote remove <nume existent>

în rezultat se șterge nu doar numele ci și toate ramurile la distanță din acest proiect stocate local prin git-fetch sau git-pull.

Pentru a lista alias-urile existente:

git remote -v

De exemplu în cazul acestui proiect în rezultatul rulării comenzii de mai sus avem:

git remote -v
origin       https://github.com/Streeling/git-rif.git (fetch)
origin       https://github.com/Streeling/git-rif.git (push)

sau simplu:

git remote

fară multe detalii

Dacă ați greșit se poate schimba url-ul:

git remote set-url <nume> <URL nou>

Pentru a curăța de ramurile care nu există pe proiectul la distanță prune și ca orice comandă ‘’periculoasă’’ are opțiunea de simulare --dry-run.

git-show

Afișează informația despre obiecte.

Sintaxa:

git show [<opțiuni>] <obiect>…​

git-show-ref

Afișează informația despre referințele proiectului.

Sintaxa:

git show-ref [<opțiuni>] [--] [<șablon de căutare>…​]

Dacă nu este specificat șablonul de căutare sunt afișate toate referințele. Când acesta (șablonul) este specificat atunci se afișează toate referințele a căror cale absolută conține drept prefix șablonul indicat. Dacă se dorește afișarea informației despre o referință care are exact numele căutat se folosește opțiunea --verify, de exemplu:

git show-ref --verify refs/heads/master

git-status

Afișează diferențele dintre conținutul ultimei comiteri, index și dosarul de lucru.

Sintaxa:

git status [<opțiuni>] [--] [<fișier>…​]

Atunci când nu este specificat nici un fișier este aplicată pentru toate fișierele din proiect.

Practic afișează 3 zone informaționale:

• fișierele care-s în index și se deosebesc de versiunea din ultima comitere (HEAD) - anume aceste modificări vor fi înregistrate la rularea comenzii git-commit;
• fișierele care-s în dosarul de lucru și se deosebesc de versiunea din index - de regulă asupra acestor fișiere aplicăm git-add;
• fișierele care-s în dosarul de lucru, dar încă n-au fost adăugate în index, adică nu-s supuse controlului versiunii.

git-tag

Comandă pentru manipularea etichetelor.

Pentru a crea o etichetă simplă se folosește în formatul următor:

git tag <nume etichetă> [<comitere>|<obiect git>]

Pentru a crea o etichetă adnotată se folosește opțiunea -a (--annotate):

git tag -a [-m <notă>] <nume etichetă> [<comitere>|<obiect git>]

dacă nu este folosită opținea -m (--message) atunci se va deschitde editorul implicit (ca și în situația cu git-commit).

Pentru a altera referința unei etichete existente poate fi utilizată opțiunea -f (--force) doar că în cazul când eticheta a fost încărcată pe server nu se recomandă această procedură. Etichetele sunt descărcate o singură dată de pe server, adică va fi nevoie de anunțat toate persoanele care au descărcat eticheta modificată să o șteargă și s-o descarce încă o dată.

Ștergerea unei etichete se realizează cu ajutorul opțiunii -d (--delete):

git tag -d <etichetă existentă>…