Tutorial avansat Git

Implementarea proiectului dvs. printr-un depozit la distanță vă permite să gestionați în mod flexibil fiecare parte a acestuia. Remediile de erori, actualizările de caracteristici, ștergerea fișierelor, munca în echipă, contribuțiile open-source, implementarea codului și multe altele sunt acum la îndemână, cu o puternică cunoaștere a Git.

Deci, ați folosit Git, dar doriți să aflați mai multe? Iată câteva sfaturi Git mai avansate care vor face ca versiunea dvs. de proiect să controleze ușor.

Filiala Git

O ramură Git vă împiedică să împingeți direct către ramura principală. Este util dacă gestionați un proiect cu o echipă de dezvoltatori. Puteți crea oricâte ramuri Git doriți și apoi le puteți uni cu ramura principală mai târziu.

Creați o sucursală Git

Pentru a crea o ramură Git, utilizați:

git branch branch_name

Treceți la o filială Git

Utilizare verifică pentru a trece la o ramură Git:

git checkout branch_name

După ce ați trecut la o sucursală, puteți schimba modificările folosind git add --all . Apoi comiteți-le folosind git commit -m 'numele de comitere' comanda.

Comparați o ramură cu Maestrul

Folosește git diff comanda:

git diff master..branch_name

Pentru a compara anumite fișiere:

git diff master..testb -- main.html

Compararea a două ramuri este similară cu modul în care comparați o ramură cu masterul:

git diff branch1..branch2

Pentru a vedea diferențele dintr-un anumit fișier între două ramuri:

git diff branch1..branch2 -- main.html

Apăsați modificările la o ramură la distanță

S-ar putea să doriți ca un alt dezvoltator să analizeze modificările pe care le-ați făcut într-un fișier din filiala dvs. locală înainte de a le împinge în direct. O practică bună este să vă împingeți sucursala Git locală la o replică de la distanță, astfel încât să poată arăta.

Să presupunem că ați creat anterior o sucursală locală numită schimbări . Puteți trece la acea ramură locală, puteți ajusta toate fișierele pe care le doriți, apoi le puteți pune în scenă și le puteți transfera la acea ramură.

Apoi, puteți împinge aceste modificări la versiunea la distanță a sucursalei:

git push origin changes

Combinați filiala la distanță cu Master folosind Pull Request

Deci, un alt programator a auditat modificările din ramura la distanță ( schimbări ). Dar doriți să o combinați cu ramura principală și să o împingeți în direct.

Amintiți-vă că sucursala dvs. la distanță moștenește numele sucursalei locale Git ( schimbări ). Iată cum să îmbinați modificările:

Treceți la ramura principală:

git checkout master

Trageți originea sau CAPUL ramurii ( schimbări ) pentru a o combina cu ramura principală:

git pull origin changes

Împingeți această fuziune în direct la ramura principală:

git push origin master

Folosiți în schimb Git Merge

Pentru a îmbina o ramură cu masterul folosind merge comanda:

Migrați către ramura principală:

git checkout master

Îmbinați-l cu ramura ( schimbări ):

git merge changes

Apoi împingeți îmbinarea în direct către ramura principală:

cum să ștergeți un cont hotmail

git push origin master

Asigurați-vă că înlocuiți schimbări cu numele sucursalei tale.

Odată ce o îmbinare are succes, puteți face acest lucru ștergeți sucursala local și de la distanță dacă nu mai aveți nevoie de el:

Legate de: Cum să redenumiți o sucursală în Git

Git Rebase

Dacă aveți mai multe sucursale cu comitetele depășite, puteți să refaceți sau să focalizați din nou cap / ref a acelor ramuri pentru a moșteni cap / ref a unuia actualizat.

Prin urmare, rebasarea este utilă atunci când trebuie să actualizați unele ramuri cu baza unei curente.

Redimensionarea nu ar trebui să fie o acțiune frecventă, totuși, mai ales dacă lucrați cu o echipă, deoarece poate perturba întregul flux de lucru. Dar dacă lucrați singur și sunteți familiarizați cu fluxul de lucru și cu ramurile dvs., refacerea nu ar trebui să facă ravagii dacă știți unde și cum să îl utilizați.

