Git
commettere

introduzione

Sintassi

• git commit [bandiere]

Parametri

Commettendo senza aprire un editore

Git di solito apre un editor (come vim o emacs ) quando si esegue git commit . Passare l'opzione -m per specificare un messaggio dalla riga di comando:

git commit -m "Commit message here"

Il tuo messaggio di commit può andare su più righe:

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

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

In alternativa, puoi passare più argomenti -m :

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

Vedi Come scrivere un messaggio di commit Git .

Udacity Git Commit Guida allo stile dei messaggi

Modifica di un commit

Se il tuo ultimo commit non è ancora stato pubblicato (non inviato a un repository upstream), puoi modificare il tuo commit.

git commit --amend

Questo metterà le modifiche attualmente in scena sul commit precedente.

Nota: questo può essere utilizzato anche per modificare un messaggio di commit errato. Verrà visualizzato l'editor predefinito (in genere vi / vim / emacs ) e ti permetterà di cambiare il messaggio precedente.

Per specificare il messaggio di commit in linea:

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

O per usare il messaggio di commit precedente senza cambiarlo:

git commit --amend --no-edit

La modifica aggiorna la data di commit ma lascia intatta la data dell'autore. Puoi dire a git di aggiornare le informazioni.

git commit --amend --reset-author

Puoi anche cambiare l'autore del commit con:

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

Nota: tenere presente che modificare il commit più recente lo sostituisce completamente e il commit precedente viene rimosso dalla cronologia del ramo. Questo dovrebbe essere tenuto presente quando si lavora con archivi pubblici e filiali con altri collaboratori.

Ciò significa che se il commit precedente era già stato spinto, dopo averlo modificato dovrai push --force .

Commettere direttamente le modifiche

Di solito, devi usare git add o git rm per aggiungere modifiche all'indice prima di poterle git commit . Passa l'opzione -a o --all per aggiungere automaticamente ogni modifica (ai file tracciati) all'indice, incluse le rimozioni:

git commit -a 

Se vuoi aggiungere anche un messaggio di commit, dovresti fare:

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

Inoltre, puoi unire due flag:

git commit -am "your commit message goes here"

Non è necessario necessariamente eseguire il commit di tutti i file contemporaneamente. Ometti il ​​flag -a o --all e specifica il file che desideri eseguire direttamente:

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

Per il commit diretto di più di un file specifico, è possibile specificare uno o più file, directory e pattern:

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

Creare un commit vuoto

In generale, il vuoto commette (o commette con stato identico al genitore) è un errore.

Tuttavia, quando si testano build hook, sistemi CI e altri sistemi che attivano un commit, è utile poter creare facilmente commit senza dover modificare / toccare un file fittizio.

Il --allow-empty il controllo.

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

Metti in scena e commetti modifiche

Le basi

Dopo aver apportato modifiche al tuo codice sorgente, dovresti mettere in scena tali modifiche con Git prima di poterle impegnare.

Ad esempio, se modifichi README.md e program.py :

git add README.md program.py

Questo dice a Git che vuoi aggiungere i file al prossimo commit che fai.

Quindi, invia i tuoi cambiamenti con

git commit

Si noti che questo aprirà un editor di testo, che è spesso vim . Se non hai familiarità con Vim, potresti voler sapere che puoi premere i per entrare in modalità inserimento , scrivere il tuo messaggio di commit, quindi premere Esc e :wq per salvare e uscire. Per evitare di aprire l'editor di testo, includi semplicemente il flag -m con il tuo messaggio

git commit -m "Commit message here"

I messaggi di commit spesso seguono alcune regole di formattazione specifiche, vedi Buoni messaggi di commit per ulteriori informazioni.

Tasti di scelta rapida

Se hai modificato molti file nella directory, invece di elencarli singolarmente, puoi utilizzare:

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

O per aggiungere tutte le modifiche, ad esclusione dei file che sono stati cancellati , dalla directory principale e dalle sottodirectory:

git add .

Oppure per aggiungere solo file attualmente tracciati ("aggiornamento"):

git add -u

Se lo si desidera, rivedere le modifiche graduali:

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

Infine, accetta le modifiche:

git commit -m "Commit message here"

In alternativa, se hai solo modificato file esistenti o eliminati e non ne hai creati di nuovi, puoi combinare le azioni di git add e git commit in un unico comando:

git commit -am "Commit message here"

Si noti che questo metterà in scena tutti i file modificati allo stesso modo di git add --all .

Dati sensibili

Non si dovrebbero mai impegnare dati sensibili, come password o chiavi private. Se questo caso si verifica e le modifiche sono già state trasferite a un server centrale, considerare eventuali dati sensibili come compromessi. Altrimenti, è possibile rimuovere tali dati in seguito. Una soluzione rapida e semplice è l'utilizzo di "BFG Repo-Cleaner": https://rtyley.github.io/bfg-repo-cleaner/ .

