Afficher l'historique des modifications d'un fichier à l'aide du contrôle de version Git

Comment puis-je voir l'historique des modifications d'un fichier individuel dans Git, les détails complets avec ce qui a changé?

Je suis allé jusqu'à:

git log -- [filename]

qui me montre l'historique de validation du fichier, mais comment puis-je obtenir le contenu de chacune des modifications de fichier?

J'essaie de faire la transition de MS SourceSafe et qui était un simple right-click→ show history.

Pour cela, j'utiliserais:

gitk [filename]

ou pour suivre les noms de fichiers passés

gitk --follow [filename]

Vous pouvez utiliser

git log -p filename

pour laisser git générer les correctifs pour chaque entrée de journal.

Voir

git help log

pour plus d'options - il peut en fait faire beaucoup de belles choses :) Pour obtenir juste le diff pour un commit spécifique, vous pouvez

git show HEAD 

ou toute autre révision par identifiant. Ou utiliser

gitk

pour parcourir visuellement les modifications.

git log --follow -p -- path-to-file

Cela montrera tout l' historique du fichier (y compris l'historique au-delà des renommages et avec des différences pour chaque changement).

En d'autres termes, si le fichier nommé bara déjà été nommé foo, alors git log -p bar(sans l' --followoption) n'affichera que l'historique du fichier jusqu'au moment où il a été renommé - il n'affichera pas l'historique du fichier lorsqu'il était appelé foo. L'utilisation git log --follow -p baraffichera l'historique complet du fichier, y compris toutes les modifications apportées au fichier lorsqu'il était connu sous le nom foo. L' -poption garantit que les différences sont incluses pour chaque modification.

Si vous préférez rester basé sur du texte, vous pouvez utiliser tig .

Installation rapide:

• apt-get :# apt-get install tig
• Homebrew (OS X) :$ brew install tig

Utilisez-le pour afficher l'historique sur un seul fichier: tig [filename]
ou parcourez l'historique détaillé du référentiel:tig

Similaire à gitkmais basé sur du texte. Prend en charge les couleurs dans le terminal!

git whatchanged -p filenameest également équivalent à git log -p filenamedans ce cas.

Vous pouvez également voir quand une ligne de code spécifique à l'intérieur d'un fichier a été modifiée avec git blame filename. Cela affichera un court ID de validation, l'auteur, l'horodatage et une ligne de code complète pour chaque ligne du fichier. Ceci est très utile après avoir trouvé un bogue et vous voulez savoir quand il a été introduit (ou qui en est la faute).

Utilisateurs de SourceTree

Si vous utilisez SourceTree pour visualiser votre référentiel (c'est gratuit et assez bon), vous pouvez cliquer avec le bouton droit sur un fichier et sélectionner Journal sélectionné

L'affichage (ci-dessous) est beaucoup plus convivial que gitk et la plupart des autres options répertoriées. Malheureusement (pour le moment), il n'y a pas de moyen facile de lancer cette vue à partir de la ligne de commande - CLI de SourceTree ouvre actuellement juste repos

Pour afficher la révision et l'auteur de la dernière modification de chaque ligne d'un fichier:

git blame filename

ou si vous souhaitez utiliser la puissante interface graphique de blâme:

git gui blame filename

Résumé des autres réponses après les avoir lues et joué un peu:

La commande habituelle en ligne de commande serait

git log --follow --all -p dir/file.c

Mais vous pouvez également utiliser gitk (gui) ou tig (text-ui) pour donner des façons beaucoup plus lisibles par l'homme de le voir.

gitk --follow --all -p dir/file.c

tig --follow --all -p dir/file.c

Sous debian / ubuntu, la commande d'installation de ces jolis outils est comme prévu:

sudo apt-get install gitk tig

Et j'utilise actuellement:

alias gdf='gitk --follow --all -p'

afin que je puisse simplement taper gdf dirpour obtenir une histoire ciblée de tout dans le sous-répertoire dir.

Ajoutez cet alias à votre .gitconfig:

[alias]
    lg = log --all --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'\n--abbrev-commit --date=relative

Et utilisez la commande comme ceci:

> git lg
> git lg -- filename

La sortie sera presque exactement la même que la sortie gitk. Prendre plaisir.

Dernièrement, j'ai découvert tig et trouvé cela très utile. Il y a des cas où je souhaiterais qu'il fasse A ou B mais la plupart du temps c'est plutôt soigné.

Pour votre cas, c'est tig <filename>peut-être ce que vous recherchez.

http://jonas.nitro.dk/tig/

Vous pouvez utiliser vscode avec GitLens , c'est un outil très puissant. Après avoir installé GitLens, allez dans l'onglet GitLens, sélectionnez FILE HISTORYet vous pouvez le parcourir.

J'ai écrit git-playback dans ce but précis

pip install git-playback
git playback [filename]

Cela a l'avantage d'afficher les résultats dans la ligne de commande (comme git log -p) tout en vous permettant de parcourir chaque validation à l'aide des touches fléchées (comme gitk).

Ou:

gitx -- <path/to/filename>

si vous utilisez gitx

Vous pouvez également essayer ceci qui répertorie les validations qui ont modifié une partie spécifique d'un fichier (implémenté dans Git 1.8.4).

Le résultat renvoyé serait la liste des validations qui ont modifié cette partie particulière. Commande:

git log --pretty=short -u -L <upperLimit>,<lowerLimit>:<path_to_filename>

où upperLimit est le start_line_number et lowerLimit est le end_line_number du fichier.

Plus de détails sur https://www.techpurohit.com/list-some-useful-git-commands

Si vous souhaitez voir l'historique complet d'un fichier, y compris sur toutes les autres branches, utilisez:

gitk --all <filename>

Avec les excellentes extensions Git , vous allez à un point de l'historique où le fichier existait toujours (s'il a été supprimé, sinon allez simplement à HEAD), passez à l' File treeonglet, faites un clic droit sur le fichier et choisissez File history.