De exemplu, să presupunem că aveți două ramuri; ramură1 și ramură2. Acum, nu ați mai făcut modificări la branch1 de ceva timp. Dar comunicați în mod constant modificări la branch2, inclusiv recent.

Deci, ați decis să purtați ramura1 împreună cu fluxul. Prin urmare, refacerea ramurii1 la ramura2 înseamnă că îi spuneți ramurii1 să ignore comitetele sale anterioare și să moștenească recenta comisie făcută la ramă2.

Iată cum puteți face asta:

Treceți la ramura abandonată (ramura1):

git checkout branch1

Apoi reintroduceți ramura1 în ramura2 actualizată:

git rebase branch2

Git Squash

Git squash vă permite să îmbinați mai multe confirmări într-una singură. Te ajută când alergi git commit de multe ori pe o singură actualizare. Un exemplu practic este atunci când fiecare remediere a erorilor sau refactor de cod pentru o singură caracteristică are un commit separat.

Dar s-ar putea să nu doriți să împingeți comisia HEAD cu cele însoțitoare, deoarece toate au același scop. O abordare recomandată este de a le împiedica într-una, pentru a evita confuzia la urmărirea comiterilor.

Cel mai bun mod de a face squash comits este prin modul interactiv rebase. Aruncați o privire la exemplul de mai jos pentru a înțelege mai bine acest lucru.

În acest exemplu, presupuneți că aveți cinci remedieri de erori. Și există un angajament pentru fiecare dintre ei. Iată cum puteți împărți aceste cinci confirmări într-o singură:

Alerga git reflog pentru a vizualiza codul hash al comitetelor dvs.:

git reflog

Iată rezultatul în acest caz:

Acum, scopul tău este să distrugi ultimele cinci confirmări, începând cu prima remediere pâna la al cincilea fix .

Pentru aceasta, copiați codul hash al commitului chiar mai jos prima remediere ( 0a83962 ). Apoi apăsați Î a renunța la reflog .

Acum fugi git rebase --interactive pe acel hash.

git rebase --interactive 0a83962

Git deschide apoi un fișier interactiv de rebase care arată astfel:

Pentru a zdrobi comitetele, cu excepția prima remediere , a inlocui alege cu s pentru fiecare dintre celelalte comisii:

Salvați și închideți acest fișier.

Apoi se deschide un alt fișier pentru a redenumi comitetul zdrobit:

cum se remediază ecranul care pâlpâie pe Android

Curățați-le și tastați un nume preferat pentru commit-ul zdrobit:

Salvați acel fișier. Apoi închideți-l și ar trebui să primiți un mesaj de succes în terminal.

Notă: Fișierul interactiv se poate deschide în terminal. Dar dacă sunteți pe Windows, este posibil să doriți să forțați terminalul să deschidă fișiere la nivel global la editorul dvs. de text preferat pentru a face zgomotul mai ușor.

Pentru aceasta, deschideți linia de comandă și rulați:

git config --global core.editor ''path to choice text editor' -n -w'

Git Fork vs. Git Clone

Forking și clonare sunt doi termeni diferiți în Git. Nu îți poți forța depozitul, deoarece este deja la tine. Cu toate acestea, puteți forța depozitul altor persoane și clona ulterior.

Utilizarea unui depozit înseamnă că luați o copie a depozitului cuiva și o faceți a dvs. Odată ce primiți o copie a acelui depozit, îl puteți clona așa cum ați face oricare dintre depozitele dvs. git pentru modificări locale.

Iată cum să clonați un depozit la distanță pe GitHub și inițiați o descărcare în directorul dvs. local:

git clone https://github.com/username/repository_name.git/

Restabiliți un fișier la starea implicită

Dacă doriți să ștergeți modificările dintr-un fișier după ultima comitere, puteți utiliza fișierul git restore comanda:

git restore filename

Modificați un angajament

Puteți reveni la o comitere anterioară dacă uitați să faceți modificări la unele fișiere în timp ce le aranjați.

Modificați fișierul pe care l-ați uitat. Apoi folosiți git amend pentru a revizui o comitere:

git add file_forgotten  
git commit --amend

Unstage Files

Puteți elimina anumite fișiere pe care le-ați organizat pentru un commit folosind du-te rm comanda:

git rm --cached filename

De asemenea, puteți elimina mai multe fișiere simultan:

git rm --cached file1 file2 file3 file4

Nu uitați să adăugați extensia de fișier relevantă la orice fișier pe care îl scutiți. De exemplu, ar trebui să fie un fișier text simplu filename.txt .

Legate de: Cum să curățați Git și să eliminați fișierele ne urmărite

Resetare Git

Folosind git reset este util dacă doriți să renunțați simultan la toate fișierele pe care le-ați organizat pentru un commit:

git reset

Git reset HEAD, cu toate acestea, îndreaptă HEAD-ul unei ramuri către un commit specific din arborele dvs. de lucru. De exemplu, dacă nu v-ați împins încă validarea curentă, puteți reveni la validarea recentă:

git reset --soft HEAD~1

A inlocui --moale cu --greu dacă ați împins deja comiterea curentă:

git reset --hard HEAD~1

Du-te Reveniți

spre deosebire de resetați comanda, du-te înapoi păstrează integritatea istoricului dvs. de comitere. Este la îndemână dacă doriți să modificați un commit din cauza erorilor sau erorilor.

Nu abandonează comiterea țintei și nici nu creează una nouă. În schimb, revine la modificările recente pe care le faceți fără a șterge sau redenumi un astfel de commit. Este o modalitate excelentă de a vă menține angajamentele mai curate, plus este mai sigur decât resetarea tot timpul.

Pentru a reveni la un commit:

git revert HEAD~1

Unde CAPUL 1 indică o comitere specifică în arborele dvs. de lucru.

Ștergeți un fișier urmărit sau un director

Poți să folosești git rm -f pentru a șterge orice fișier urmărit din arborele dvs. de lucru. Rețineți, totuși, că Git nu poate elimina fișierele care nu sunt urmărite, deoarece nu le cache.

Pentru a șterge un fișier etapizat:

git rm -f filename

Pentru a elimina un folder în etape:

git rm -r -f foldername

Git Logging

Pentru a vizualiza jurnalele de comitere și istoricul dvs. în Git:

git log

Pentru a înregistra activitățile într-o anumită ramură:

git log branch_name

Legate de: Cum să inspectați istoricul unui proiect cu jurnalul git

Uneori s-ar putea să doriți să reveniți la o comitere abandonată. Deci, pentru a vizualiza confirmările abandonate, inclusiv cele relevante:

git reflog

Pentru a vizualiza jurnalele de referință pentru o anumită ramură:

git reflog branch_name

Gestionați versiunile proiectului dvs. ca un profesionist cu Git

Cu Git care oferă multe avantaje, puteți gestiona lansările de proiect de la distanță, fără a arunca fișiere și foldere la fața locului în ramura principală. În plus, vă permite să derulați proiecte cu ușurință împreună cu o echipă.

După cum ați văzut, Git are multe funcții pe care le puteți explora. Dar aveți grijă să utilizați aceste caracteristici în mod intenționat. În caz contrar, ați putea ajunge să spargeți lucrurile. Acestea fiind spuse, puteți continua să creați un depozit demo la distanță și să vă jucați cu aceste caracteristici.

Acțiune Acțiune Tweet E-mail Gestionați-vă versiunea de fișiere ca un programator cu Git

Programatorii au creat sisteme de control al versiunilor (VCS) pentru a rezolva problemele de control al versiunii de fișiere. Să vedem noțiunile de bază ale controlului versiunilor folosind sistemul de top de astăzi, Git.

Citiți în continuare Subiecte asemănătoare

Programare
Dezvoltare web
GitHub
Tutoriale de codare

Despre autor Idisou Omisola(94 articole publicate)

Idowu este pasionat de orice tehnologie inteligentă și productivitate. În timpul liber, se joacă cu codificarea și trece la tabla de șah când se plictisește, dar îi place, de asemenea, să se rupă de rutină din când în când. Pasiunea sa pentru a arăta oamenilor calea în jurul tehnologiei moderne îl motivează să scrie mai multe.

Mai multe de la Idowu Omisola

Aboneaza-te la newsletter-ul nostru

Alăturați-vă newsletter-ului pentru sfaturi tehnice, recenzii, cărți electronice gratuite și oferte exclusive!

Faceți clic aici pentru a vă abona