Git
begå

Introduktion

Syntax

• git commit [flaggor]

parametrar

Åtar sig utan att öppna en redaktör

Git öppnar vanligtvis en redigerare (som vim eller emacs ) när du kör git commit . -m alternativet -m att ange ett meddelande från kommandoraden:

git commit -m "Commit message here"

Ditt engagemang kan gå över flera rader:

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

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

Alternativt kan du skicka in flera -m argument:

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

Se Hur man skriver ett Git-meddelande .

Udacity Git Commit Message Style Guide

Ändra en åtagande

Om ditt senaste åtagande inte har publicerats ännu (inte skjutits till ett uppströmsförråd) kan du ändra ditt åtagande.

git commit --amend

Detta kommer att lägga de för närvarande iscensatta ändringarna på det tidigare åtagandet.

Obs! Detta kan också användas för att redigera ett felaktigt meddelande om åtagande. Det tar upp standardredigeraren (vanligtvis vi / vim / emacs ) och låter dig ändra det tidigare meddelandet.

Så här anger du inloggningsmeddelandet inline:

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

Eller för att använda det tidigare åtagandemeddelandet utan att ändra det:

git commit --amend --no-edit

Ändring uppdaterar åtagandedatumet men lämnar författarens datum orört. Du kan be git att uppdatera informationen.

git commit --amend --reset-author

Du kan också ändra författaren till åtagandet med:

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

Obs: Var medveten om att ändring av det senaste åtagandet ersätter det helt och att det tidigare åtagandet tas bort från filialens historia. Detta bör hållas i minnet när man arbetar med offentliga förvar och på filialer med andra kollaboratörer.

Detta innebär att om det tidigare åtagandet redan hade skjutits, efter att du har ändrat det, måste du push --force .

Genomför ändringar direkt

Vanligtvis måste du använda git add eller git rm att lägga till ändringar i indexet innan du kan git commit dem. --all alternativet -a eller --all att automatiskt lägga till varje ändring (till spårade filer) i indexet, inklusive borttagningar:

git commit -a 

Om du också vill lägga till ett meddelande om engagemang skulle du göra:

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

Du kan också gå med i två flaggor:

git commit -am "your commit message goes here"

Du behöver inte nödvändigtvis begå alla filer på en gång. --all flaggan -a eller --all och ange vilken fil du vill begå direkt:

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

För att direkt använda mer än en specifik fil kan du också ange en eller flera filer, kataloger och mönster:

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

Skapa en tom åtagande

Generellt sett är tomma åtaganden (eller begår med tillstånd som är identiska med föräldern) ett fel.

Men när man testar byggkrokar, CI-system och andra system som utlöser ett åtagande, är det praktiskt att enkelt kunna skapa åtaganden utan att behöva redigera / röra en dummy-fil.

Den --allow-empty åtaganden kommer att kringgå kontrollen.

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

Scene och begå förändringar

Det grundläggande

När du har gjort ändringar i källkoden, bör du arrangera dessa ändringar med Git innan du kan begå dem.

Om du till exempel ändrar README.md och program.py :

git add README.md program.py

Detta säger GIT att du vill lägga till filerna till nästa åtagande du gör.

Sedan begå dina ändringar med

git commit

Observera att detta öppnar en textredigerare, som ofta är vim . Om du inte är bekant med vim, kanske du vill veta att du kan trycka på i att gå till insert- läge, skriva ditt engagemang och tryck sedan på Esc och :wq att spara och avsluta. För att undvika att öppna textredigeraren, inkludera helt enkelt flaggan -m ditt meddelande

git commit -m "Commit message here"

Kommittémeddelanden följer ofta vissa specifika formateringsregler, se Bra åtagandemeddelanden för mer information.

Genvägar

Om du har ändrat många filer i katalogen, snarare än att lista upp var och en av dem, kan du använda:

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

Eller för att lägga till alla ändringar, inte inklusive filer som har raderats , från den översta katalogen och underkatalogerna:

git add .

Eller för att bara lägga till filer som för närvarande spåras ("uppdatera"):

git add -u

Om så önskas, granska de iscensatta ändringarna:

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

Slutligen begå ändringarna:

git commit -m "Commit message here"

Alternativt, om du bara har modifierat befintliga filer eller raderade filer och inte har skapat några nya, kan du kombinera åtgärderna för git add och git commit i ett enda kommando:

git commit -am "Commit message here"

Observera att detta kommer att scenera alla modifierade filer på samma sätt som git add --all .

Känslig data

Du bör aldrig begå någon känslig information, till exempel lösenord eller ens privata nycklar. Om det här fallet inträffar och ändringarna redan har skjutits till en central server ska du överväga all känslig information som komprometterad. Annars är det möjligt att ta bort sådana data efteråt. En snabb och enkel lösning är användningen av "BFG Repo-Cleaner": https://rtyley.github.io/bfg-repo-cleaner/ .

Kommandot bfg --replace-text passwords.txt my-repo.git läser lösenord från filen passwords.txt och ersätter dessa med ***REMOVED*** . Den här åtgärden beaktar alla tidigare åtaganden i hela förvaret.

Åtar sig för någon annans räkning

Om någon annan skrev koden du begår kan du ge dem kredit med alternativet - --author :

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

Du kan också tillhandahålla ett mönster som Git kommer att använda för att söka efter tidigare författare:

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

I det här fallet kommer författarinformationen från det senaste åtagandet med en författare som innehåller "John" att användas.

På GitHub kommer åtaganden gjorda på något av ovanstående sätt att visa en stor författares miniatyrbild, med pendlarens mindre och framför:

Återför ändringar i specifika filer

Du kan göra ändringar i specifika filer och hoppa över iscensättning av dem med git add :

git commit file1.c file2.h

Eller så kan du först stega filerna:

git add file1.c file2.h

och begå dem senare:

git commit

Bra engagemang

Det är viktigt för någon som går igenom git log att lätt förstå vad varje begå handlade om. Bra engagemang inkluderar vanligtvis ett antal uppgifter eller problem i en tracker och en kort beskrivning av vad som har gjorts och varför, och ibland också hur det har gjorts.

Bättre meddelanden kan se ut:

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

Följande meddelanden skulle inte vara lika användbara:

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?

Ett sätt att testa om ett åtagandemeddelande är skrivet i rätt stämning är att ersätta blanket med meddelandet och se om det är meningsfullt:

Om jag lägger till denna åtagande kommer jag att ___ till mitt arkiv.

De sju reglerna för ett stort git-meddelande

1. Separera ämnesraden från kroppen med en tom linje
2. Begränsa ämnesraden till 50 tecken
3. Skriv ut ämnesraden
4. Avsluta inte ämnesraden med en period
5. Använd det tvingande stämningen i ämnesraden
6. Förpacka varje rad i kroppen manuellt med 72 tecken
7. Använd kroppen för att förklara vad och varför istället för hur

7 regler från Chris Beams blogg .

Åtar sig vid ett visst datum

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

Parametern - --date ställer in författarens datum . Detta datum visas till exempel i standardutgången från git log .

För att tvinga åtagandedatumet också:

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

Datumparametern accepterar de flexibla formaten som stöds av GNU-datum, till exempel:

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'

När datumet inte anger tid, kommer den aktuella tiden att användas och endast datumet kommer att åsidosättas.

Välja vilka rader som ska arrangeras för att begå

Anta att du har många ändringar i en eller flera filer, men från varje fil du bara vill göra några av ändringarna kan du välja önskade ändringar med:

git add -p

eller

git add -p [file]

Var och en av dina ändringar kommer att visas individuellt, och för varje ändring uppmanas du att välja ett av följande alternativ:

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.

Detta kommer att styra de delar av filerna du väljer. Då kan du göra alla iscensatta förändringar så här:

git commit -m 'Commit Message'

Ändringarna som inte iscensatt eller begåtts kommer fortfarande att visas i dina arbetsfiler och kan begås senare vid behov. Eller om de återstående ändringarna är oönskade kan de kasseras med:

git reset --hard

Bortsett från att dela upp en stor förändring till mindre åtaganden, är detta tillvägagångssätt också användbart för att granska vad du ska göra. Genom att individuellt bekräfta varje ändring har du en möjlighet att kontrollera vad du skrev och kan undvika oavsiktlig iscensättning av oönskad kod, t.ex.

Ändra tiden för ett åtagande

Du kan ändra tiden för ett åtagande med hjälp av

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

eller ens

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

Ändring av författaren till en åtagande

Om du gör ett åtagande som fel författare kan du ändra det och sedan ändra det

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

git commit --amend --reset-author

GPG-signering förbinder sig

1. Bestäm ditt nyckel-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]
   

   Ditt ID är en alfanumerisk 16-siffrig kod efter den första snedstrecken.

2. Definiera ditt nyckel-ID i din GIT-konfiguration

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

3. Från version 1.7.9 accepterar git commit alternativet -S för att bifoga en signatur till dina åtaganden. Om du använder det här alternativet frågar du om din GPG-lösenfras och lägger till din signatur i åtagandeloggen.

   git commit -S -m "Your commit message"