Par défaut, il suit le fichier à travers les renommages, et l' Blameonglet permet de voir le nom à une révision donnée.

Il a quelques problèmes mineurs, comme apparaître fatal: Not a valid object namedans l' Viewonglet lorsque vous cliquez sur la révision de suppression, mais je peux vivre avec ça. :-)

Si vous utilisez l'interface graphique git (sous Windows) dans le menu Référentiel, vous pouvez utiliser "Visualiser l'historique du maître". Mettez en surbrillance un commit dans le volet supérieur et un fichier en bas à droite et vous verrez le diff pour ce commit en bas à gauche.

SmartGit :

1. Dans le menu, permet d'afficher les fichiers inchangés: Afficher / Afficher les fichiers inchangés
2. Faites un clic droit sur le fichier et sélectionnez «Journal» ou appuyez sur «Ctrl-L»

La réponse que je cherchais qui n'était pas dans ce fil est de voir les changements dans les fichiers que j'avais mis en scène pour la validation. c'est à dire

git diff --cached

Si vous utilisez TortoiseGit, vous devriez pouvoir faire un clic droit sur le fichier et faire TortoiseGit --> Show Log. Dans la fenêtre qui apparaît, assurez-vous:

• L' Show Whole Projectoption ' ' n'est pas cochée.

• ' All Branches' est cochée.

git diff -U <filename> vous donner un diff unifié.

Il doit être coloré en rouge et vert. Si ce n'est pas le cas, lancez: d' git config color.ui autoabord.

Si vous utilisez eclipse avec le plugin git, il a une excellente vue de comparaison avec l'historique. Faites un clic droit sur le fichier et sélectionnez "comparer avec" => "historique"

Je suis probablement sur la position de l'OP lorsque cela a commencé, à la recherche de quelque chose de simple qui me permettrait d'utiliser git difftool avec vimdiff pour examiner les modifications apportées aux fichiers de mon référentiel à partir d'un commit spécifique. Je n'étais pas trop satisfait des réponses que je trouvais, alors j'ai jeté ce script git inc remental rep orter (gitincrep) ensemble et cela m'a été utile:

#!/usr/bin/env bash

STARTWITH="${1:-}"
shift 1

DFILES=( "$@" )

RunDiff()
{
        GIT1=$1
        GIT2=$2
        shift 2

        if [ "$(git diff $GIT1 $GIT2 "$@")" ]
        then
                git log ${GIT1}..${GIT2}
                git difftool --tool=vimdiff $GIT1 $GIT2 "$@"
        fi
}

OLDVERS=""
RUNDIFF=""

for NEWVERS in $(git log --format=format:%h  --reverse)
do
        if [ "$RUNDIFF" ]
        then
                RunDiff $OLDVERS $NEWVERS "${DFILES[@]}"
        elif [ "$OLDVERS" ]
        then
                if [ "$NEWVERS" = "${STARTWITH:=${NEWVERS}}" ]
                then
                        RUNDIFF=true
                        RunDiff $OLDVERS $NEWVERS "${DFILES[@]}"
                fi
        fi
        OLDVERS=$NEWVERS
done

Appelé sans argument, cela commencera au début de l'historique du dépôt, sinon il commencera avec le hachage de validation abrégé que vous fournissez et passera au présent - vous pouvez Ctrl-C à tout moment pour quitter. Tout argument après le premier limitera les rapports de différence pour inclure uniquement les fichiers répertoriés parmi ces arguments (ce qui, je pense, est ce que l'OP voulait, et je le recommanderais pour tous les projets, sauf les plus petits). Si vous vérifiez les modifications apportées à des fichiers spécifiques et souhaitez commencer depuis le début, vous devrez fournir une chaîne vide pour arg1. Si vous n'êtes pas un utilisateur de vim, vous pouvez remplacer vimdiff par votre outil de diff préféré.

Le comportement consiste à afficher les commentaires de validation lorsque des modifications pertinentes sont trouvées et à commencer à proposer des exécutions vimdiff pour chaque fichier modifié (c'est le comportement de git difftool , mais cela fonctionne ici).

Cette approche est probablement assez naïve, mais en examinant de nombreuses solutions ici et dans un article connexe, beaucoup impliquaient l'installation de nouveaux outils sur un système où je n'ai pas d'accès administrateur, avec des interfaces qui avaient leur propre courbe d'apprentissage. Le script ci-dessus a fait ce que je voulais sans traiter de tout cela. J'examinerai les nombreuses excellentes suggestions ici lorsque j'ai besoin de quelque chose de plus sophistiqué - mais je pense que cela répond directement au PO.

J'ai trouvé une solution très simple pour retrouver rapidement l'historique du fichier.

1. Faites un changement aléatoire dans le fichier
2. Il apparaîtra comme des changements non validés sur votre arbre source
3. Faites un clic droit sur le fichier et sélectionnez 'Journal sélectionné'

Cela montrerait l'histoire de tous les commits.