Modifica dei dettagli dopo Git pull

Dopo un pull di Git, il suo output fornisce un riepilogo dell'importo della modifica.

Come posso vedere ogni o alcuni dei cambiamenti dettagliati dei file?

Ok, ecco la mia domanda a Jefromi:

1. Come faccio a sapere se stavo tirando dal maestro? Tutto quello che ho fatto è "git pull".

2. Cosa indica master e qual è la differenza tra master e HEAD, i due head predefiniti di Git?

3. Come posso vedere la modifica dettagliata in un file specifico?

4. Come vedo di nuovo la modifica nell'output di riepilogo dell'ultimo git pull?

5. Qual è la differenza tra git diffe git whatchanged?

Supponiamo che stai tirando verso il maestro. È possibile fare riferimento alla posizione precedente di masterby master@{1}(o anche master@{10.minutes.ago}, vedere la sezione revisioni Specifica della pagina man git-rev-parse ), in modo da poter fare le cose come

• Vedi tutte le modifiche: git diff master@{1} master

• Vedi le modifiche a un determinato file: git diff master@{1} master <file>

• Vedi tutte le modifiche all'interno di una determinata directory: git diff master@{1} master <dir>

• Vedi di nuovo il riepilogo delle modifiche: git diff --stat master@{1} master

Per quanto riguarda la tua domanda su "come faccio a sapere se sono padrone" ... beh, usare i rami è una parte importante del flusso di lavoro di Git. Devi sempre essere consapevole del ramo in cui ti trovi: se hai apportato modifiche, desideri portarle nel ramo giusto! Puoi vedere un elenco di tutti i rami, con un asterisco di quello attualmente estratto, con il comando git branch. Viene inoltre stampato il nome del ramo corrente insieme all'output di git status. Consiglio vivamente di sfogliare le pagine man dei comandi da usare: è un ottimo modo per acquisire lentamente alcune conoscenze.

E la tua ultima domanda: HEADè il nome del ramo attualmente estratto. Puoi davvero usare HEADe anche HEAD@{1}in questo contesto, ma è un po 'più robusto usare i rami, poiché se vai a dare un'occhiata a un altro ramo. HEADè ora quel secondo ramo, ed HEAD@{1}è ora master- non quello che vuoi!

Per evitare di dover fare molte piccole domande come questa, probabilmente dovresti dare un'occhiata a un tutorial Git. Ce ne sono un milione sul Web, ad esempio:

• Il libro Pro Git
• Git Magic
• e i 4,5 milioni di hit su Google per "Tutorial Git"

Di 'che fai un pull git in questo modo:

$ git pull
remote: Counting objects: 10, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 6 (delta 4), reused 0 (delta 0)
Unpacking objects: 100% (6/6), done.
From git@dev.example.com:reponame
   a407564..9f52bed  branchname   -> origin/branchname
Updating a407564..9f52bed
Fast forward
 .../folder/filename          |  209 ++++++++-----
 .../folder2/filename2        |  120 +++++++++++---------
 2 files changed, 210 insertions(+), 119 deletions(-)

Puoi vedere il diff di ciò che è cambiato usando i numeri di revisione:

$ git diff a407564..9f52bed

1. Come faccio a sapere se stavo tirando a master? Tutto quello che ho fatto è "git pull".

Il comando stesso funziona in questo modo:

git pull [options] [<repository> [<refspec>…]]

e per impostazione predefinita si riferisce al ramo corrente. Puoi controllare i tuoi rami usando

git branch -a

Questo elencherà le tue filiali locali e remote come ad esempio (aggiunto un --- divisore tra locale e remoto per renderlo più chiaro)

*master
foo
bar
baz
---
origin/HEAD -> origin/master
origin/deploy
origin/foo
origin/master
origin/bar
remote2/foo
remote2/baz

Quando dai un'occhiata a un repository remoto, vedrai a cosa ti riferisci:

git remote show origin

elencherà come segue:

* remote origin
  Fetch URL: ssh://git@git.example.com:12345/username/somerepo.git
  Push  URL: ssh://git@git.example.com:12345/username/somerepo.git
  HEAD branch: master
  Remote branches:
    foo    tracked
    master tracked
  Local refs configured for 'git push':
    foo    pushes to foo    (up to date)
    master pushes to master (fast-forwardable)

Quindi è abbastanza facile essere sicuri da dove tirare e spingere.

3. come vedere la modifica dei dettagli in un file specifico?

4. come vedere di nuovo la modifica dell'output di riepilogo di last git pull?

Il modo più semplice ed elegante (imo) è:

git diff --stat master@{1}..master --dirstat=cumulative,files

Questo ti darà due blocchi di informazioni sui cambiamenti tra il tuo ultimo pull e lo stato attuale del lavoro. Esempio di output (ho aggiunto un --- divisore tra --state --dirstatoutput per renderlo più chiaro):

 mu-plugins/media_att_count.php                     |  0
 mu-plugins/phpinfo.php                             |  0
 mu-plugins/template_debug.php                      |  0
 themes/dev/archive.php                             |  0
 themes/dev/category.php                            | 42 ++++++++++++++++++
 .../page_templates/foo_template.php                |  0
 themes/dev/style.css                               |  0
 themes/dev/tag.php                                 | 44 +++++++++++++++++++
 themes/dev/taxonomy-post_format.php                | 41 +++++++++++++++++
 themes/dev/template_parts/bar_template.php         |  0
 themes/someproject/template_wrappers/loop_foo.php  | 51 ++++++++++++++++++++++
---
 11 files changed, 178 insertions(+)
  71.3% themes/dev/
  28.6% themes/someproject/template_wrappers/
 100.0% themes/
  27.2% mu-plugins/
   9.0% themes/dev/page_templates/
   9.0% themes/dev/template_parts/
  63.6% themes/dev/
   9.0% themes/someproject/template_wrappers/
  72.7% themes/

In questo modo è un po 'confuso, ma ti permetterà di usare strumenti grafici come gitko gitgo git-gui:

git pull
git reset HEAD@{1}
gitg (or gitk or whatever tool you like)

La risposta con il maggior numero di voti offre il modo migliore utilizzando lo strumento git, ma uso questo metodo perché posso quindi utilizzare gli strumenti con la GUI per vedere le modifiche: P

Avrei quindi il passaggio extra di fare un git checkout .e poi farlo di git pullnuovo in modo da tirare e unire correttamente, ma apprezzo la capacità di esaminare le differenze in una GUI abbastanza da affrontare i due passaggi aggiuntivi.