Git
Het plegen

Invoering

Syntaxis

• git commit [vlaggen]

parameters

Vastleggen zonder een editor te openen

Git opent meestal een editor (zoals vim of emacs ) wanneer je git commit uitvoert. Geef de optie -m door om een bericht op te geven vanaf de opdrachtregel:

git commit -m "Commit message here"

Je commit bericht kan over meerdere regels gaan:

git commit -m "Commit 'subject line' message here

More detailed description follows here (after a blank line)."

Als alternatief kunt u meerdere -m argumenten doorgeven:

git commit -m "Commit summary" -m "More detailed description follows here"

Zie Een Git Commit-bericht schrijven .

Udacity Git Commit Stijlgids voor berichten

Een commit wijzigen

Als je laatste commit nog niet is gepubliceerd (niet naar een upstream repository gepusht) dan kun je je commit aanpassen.

git commit --amend

Dit zal de huidige gefaseerde wijzigingen in de vorige commit plaatsen.

Opmerking: dit kan ook worden gebruikt om een onjuist commit-bericht te bewerken. Hiermee wordt de standaardeditor (meestal vi / vim / emacs ) weergegeven en kunt u het vorige bericht wijzigen.

Om het commit bericht inline te specificeren:

git commit --amend -m "New commit message"

Of om het vorige commit bericht te gebruiken zonder het te wijzigen:

git commit --amend --no-edit

Amending werkt de vastleggingsdatum bij, maar laat de datum van de auteur ongewijzigd. Je kunt git vertellen de informatie te vernieuwen.

git commit --amend --reset-author

Je kunt de auteur van de commit ook wijzigen met:

git commit --amend --author "New Author <[email protected]>"

Opmerking: Houd er rekening mee dat het wijzigen van de meest recente commit deze volledig vervangt en dat de vorige commit uit de geschiedenis van de branch wordt verwijderd. Dit moet in gedachten worden gehouden bij het werken met openbare repositories en op filialen met andere medewerkers.

Dit betekent dat als de eerdere commit al was gepusht, je na het wijzigen ervan - push --force moet push --force .

Wijzigingen rechtstreeks doorvoeren

Gewoonlijk moet je git add of git rm gebruiken om wijzigingen aan de index toe te voegen voordat je ze kunt git commit . Geef de optie -a of --all door om elke wijziging (aan bijgehouden bestanden) automatisch aan de index toe te voegen, inclusief verwijderingen:

git commit -a 

Als je ook een commit bericht wilt toevoegen, zou je het volgende doen:

git commit -a -m "your commit message goes here"

U kunt ook lid worden van twee vlaggen:

git commit -am "your commit message goes here"

U hoeft niet noodzakelijkerwijs alle bestanden tegelijk te plegen. Laat de vlag -a of --all en geef aan welk bestand u direct wilt vastleggen:

git commit path/to/a/file -m "your commit message goes here"

Voor het direct vastleggen van meer dan één specifiek bestand, kunt u ook een of meerdere bestanden, mappen en patronen opgeven:

git commit path/to/a/file path/to/a/folder/* path/to/b/file -m "your commit message goes here"

Een lege commit maken

Over het algemeen is lege commits (of commits met status die identiek is aan de ouder) een fout.

Bij het testen van build hooks, CI-systemen en andere systemen die een commit activeren, is het handig om gemakkelijk commits te kunnen maken zonder een dummybestand te hoeven bewerken / aanraken.

De --allow-empty commit zal de controle omzeilen.

git commit -m "This is a blank commit" --allow-empty

Wijzigingen aanbrengen en vastleggen

De basis

Na het maken van wijzigingen in uw broncode, moet u deze wijzigingen met Git podium voordat u ze kunt plegen.

Bijvoorbeeld, als u verandert README.md en program.py :

git add README.md program.py

Dit vertelt git dat je de bestanden wilt toevoegen aan de volgende commit die je doet.

Leg vervolgens uw wijzigingen vast met

git commit

Merk op dat dit een teksteditor opent, die vaak vim is . Als u niet bekend bent met vim, zou u willen weten dat kunt u op i om te gaan naar de insert stand, schrijf je commit boodschap, druk dan op Esc en :wq op te slaan en af te sluiten. Om te voorkomen dat u de teksteditor opent, -m eenvoudig de vlag -m aan uw bericht

git commit -m "Commit message here"

Commit-berichten volgen vaak enkele specifieke opmaakregels, zie Goede commit-berichten voor meer informatie.

shortcuts

Als u veel bestanden in de map hebt gewijzigd, in plaats van ze allemaal te vermelden, kunt u het volgende gebruiken:

git add --all        # equivalent to "git add -a"

Of om alle wijzigingen toe te voegen, met uitzondering van bestanden die zijn verwijderd , uit de map op het hoogste niveau en submappen:

git add .

Of om alleen bestanden toe te voegen die momenteel worden gevolgd ("update"):

git add -u

Bekijk desgewenst de gefaseerde wijzigingen:

git status           # display a list of changed files
git diff --cached    # shows staged changes inside staged files

Leg ten slotte de wijzigingen vast:

git commit -m "Commit message here"

Als alternatief, als je alleen bestaande bestanden hebt gewijzigd of bestanden hebt verwijderd en geen nieuwe hebt gemaakt, kun je de acties van git add en git commit combineren in een enkele opdracht:

git commit -am "Commit message here"

Merk op dat dit alle gewijzigde bestanden op dezelfde manier als git add --all zal stadium.

Gevoelige data

U mag nooit gevoelige gegevens vastleggen, zoals wachtwoorden of zelfs privésleutels. Als dit geval zich voordoet en de wijzigingen al naar een centrale server zijn doorgevoerd, moet u rekening houden met gevoelige gegevens als aangetast. Anders is het mogelijk dergelijke gegevens achteraf te verwijderen. Een snelle en gemakkelijke oplossing is het gebruik van de "BFG Repo-Cleaner": https://rtyley.github.io/bfg-repo-cleaner/ .

De opdracht bfg --replace-text passwords.txt my-repo.git leest wachtwoorden uit het bestand passwords.txt en vervangt deze door ***REMOVED*** . Deze bewerking houdt rekening met alle eerdere commits van de hele repository.

Begaan namens iemand anders

Als iemand anders de code die je aan het schrijven bent, hebt geschreven, kun je hem crediteren met de optie --author :

git commit -m "msg" --author "John Smith <[email protected]>"

Je kunt ook een patroon opgeven dat Git zal gebruiken om naar eerdere auteurs te zoeken:

git commit -m "msg" --author "John"

In dit geval wordt de auteursinformatie van de meest recente commit met een auteur met "John" gebruikt.

Op GitHub tonen commits die op een van de bovenstaande manieren zijn gedaan de miniatuur van een grote auteur, met de kleinere van de committer en vooraan:

Wijzigingen aanbrengen in specifieke bestanden

Je kunt wijzigingen aanbrengen die zijn aangebracht in specifieke bestanden en deze overslaan met behulp van git add :

git commit file1.c file2.h

Of u kunt eerst de bestanden opvoeren:

git add file1.c file2.h

en leg ze later vast:

git commit

Goede commit berichten

Het is belangrijk voor iemand die door het git log om gemakkelijk te begrijpen waar elke commit over ging. Goede commit-berichten bevatten meestal een aantal taken of een probleem in een tracker en een beknopte beschrijving van wat er is gedaan en waarom, en soms ook hoe het is gedaan.

Betere berichten kunnen er uitzien als:

TASK-123: Implement login through OAuth
TASK-124: Add auto minification of JS/CSS files
TASK-125: Fix minifier error when name > 200 chars

Terwijl de volgende berichten niet zo nuttig zouden zijn:

fix                         // What has been fixed?
just a bit of a change      // What has changed?
TASK-371                    // No description at all, reader will need to look at the tracker themselves for an explanation
Implemented IFoo in IBar    // Why it was needed?

Een manier om te testen of een commit-bericht in de juiste stemming is geschreven, is door de lege plek te vervangen door het bericht en te kijken of het zinvol is:

Als ik deze commit toevoeg, zal ik ___ toevoegen aan mijn repository.

De zeven regels van een geweldige git commit boodschap

1. Scheid de onderwerpregel van het lichaam met een lege regel
2. Beperk de onderwerpregel tot 50 tekens
3. Hoofdletter van de onderwerpregel
4. Sluit de onderwerpregel niet af met een punt
5. Gebruik de gebiedende wijs in de onderwerpregel
6. Wikkel elke regel van het lichaam handmatig in 72 tekens
7. Gebruik het lichaam om uit te leggen wat en waarom in plaats van hoe

7 regels uit de blog van Chris Beam .

Vastleggen op een specifieke datum

git commit -m 'Fix UI bug' --date 2016-07-01

Met de parameter --date wordt de datum van de auteur ingesteld . Deze datum zal bijvoorbeeld verschijnen in de standaarduitvoer van git log .

Om de vastlegdatum ook te forceren:

GIT_COMMITTER_DATE=2016-07-01 git commit -m 'Fix UI bug' --date 2016-07-01

De parameter date accepteert de flexibele indelingen die worden ondersteund door GNU date, bijvoorbeeld:

git commit -m 'Fix UI bug' --date yesterday
git commit -m 'Fix UI bug' --date '3 days ago'
git commit -m 'Fix UI bug' --date '3 hours ago'

Als de datum geen tijd aangeeft, wordt de huidige tijd gebruikt en wordt alleen de datum overschreven.

Selecteren welke regels moeten worden geënsceneerd om te plegen

Stel dat u veel wijzigingen in een of meer bestanden hebt, maar van elk bestand dat u slechts enkele van de wijzigingen wilt doorvoeren, kunt u de gewenste wijzigingen selecteren met:

git add -p

of

git add -p [file]

Elk van uw wijzigingen wordt afzonderlijk weergegeven en voor elke wijziging wordt u gevraagd een van de volgende opties te kiezen:

y - Yes, add this hunk

n - No, don’t add this hunk

d - No, don’t add this hunk, or any other remaining hunks for this file.
    Useful if you’ve already added what you want to, and want to skip over the rest.

s - Split the hunk into smaller hunks, if possible

e - Manually edit the hunk.  This is probably the most powerful option.
    It will open the hunk in a text editor and you can edit it as needed.

Hiermee worden de delen van de bestanden die u kiest gefaseerd. Vervolgens kunt u alle geënsceneerde wijzigingen als volgt doorvoeren:

git commit -m 'Commit Message'

De wijzigingen die niet zijn doorgevoerd of doorgevoerd, worden nog steeds weergegeven in uw werkbestanden en kunnen later worden doorgevoerd indien nodig. Of als de resterende wijzigingen ongewenst zijn, kunnen ze worden verwijderd met:

git reset --hard

Afgezien van het opsplitsen van een grote verandering in kleinere commits, is deze aanpak ook nuttig om te bekijken wat je gaat plegen. Door elke wijziging afzonderlijk te bevestigen, hebt u de mogelijkheid om te controleren wat u hebt geschreven en kunt u voorkomen dat per ongeluk ongewenste code, zoals println / logging-instructies, wordt ingesteld.

De tijd van een commit wijzigen

Je cam past de tijd van een commit aan met behulp van

git commit --amend --date="Thu Jul 28 11:30 2016 -0400"

of zelfs

git commit --amend --date="now"

De auteur van een commit wijzigen

Als je een commit maakt als de verkeerde auteur, kun je deze wijzigen en vervolgens wijzigen

git config user.name "Full Name"
git config user.email "[email protected]"

git commit --amend --reset-author

GPG-ondertekening verbindt zich

1. Bepaal uw sleutel-ID

   gpg --list-secret-keys --keyid-format LONG
   
   /Users/davidcondrey/.gnupg/secring.gpg
   --------------------------------------
   sec   2048R/YOUR-16-DIGIT-KEY-ID YYYY-MM-DD [expires: YYYY-MM-DD]
   

   Uw ID is een alfanumerieke 16-cijferige code na de eerste slash.

2. Definieer je sleutel ID in je git config

   git config --global user.signingkey YOUR-16-DIGIT-KEY-ID
   

3. Vanaf versie 1.7.9 accepteert git commit de optie -S om een handtekening toe te voegen aan je commits. Als je deze optie gebruikt, wordt je GPG-wachtwoordzin gevraagd en wordt je handtekening toegevoegd aan het vastleggingslogboek.

   git commit -S -m "Your commit message"