Commits gebruiken in Git

De veranderingen in Git Ze zijn niet hetzelfde als in andere beheer- en versiecontrolesystemen, omdat door alleen op te slaan wat echt is veranderd, de grootte van de bestanden die voor controle worden gegenereerd, wordt verkleind en het ook meer wendbaar is.
Het aspect dat dit alles regelt, is de inhoudsopgave wie heeft de verantwoordelijkheid om te weten wie, wat en wanneer van alle aangebrachte wijzigingen, daarom, na het toevoegen van de verschillende aspecten aan onze inhoudsopgave van tak de oproep is gedaan verbinden.
Wat is een verplichting?In Git We weten dat om een ​​wijziging toe te voegen, we een verbinden van hetzelfde zodra het is toegevoegd aan de repository-index. Wat is echter een verbinden precies? Deze vraag wordt niet altijd aan onszelf gesteld, omdat de manier waarop we Git hiermee omgaat is vrij duidelijk, maar a verbinden is de manier waarop Git registreert de huidige status van de repository-index en slaat deze op in het bijbehorende object, op deze manier elke verbinden het is afgeleid van de vorige en dus kan de structuur die geen veranderingen ondergaat opnieuw worden gebruikt.
Het resourcebeheer dat dit zo snel maakt, is te danken aan het feit dat er vergelijkingen worden gemaakt tussen SHA1 Daarom, als de elementen in de index dezelfde hash hebben, gaan ze niet verder in hun wijzigingen omdat ze identiek zijn en dus worden alleen de bestanden genomen die echt zijn gewijzigd.
De manier waarop de begaat stelt ons in staat hiërarchische structuren op te zetten die de zekerheid geven de oorsprong van alle geregistreerde wijzigingen te achterhalen, dus als we de best practices van Git We zullen nooit verloren gaan, dankzij de unieke identifiers kunnen we er ook zeker van zijn dat als een functionaliteit een probleem heeft veroorzaakt, deze precies op het punt kan worden gevonden waar deze was opgenomen.
We hebben commentaar gegeven op hoe begaat heb een hash-in SHA1 waarmee ze kunnen worden geïdentificeerd, blijkt dat deze hash ze ook uniek en onherhaalbaar maakt, dat wil zeggen, als we een verbinden en in een andere repository wordt dezelfde hash gevonden, zodat we kunnen weten dat het hetzelfde is verbinden.
Hierdoor is de verbinden wordt ook overwogen atomair, dat wil zeggen, als een enkele eenheid die onafhankelijk de status van veel mappen of bestanden opslaat, hiermee kunnen we verwijzen naar de verbinden als een eenheid binnen onze repository en dus elk te kunnen behandelen als een element dat, hoewel het gerelateerd is aan het vorige, uniek is.
Hoewel de hasj SHA1 dient als een unieke identificatie voor de verbinden, de structuur van 40 alfanumerieke tekens kan een probleem vormen wanneer we met een andere ontwikkelaar willen communiceren en dat willen uitleggen verbinden We zijn aan het praten.
verwante namenOm dit probleem op te lossen, kunnen we vaststellen: relatieve namen en makkelijker te onthouden voor begaatDeze vervangen de hash niet, maar werken eerder als een soort label waarmee we ze op een meer menselijke manier kunnen identificeren.
Om over de laatste te praten verbinden van de tak we kunnen eenvoudig verwijzen naar HOOFD, aangezien dit altijd zal verwijzen naar de laatste en meest recente verbindenOmdat we dit echter niet altijd nodig hebben, is het voldoende dat we de eerste tekens van de gebruiken hasj, hoewel het niet altijd uniek zal zijn, dus door meer karakters toe te voegen, zullen we de bijbehorende uniciteit bereiken.
Laten we eens kijken naar het commando dat we moeten gebruiken om het laatste te bereiken:

git log -1 --pretty = een regel identifier commit

Nu zullen we in de volgende afbeelding zien hoe we a . identificeren verbinden binnen onze testrepository, hiervoor gaan we in eerste instantie lokaliseren wat de SHA1 van de HOOFD en dan gaan we het bij de eerste tekens noemen, laten we eens kijken:

Met het vorige voorbeeld hebben we een tool ontdekt voor: Git dat kan erg handig zijn en is de log commando, dit is zeer krachtig omdat het ons in staat stelt om de verschillende verbinden op een snelle en nauwkeurige manier, maar het heeft veel parameters en configuraties die in eerste instantie moeilijk te onthouden kunnen zijn, maar om het te gebruiken hoeven we ze niet allemaal te leren, we kunnen beetje bij beetje gaan terwijl we eraan wennen gebruik maken van.
Als we de commit-geschiedenis willen zien, doe dan het volgende:

git log branchnaam

Hiermee krijgen we de gedetailleerde geschiedenisinformatie van onze tak en hun begaatLaten we eens kijken hoe het eruit ziet in onze console in de repository met tests die we hebben:

We merken dan hoe de begaat zijn georganiseerd van de meest recente tot de oudste, dit stelt ons in staat om een ​​beetje de historische lijn te zien van de veranderingen die door de tak gekozen om het historische logboek te bekijken.
Omdat het werken aan de console soms wat zwaar is, hoewel het zeer noodzakelijk is, Git biedt ons een tool waarmee we de geschiedenis van begaat grafisch en is gitk is geen subcommando van Git zoals bijvoorbeeld log dat we al hebben gezien, maar het is een onafhankelijk commando en geeft ons toegang tot meer details van de branch en zijn geschiedenis.
Om het te gebruiken, hoeven we alleen de volgende opdracht uit te voeren:

gitk naamBranch

Laten we eens kijken hoe de uitvoering ervan eruitziet in de console:

Hoewel het lijkt alsof er niets is gebeurd, krijgen we binnenkort een venster met de afbeelding die is gevraagd voor de tak gespecificeerd zoals we kunnen zien in de volgende schermafbeelding:

VERGROTEN

We kunnen opmerken dat we een veel groter detail hebben, naast de verbetering in de visualisatie.
Scheidsrechters Y Symrefs behoren tot referenties Y symbolische verwijzingen respectievelijk, de eerste komt overeen met een identifier SHA1 van een object binnen het objectframe van onze repository, anderzijds correspondeert de tweede indirect met een object, ondanks zijn naam is het ook een referentie.
Deze structuur van verwijzingen is erg belangrijk om te weten, omdat het ons in staat zal stellen de organisatie van onze directory van te begrijpen begaat Y takken binnenin Git, die zijn opgeslagen in de directory .git / ref.
Een symbolische referentie makenAls we expliciet een symbolische verwijzing gebruik gewoon het commando git symbolic-ref, en hoewel het mogelijk is om namen als . te gebruiken HOOFD voor deze referenties is het niet raadzaam omdat ze ons uiteindelijk tot verwarring kunnen leiden die schade aan onze repository kan veroorzaken.
Laten we tot slot eens kijken hoe de uitvoering van deze opdracht eruitziet wanneer we deze toepassen op onze testrepository:

Een ander interessant aspect van begaat, is dat we kunnen werken met relatieve namenDit maakt het vinden van commit-bereiken heel eenvoudig, bijvoorbeeld als we willen lokaliseren wat er is tussen de beoordelingen van een bepaalde periode, dan kunnen we dat doen.
Om dit te bereiken hoeven we alleen de naam van de tak plus het symbool te gebruiken ^ en het revisienummer. Bijvoorbeeld meester ^ waar we verwijzen naar de voorlaatste wijziging in de tak meester.
Geschiedenis van de opslagplaatsOp deze manier zullen we in staat zijn om door de hele geschiedenis van onze repository te gaan, wat ons de mogelijkheid geeft om toegang te krijgen tot de begaat die het voor ons mogelijk hebben gemaakt om de huidige te hebben, als we de structuur volgen meester 2 gaat ons naar de tweede vader van verbinden, dat wil zeggen, degene die parallel het leven heeft gegeven, ook met ~ we hebben toegang tot de vader van de vader van onze huidige commit, dat wil zeggen, de grootvader, om het op de een of andere manier in genealogie te zetten.
Een voorbeeld kan zijn: meester 2 ~ 3 Om te verwijzen naar historische wijzigingen in onze repository, moeten we, als we de naam van een relatieve commit willen verkrijgen, gewoon het volgende commando gebruiken:

git rev-parse relatieve naam

Dit zal de teruggeven SHA1 van de verbinden waar we bij kwamen. Laten we in de volgende afbeelding zien hoe we de naam van de huidige commit kunnen verkrijgen van master en with meester ~ de naam van de eerste ouder van dezelfde die de . zou zijn verbinden van waaruit we beginnen:

We merkten toen hoe we er twee konden bemachtigen SHA1 anders en geldig binnen onze repository, alleen met behulp van relatieve namen.
Hiermee sluiten we deze tutorial af, we hebben nieuwe concepten geïntroduceerd van wat de begaat binnenin GitDit geeft ons de mogelijkheid om de structuren van onze repositories beter te begrijpen, hiermee zal de organisatie logischer lijken en kunnen we dus veel effectiever zijn bij het beheren van wijzigingen binnen onze code. De manier waarop Git het managen van de verschillen maakt het zo bijzonder en daarom is het een van de toonaangevende versiebeheerders van de huidige technologie geworden.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven