Changement de détail après le pull Git

Après un pull Git, sa sortie donne un résumé du montant du changement.

Comment puis-je voir les modifications détaillées de chacun ou de certains fichiers?

D'accord, voici ma question à Jefromi:

1. Comment savoir si je tirais vers la maîtrise? Tout ce que j'ai fait, c'est "git pull".

2. Sur quoi pointe master et quelle est la différence entre master et HEAD, les deux têtes par défaut de Git?

3. Comment voir la modification détaillée dans un fichier spécifique?

4. Comment puis-je voir à nouveau le changement dans la sortie de résumé par le dernier git pull?

5. Quelle est la différence entre git diffet git whatchanged?

Supposons que vous tiriez vers le maître. Vous pouvez vous référer à la position précédente de masterby master@{1}(ou même master@{10.minutes.ago}; voir la section de spécification des révisions de la page de manuel git-rev-parse ), afin de pouvoir faire des choses comme

• Voir tous les changements: git diff master@{1} master

• Voir les modifications apportées à un fichier donné: git diff master@{1} master <file>

• Voir toutes les modifications dans un répertoire donné: git diff master@{1} master <dir>

• Consultez à nouveau le résumé des modifications: git diff --stat master@{1} master

Quant à votre question "comment savoir si je suis sur master" ... eh bien, l'utilisation de branches est une partie importante du workflow Git. Vous devez toujours être conscient de la branche sur laquelle vous vous trouvez - si vous avez effectué des modifications, vous voulez les tirer vers la bonne branche! Vous pouvez voir une liste de toutes les branches, avec un astérisque à côté de celle actuellement extraite, avec la commande git branch. Le nom de la branche actuelle est également imprimé avec la sortie de git status. Je recommande vivement de parcourir les pages de manuel des commandes à utiliser - c'est un excellent moyen d'acquérir lentement des connaissances.

Et votre dernière question: HEADest le nom de la branche actuellement extraite. Vous pouvez en effet utiliser HEADet HEAD@{1}dans ce contexte également, mais c'est un peu plus robuste d'utiliser les branches, car si vous allez vérifier une autre branche. HEADest maintenant cette deuxième branche, et HEAD@{1}est maintenant master- pas ce que vous voulez!

Pour éviter d'avoir à poser beaucoup de petites questions comme celle-ci, vous devriez probablement jeter un œil à un didacticiel Git. Il y en a un million sur le web, par exemple:

• Le livre Pro Git
• Git Magic
• et les 4,5 millions de visites sur Google pour "Git tutorial"

Dites que vous faites un git pull comme ceci:

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

Vous pouvez voir la différence de ce qui a changé en utilisant les numéros de révision:

$ git diff a407564..9f52bed

1. Comment savoir si je tirais vers la maîtrise? Tout ce que j'ai fait, c'est "git pull".

La commande elle-même fonctionne comme ceci:

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

et par défaut fait référence à la branche actuelle. Vous pouvez vérifier vos succursales en utilisant

git branch -a

Cela listera vos succursales locales et distantes comme par exemple (Ajout d'un --- diviseur as entre local et distant pour le rendre plus clair)

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

Lorsque vous examinez ensuite un dépôt distant, vous verrez à quoi vous faites référence:

git remote show origin

listera comme suit:

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

Il est donc assez facile de savoir d'où tirer et de pousser.

3. comment voir le détail changer dans un fichier spécifique?

4. comment voir à nouveau le changement dans la sortie de résumé par le dernier pull git?

Le moyen le plus simple et le plus élégant (imo) est:

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

Cela vous donnera deux blocs d'informations sur les changements entre votre dernier tirage et l'état actuel du travail. Exemple de sortie (j'ai ajouté un --- diviseur entre --statet la --dirstatsortie pour le rendre plus clair):

 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/

Cette méthode est un peu piratée, mais elle vous permettra d'utiliser des outils graphiques comme gitkou gitgou git-gui:

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

La réponse avec le plus de votes positifs donne le meilleur moyen d'utiliser l'outil git, mais j'utilise cette méthode car je peux ensuite utiliser des outils avec une interface graphique pour voir les changements: P

J'aurais alors l'étape supplémentaire de faire un git checkout ., puis de le faire à git pullnouveau pour que je tire et fusionne correctement, mais j'apprécie suffisamment la possibilité d'examiner les différences dans une interface graphique pour gérer les deux étapes supplémentaires.