Detailänderung nach Git Pull

Nach einem Git-Pull gibt die Ausgabe eine Zusammenfassung des Änderungsbetrags.

Wie kann ich jede oder einige der detaillierten Detailänderungen der Dateien sehen?

Okay, hier ist meine Frage an Jefromi:

1. Woher weiß ich, ob ich zum Meister gezogen habe? Alles was ich getan habe ist "git pull".

2. Worauf weist Master hin und was ist der Unterschied zwischen Master und HEAD, den beiden Standardköpfen von Git?

3. Wie sehe ich die detaillierte Änderung in einer bestimmten Datei?

4. Wie sehe ich die Änderung in der Zusammenfassungsausgabe bis zum letzten git pullMal wieder?

5. Was ist der Unterschied zwischen git diffund git whatchanged?

Angenommen, Sie ziehen, um zu meistern. Sie können auf die vorherige Position von masterby verweisen master@{1}(oder sogar auf master@{10.minutes.ago}den Abschnitt über die Angabe von Revisionen auf der Manpage git-rev-parse ), damit Sie Dinge wie tun können

• Alle Änderungen anzeigen: git diff master@{1} master

• Siehe die Änderungen an einer bestimmten Datei: git diff master@{1} master <file>

• Alle Änderungen in einem bestimmten Verzeichnis anzeigen: git diff master@{1} master <dir>

• Siehe die Zusammenfassung der Änderungen noch einmal: git diff --stat master@{1} master

Was Ihre Frage betrifft: "Woher weiß ich, ob ich auf dem Master bin?" Nun, die Verwendung von Zweigen ist ein wichtiger Teil des Git-Workflows. Sie sollten immer wissen, in welchem ​​Zweig Sie sich befinden - wenn Sie Änderungen vorgenommen haben, möchten Sie sie in den richtigen Zweig ziehen! Mit dem Befehl können Sie eine Liste aller Zweige mit einem Sternchen neben dem aktuell ausgecheckten anzeigen git branch. Der aktuelle Filialname wird zusammen mit der Ausgabe von gedruckt git status. Ich empfehle dringend, die Manpages der zu verwendenden Befehle zu überfliegen - dies ist eine großartige Möglichkeit, langsam etwas Wissen zu sammeln.

Und Ihre letzte Frage: HEADist der Name für den aktuell ausgecheckten Zweig. Sie können zwar auch HEADund HEAD@{1}in diesem Zusammenhang auch verwenden, aber es ist etwas robuster, die Zweige zu verwenden, da Sie einen anderen Zweig auschecken müssen. HEADist jetzt dieser zweite Zweig und HEAD@{1}ist jetzt master- nicht was du willst!

Um zu vermeiden, dass Sie viele kleine Fragen wie diese stellen müssen, sollten Sie sich wahrscheinlich ein Git-Tutorial ansehen. Es gibt eine Million im Web, zum Beispiel:

• Das Pro Git Buch
• Git Magic
• und die 4,5 Millionen Hits bei Google für "Git Tutorial"

Angenommen, Sie machen einen Git-Pull wie folgt:

$ 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(-)

Anhand der Versionsnummern können Sie den Unterschied erkennen, der sich geändert hat:

$ git diff a407564..9f52bed

1. Woher weiß ich, ob ich zum Master gezogen habe? Alles was ich getan habe ist "git pull".

Der Befehl selbst funktioniert folgendermaßen:

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

und bezieht sich standardmäßig auf den aktuellen Zweig. Sie können Ihre Filialen mit überprüfen

git branch -a

Dadurch werden Ihre lokalen und Remote-Zweige aufgelistet, wie z. B. ( --- Als Teiler zwischen lokal und Remote hinzugefügt , um dies klarer zu machen)

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

Wenn Sie sich dann ein Remote-Repo ansehen, werden Sie sehen, worauf Sie sich beziehen:

git remote show origin

wird wie folgt aufgelistet:

* 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)

Es ist also ziemlich einfach, sicher zu sein, woher man zieht und wohin man schiebt.

3. Wie kann man die Detailänderung in einer bestimmten Datei sehen?

4. Wie kann man die Änderung der Zusammenfassungsausgabe durch den letzten Git-Pull erneut sehen?

Der einfachste und eleganteste Weg (imo) ist:

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

Auf diese Weise erhalten Sie zwei Informationsblöcke über die Änderungen zwischen Ihrem letzten Zug und dem aktuellen Arbeitsstatus. Beispielausgabe (Ich habe einen --- als Teiler zwischen --statund --dirstatAusgabe hinzugefügt , um es klarer zu machen):

 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/

Dieser Weg ist etwas hackig, aber Sie können damit grafische Tools wie gitkoder gitgoder verwenden git-gui:

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

Die Antwort mit den meisten Upvotes gibt den besten Weg mit dem Git-Tool, aber ich verwende diese Methode, weil ich dann Tools mit GUI verwenden kann, um die Änderungen zu sehen: P.

Ich hätte dann den zusätzlichen Schritt, ein git checkout .und dann git pullerneut auszuführen, damit ich richtig ziehen und zusammenführen kann, aber ich schätze die Fähigkeit, Unterschiede in einer GUI genug zu untersuchen, um die zusätzlichen zwei Schritte zu bewältigen.