Visualizza la cronologia delle modifiche di un file utilizzando il controllo delle versioni di Git

Come posso visualizzare la cronologia delle modifiche di un singolo file in Git, i dettagli completi con ciò che è cambiato?

Sono arrivato a:

git log -- [filename]

che mi mostra la cronologia di commit del file, ma come posso accedere al contenuto di ciascuna delle modifiche al file?

Sto cercando di fare il passaggio da MS SourceSafe e quello era un semplice right-click→ show history.

Per questo vorrei usare:

gitk [filename]

o per seguire i nomi precedenti del nome file

gitk --follow [filename]

Puoi usare

git log -p filename

per consentire a git di generare le patch per ciascuna voce del registro.

Vedere

git help log

per più opzioni - può effettivamente fare molte cose carine :) Per ottenere solo il diff per un impegno specifico che puoi

git show HEAD 

o qualsiasi altra revisione per identificatore. Oppure usa

gitk

per esaminare visivamente le modifiche.

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

Questo mostrerà l' intero cronologia del file (inclusa la cronologia oltre i nomi e le differenze per ogni modifica).

In altre parole, se il nome del file è barstato chiamato una volta foo, allora git log -p bar(senza l' --followopzione) mostrerà la cronologia del file solo fino al punto in cui è stato rinominato - non mostrerà la cronologia del file quando era conosciuto come foo. L'utilizzo git log --follow -p barmostrerà l'intera cronologia del file, comprese eventuali modifiche al file quando era noto come foo. L' -popzione garantisce che le differenze siano incluse per ogni modifica.

Se preferisci rimanere basato sul testo, potresti voler usare tig .

Installazione rapida:

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

Usalo per visualizzare la cronologia su un singolo file: tig [filename]
oppure sfoglia la cronologia dettagliata dei repository:tig

Simile a gitkma basato sul testo. Supporta i colori nel terminale!

git whatchanged -p filename è anche equivalente a git log -p filename in questo caso.

Puoi anche vedere quando è stata modificata una specifica riga di codice all'interno di un file git blame filename. Questo stamperà un breve ID di commit, l'autore, il timestamp e la riga di codice completa per ogni riga del file. Questo è molto utile dopo che hai trovato un bug e vuoi sapere quando è stato introdotto (o chi è il difetto).

Utenti SourceTree

Se usi SourceTree per visualizzare il tuo repository (è gratuito e abbastanza buono) puoi fare clic con il tasto destro su un file e selezionare Log Selected

Il display (sotto) è molto più amichevole di gitk e della maggior parte delle altre opzioni elencate. Sfortunatamente (in questo momento) non esiste un modo semplice per avviare questa vista dalla riga di comando: la CLI di SourceTree attualmente apre solo repository.

Per mostrare quale revisione e autore hanno modificato l'ultima riga di ogni riga di un file:

git blame filename

o se si desidera utilizzare la potente GUI della colpa:

git gui blame filename

Riepilogo di altre risposte dopo averle leggere e aver giocato un po ':

Il solito comando da riga di comando sarebbe

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

Ma puoi anche usare gitk (gui) o tig (text-ui) per dare modi molto più leggibili dall'uomo di guardarlo.

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

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

Sotto debian / ubuntu, il comando di installazione per questi adorabili strumenti è come previsto:

sudo apt-get install gitk tig

E attualmente sto usando:

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

così posso solo digitare gdf dirper ottenere una cronologia focalizzata di tutto nella sottodirectory dir.

Aggiungi questo alias al tuo .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

E usa il comando in questo modo:

> git lg
> git lg -- filename

L'output avrà lo stesso aspetto dell'output gitk. Godere.

Ultimamente ho scoperto tig e l' trovato molto utile. Ci sono alcuni casi in cui vorrei che fosse A o B, ma il più delle volte è piuttosto pulito.

Per il tuo caso, tig <filename>potrebbe essere quello che stai cercando.

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

Puoi usare vscode con GitLens , è uno strumento molto potente. Dopo aver installato GitLens, vai alla scheda GitLens, seleziona FILE HISTORYe puoi sfogliarlo.

Ho scritto git-playback per questo preciso scopo

pip install git-playback
git playback [filename]

Questo ha il vantaggio sia di visualizzare i risultati nella riga di comando (come git log -p) sia di passare attraverso ciascun commit usando i tasti freccia (come gitk).

O:

gitx -- <path/to/filename>

se stai usando gitx

Puoi anche provare questo che elenca i commit che hanno cambiato una parte specifica di un file (Implementato in Git 1.8.4).

Il risultato restituito sarebbe l'elenco di commit che ha modificato questa particolare parte. Comando:

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

dove upperLimit è il start_line_number e lowerLimit è il finale_line_number del file.

Maggiori dettagli su https://www.techpurohit.com/list-some-useful-git-commands

Se vuoi vedere l'intera cronologia di un file, incluso su tutti gli altri rami usa:

gitk --all <filename>

Con le eccellenti estensioni di Git , vai a un punto della cronologia in cui il file esisteva ancora (se è stato eliminato, altrimenti vai a HEAD), passa alla File treescheda, fai clic con il pulsante destro del mouse sul file e scegli File history.

Per impostazione predefinita, segue il file attraverso i nomi e la Blamescheda consente di vedere il nome in una data revisione.

Ha alcuni gotcha minori, come mostrare fatal: Not a valid object namenella Viewscheda quando si fa clic sulla revisione della cancellazione, ma posso conviverci. :-)

Se stai usando la GUI di Git (su Windows) nel menu Repository puoi usare "Visualizza la cronologia del master". Evidenzia un commit nel riquadro in alto e un file in basso a destra e vedrai il diff per quel commit in basso a sinistra.

SmartGit :

1. Nel menu abilita la visualizzazione di file invariati: Visualizza / Mostra file invariati
2. Fare clic con il tasto destro del mouse sul file e selezionare "Registro" o premere "Ctrl-L"

La risposta che stavo cercando che non era in questo thread è vedere i cambiamenti nei file che avevo messo in scena per il commit. vale a dire

git diff --cached

Se usi TortoiseGit dovresti essere in grado di fare clic con il tasto destro del mouse sul file e farlo TortoiseGit --> Show Log. Nella finestra che si apre, assicurati di:

• ' Show Whole Project' opzione non selezionata.

• ' All Branches' opzione è selezionata.

git diff -U <filename> darti un diff unificato.

Dovrebbe essere colorato in rosso e verde. In caso contrario, eseguire: git config color.ui autoprima.

Se stai usando eclipse con il plugin git, ha un'eccellente vista di confronto con la cronologia. Fai clic con il pulsante destro del mouse sul file e seleziona "confronta con" => "cronologia"

Probabilmente sto parlando di dove si trovava l'OP quando è iniziato, cercando qualcosa di semplice che mi permettesse di usare git difftool con vimdiff per rivedere le modifiche ai file nel mio repository a partire da un commit specifico. Non ero troppo contento delle risposte che stavo trovando, quindi ho gettato insieme questo script git inc remental rep orter (gitincrep) ed è stato utile per me:

#!/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

Chiamato senza argomenti, questo inizierà dall'inizio della cronologia dei repository, altrimenti inizierà con qualsiasi hash di commit abbreviato che fornisci e procedi al presente - puoi ctrl-C in qualsiasi momento per uscire. Qualsiasi argomento dopo il primo limiterà i rapporti sulle differenze per includere solo i file elencati tra quegli argomenti (che penso sia quello che voleva l'OP, e lo consiglierei per tutti tranne che per i piccoli progetti). Se stai controllando le modifiche a file specifici e vuoi iniziare dall'inizio, dovrai fornire una stringa vuota per arg1. Se non sei un utente vim, puoi sostituire vimdiff con il tuo strumento diff preferito.

Il comportamento consiste nell'emettere i commenti di commit quando vengono rilevate modifiche rilevanti e iniziare a offrire esecuzioni vimdiff per ogni file modificato (questo è il comportamento git difftool , ma funziona qui).

Questo approccio è probabilmente piuttosto ingenuo, ma guardando molte delle soluzioni qui e in un post correlato, molti hanno coinvolto l'installazione di nuovi strumenti su un sistema in cui non ho accesso come amministratore, con interfacce che avevano la loro curva di apprendimento. La sceneggiatura sopra ha fatto quello che volevo senza occuparmene. Esaminerò qui molti eccellenti suggerimenti quando avrò bisogno di qualcosa di più sofisticato, ma penso che questo sia direttamente rispondente al PO.

Ho trovato una soluzione molto semplice per trovare rapidamente la cronologia del file.

1. Apporta una modifica casuale al file
2. Mostrerà come modifiche non confermate sul tuo sourcetree
3. Fare clic con il tasto destro sul file e selezionare 'Log Selected'

Mostrerebbe la storia di tutti gli impegni.