Zmiana szczegółów po ściągnięciu Git

Po ściągnięciu przez Git jego dane wyjściowe zawierają podsumowanie wielkości zmiany.

Jak mogę zobaczyć szczegółowe zmiany w każdym lub niektórych plikach?

OK, oto moje pytanie do Jefromiego:

1. Skąd mam wiedzieć, czy ciągnąłem do mistrzostwa? Wszystko, co zrobiłem, to „git pull”.

2. Na co wskazuje master i jaka jest różnica między master i HEAD, dwoma domyślnymi głowicami Gita?

3. Jak wyświetlić szczegółową zmianę w określonym pliku?

4. Jak ponownie zobaczyć zmianę w podsumowaniu wyników przez ostatnie git pull?

5. Jaka jest różnica między git diffi git whatchanged?

Załóżmy, że ciągniesz do mistrzostwa. Możesz odwołać się do poprzedniej pozycji masterby master@{1}(lub nawet master@{10.minutes.ago}; zobacz sekcję określającą wersje strony podręcznika git-rev-parse ), dzięki czemu możesz robić takie rzeczy jak

• Zobacz wszystkie zmiany: git diff master@{1} master

• Zobacz zmiany w podanym pliku: git diff master@{1} master <file>

• Zobacz wszystkie zmiany w danym katalogu: git diff master@{1} master <dir>

• Zobacz podsumowanie zmian ponownie: git diff --stat master@{1} master

Jeśli chodzi o twoje pytanie „skąd mam wiedzieć, czy jestem na master”… cóż, używanie gałęzi jest ważną częścią przepływu pracy Gita. Zawsze powinieneś być świadomy tego, na której gałęzi się znajdujesz - jeśli wyciągnąłeś zmiany, chcesz przeciągnąć je do właściwej gałęzi! Możesz zobaczyć listę wszystkich gałęzi, z gwiazdką przy aktualnie wyewidencjonowanym, za pomocą polecenia git branch. Bieżąca nazwa gałęzi jest również drukowana wraz z danymi wyjściowymi git status. Bardzo polecam przejrzenie stron podręcznika man poleceń - to świetny sposób na powolne zdobywanie wiedzy.

I ostatnie pytanie: HEADto nazwa aktualnie wyewidencjonowanego oddziału. Rzeczywiście możesz użyć HEADiw HEAD@{1}tym kontekście, ale użycie gałęzi jest nieco bardziej niezawodne, ponieważ jeśli pójdziesz i sprawdź inną gałąź. HEADjest teraz tą drugą gałęzią i HEAD@{1}jest teraz master- nie tym, czego chcesz!

Aby uniknąć konieczności zadawania wielu takich małych pytań, prawdopodobnie powinieneś rzucić okiem na samouczek Gita. W sieci jest milion, na przykład:

• Książka Pro Git
• Git Magic
• i 4,5 miliona odsłon w Google dotyczących „samouczka Git”

Powiedz, że wykonujesz takie git pull:

$ 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 [email protected]:reponame
   a407564..9f52bed  branchname   -> origin/branchname
Updating a407564..9f52bed
Fast forward
 .../folder/filename          |  209 ++++++++-----
 .../folder2/filename2        |  120 +++++++++++---------
 2 files changed, 210 insertions(+), 119 deletions(-)

Możesz zobaczyć różnicę tego, co się zmieniło, używając numerów wersji:

$ git diff a407564..9f52bed

1. Skąd mam wiedzieć, czy ciągnę do mistrzostwa? Wszystko, co zrobiłem, to „git pull”.

Samo polecenie działa w ten sposób:

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

i domyślnie odnosi się do bieżącej gałęzi. Możesz sprawdzić swoje oddziały za pomocą

git branch -a

Spowoduje to wyświetlenie lokalnych i zdalnych oddziałów, takich jak np. (Dodano --- jako dzielnik między lokalnym i zdalnym, aby było bardziej przejrzyste)

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

Kiedy następnie spojrzysz na jedno zdalne repozytorium, zobaczysz, do czego się odnosisz:

git remote show origin

wyświetli się następująco:

* remote origin
  Fetch URL: ssh://[email protected]:12345/username/somerepo.git
  Push  URL: ssh://[email protected]: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)

Dlatego łatwo jest mieć pewność, skąd wyciągnąć i pchać.

3. jak zobaczyć zmianę szczegółów w określonym pliku?

4. jak ponownie zobaczyć zmianę w podsumowaniu wyników ostatniego git pull?

Najłatwiejszy i najbardziej elegancki sposób (imo) to:

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

W ten sposób uzyskasz dwa bloki informacji o zmianach między ostatnim pociągnięciem a bieżącym stanem pracy. Przykładowe dane wyjściowe (dodałem --- jako dzielnik między --stati --dirstatwyjście, aby było bardziej przejrzyste):

 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/

Ten sposób jest trochę hakerski, ale pozwoli ci użyć narzędzi graficznych, takich jak gitklub gitglub git-gui:

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

Odpowiedź z największą liczbą głosów pozytywnych daje najlepszy sposób za pomocą narzędzia git, ale używam tej metody, ponieważ mogę następnie użyć narzędzi z GUI, aby zobaczyć zmiany: P

Miałbym wtedy dodatkowy krok, aby wykonać a, git checkout .a następnie zrobić to git pullponownie, aby poprawnie wyciągnąć i scalić, ale cenię sobie możliwość zbadania różnic w GUI na tyle, aby poradzić sobie z dodatkowymi dwoma krokami.