Il comando bfg --replace-text passwords.txt my-repo.git legge le password dal file passwords.txt e le sostituisce con ***REMOVED*** . Questa operazione considera tutti i commit precedenti dell'intero repository.

Impegnarsi per conto di qualcun altro

Se qualcun altro ha scritto il codice che stai impegnando, puoi dare loro credito con l'opzione --author :

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

Puoi anche fornire uno schema, che Git utilizzerà per cercare autori precedenti:

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

In questo caso, verranno utilizzate le informazioni dell'autore dal commit più recente con un autore contenente "John".

Su GitHub, i commit effettuati in uno dei due modi sopra mostreranno la miniatura di un autore di grandi dimensioni, con il committer più piccolo e davanti:

Commettere modifiche in file specifici

Puoi commutare le modifiche apportate a file specifici e ignorarle con l'uso di git add :

git commit file1.c file2.h

O puoi prima mettere in scena i file:

git add file1.c file2.h

e impegnali in seguito:

git commit

Buoni messaggi di commit

È importante per qualcuno che attraversa il git log per capire facilmente di cosa si trattava ogni commit. I buoni messaggi di commit di solito includono un numero di un'attività o un problema in un tracker e una descrizione concisa di ciò che è stato fatto e perché, e talvolta anche di come è stato fatto.

I messaggi migliori possono avere il seguente aspetto:

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

Considerando che i seguenti messaggi non sarebbero abbastanza utili:

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?

Un modo per verificare se un messaggio di commit è stato scritto nell'umore giusto è quello di sostituire lo spazio vuoto con il messaggio e vedere se ha senso:

Se aggiungo questo commit, farò ___ al mio repository.

Le sette regole di un grande messaggio di commit git

1. Separare la linea dell'oggetto dal corpo con una riga vuota
2. Limita la riga dell'oggetto a 50 caratteri
3. Capitalizzare la riga dell'oggetto
4. Non terminare la riga dell'oggetto con un punto
5. Usa l' umore imperativo nella riga dell'oggetto
6. Avvolgere manualmente ogni linea del corpo a 72 caratteri
7. Usa il corpo per spiegare cosa e perché invece di come

7 regole del blog di Chris Beam .

Commettere in una data specifica

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

Il parametro --date imposta la data dell'autore . Questa data apparirà nell'output standard di git log , ad esempio.

Per forzare anche la data di commit :

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

Il parametro date accetta i formati flessibili supportati dalla data di GNU, ad esempio:

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'

Quando la data non specifica l'ora, verrà utilizzata l'ora corrente e solo la data verrà sostituita.

Selezionare quali linee dovrebbero essere messe in scena per l'impegno

Supponiamo che tu abbia molte modifiche in uno o più file, ma da ogni file vuoi solo salvare alcune delle modifiche, puoi selezionare le modifiche desiderate usando:

git add -p

o

git add -p [file]

Ciascuno dei tuoi cambiamenti verrà visualizzato individualmente, e per ogni modifica ti verrà richiesto di scegliere una delle seguenti opzioni:

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.

Questo metterà in scena le parti dei file che scegli. Quindi puoi commettere tutte le modifiche graduali come questa:

git commit -m 'Commit Message'

Le modifiche che non sono state gestite o impegnate verranno comunque visualizzate nei file di lavoro e potranno essere successivamente inoltrate, se necessario. O se le modifiche rimanenti non sono volute, possono essere scartate con:

git reset --hard

Oltre a rompere un grande cambiamento in piccoli commit, questo approccio è anche utile per rivedere ciò che stai per commettere. Confermando singolarmente ogni modifica, hai l'opportunità di verificare ciò che hai scritto e puoi evitare di mettere in scena accidentalmente codice indesiderato come println / dichiarazioni di registrazione.

Modifica del tempo di un commit

Si cam modifica l'ora di un commit utilizzando

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

o anche

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

Modifica dell'autore di un commit

Se si commette un commit come autore errato, è possibile modificarlo e quindi modificare

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

git commit --amend --reset-author

La firma GPG si impegna

1. Determina il tuo ID chiave

   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]
   

   Il tuo ID è un codice alfanumerico di 16 cifre che segue la prima barra di avanzamento.

2. Definisci il tuo ID chiave nel tuo git config

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

3. A partire dalla versione 1.7.9, git commit accetta l'opzione -S per allegare una firma ai tuoi commit. L'utilizzo di questa opzione richiederà la passphrase GPG e aggiungerà la tua firma al log di commit.

   git commit -S -m "Your commit message"