Exibir o histórico de alterações de um arquivo usando a versão do Git

Como posso visualizar o histórico de alterações de um arquivo individual no Git, detalhes completos com o que mudou?

Eu cheguei até:

git log -- [filename]

que me mostra o histórico de consolidação do arquivo, mas como faço para obter o conteúdo de cada uma das alterações no arquivo?

Estou tentando fazer a transição do MS SourceSafe e isso costumava ser um simples right-click→ show history.

Para isso, eu usaria:

gitk [filename]

ou para seguir o nome do arquivo e renomear

gitk --follow [filename]

Você pode usar

git log -p filename

para permitir que o git gere os patches para cada entrada de log.

Vejo

git help log

para mais opções - ele pode realmente fazer muitas coisas legais :) Para obter apenas o diff de um commit específico, você pode

git show HEAD 

ou qualquer outra revisão por identificador. Ou use

gitk

para procurar as alterações visualmente.

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

Isso mostrará todo o histórico do arquivo (incluindo o histórico além de renomear e com diffs para cada alteração).

Em outras palavras, se o arquivo nomeado barjá tiver sido nomeado foo, git log -p bar(sem a --followopção) mostrará apenas o histórico do arquivo até o ponto em que foi renomeado - ele não mostrará o histórico do arquivo quando conhecido como foo. O uso git log --follow -p barexibirá o histórico inteiro do arquivo, incluindo quaisquer alterações no arquivo quando ele era conhecido como foo. A -popção garante que as diferenças sejam incluídas para cada alteração.

Se você preferir ficar com base em texto, convém usar o tig .

Instalação rápida:

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

Use-o para visualizar o histórico em um único arquivo: tig [filename]
ou procure o histórico detalhado de repositórios:tig

Semelhante ao gitkmas baseado em texto. Suporta cores no terminal!

git whatchanged -p filenametambém é equivalente a git log -p filenameneste caso.

Você também pode ver quando uma linha de código específica dentro de um arquivo foi alterada git blame filename. Isso imprimirá um ID de confirmação curto, o autor, o carimbo de data e hora e a linha de código completa para todas as linhas do arquivo. Isso é muito útil depois que você encontra um bug e deseja saber quando ele foi introduzido (ou quem foi a culpa).

Usuários do SourceTree

Se você usar o SourceTree para visualizar seu repositório (é gratuito e bastante bom), clique com o botão direito do mouse em um arquivo e selecione Log Selecionado

A exibição (abaixo) é muito mais amigável que o gitk e a maioria das outras opções listadas. Infelizmente (no momento) não há uma maneira fácil de iniciar essa exibição na linha de comando - a CLI do SourceTree atualmente apenas abre repositórios.

Para mostrar qual revisão e autor modificou pela última vez cada linha de um arquivo:

git blame filename

ou se você quiser usar a poderosa GUI de culpa:

git gui blame filename

Resumo de outras respostas depois de ler e tocar um pouco:

O comando de linha de comando usual seria

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

Mas você também pode usar o gitk (gui) ou o tig (text-ui) para fornecer maneiras muito mais legíveis para o ser humano.

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

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

Sob debian / ubuntu, o comando de instalação para essas ferramentas encantadoras é o esperado:

sudo apt-get install gitk tig

E atualmente estou usando:

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

para que eu possa digitar gdf dirpara obter um histórico focado de tudo no subdiretório dir.

Adicione este alias ao seu .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 use o comando como este:

> git lg
> git lg -- filename

A saída será quase exatamente igual à saída do gitk. Aproveitar.

Ultimamente eu descobri tig e achei muito útil. Há alguns casos em que eu gostaria que fosse A ou B, mas na maioria das vezes é bem legal.

Para o seu caso, tig <filename>pode ser o que você está procurando.

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

Você pode usar o vscode com o GitLens , é uma ferramenta muito poderosa. Após instalar o GitLens, vá para a guia GitLens, selecione FILE HISTORYe você pode navegar por ele.

Eu escrevi git-playback para esse propósito exato

pip install git-playback
git playback [filename]

Isso tem o benefício de exibir os resultados na linha de comando (como git log -p) e também permitir que você percorra cada confirmação usando as teclas de seta (como gitk).

Ou:

gitx -- <path/to/filename>

se você estiver usando gitx

Você também pode tentar isso, listando os commits que alteraram uma parte específica de um arquivo (implementado no Git 1.8.4).

O resultado retornado seria a lista de confirmações que modificaram esta parte específica. Comando:

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

em que upperLimit é o número_de_instrução e lowerLimit é o número de linha de término do arquivo.

Mais detalhes em https://www.techpurohit.com/list-some-useful-git-commands

Se você quiser ver todo o histórico de um arquivo, inclusive em todas as outras ramificações, use:

gitk --all <filename>

Com as excelentes Git Extensions , você chega a um ponto no histórico em que o arquivo ainda existia (se tiver sido excluído, caso contrário, vá para HEAD), alterne para a File treeguia, clique com o botão direito do mouse no arquivo e escolha File history.

Por padrão, ele segue o arquivo através das renomeações e a Blameguia permite ver o nome em uma determinada revisão.

Ele tem algumas dicas menores, como aparecer fatal: Not a valid object namena Viewguia ao clicar na revisão de exclusão, mas eu posso conviver com isso. :-)

Se você estiver usando a GUI do git (no Windows) no menu Repositório, poderá usar "Visualizar histórico do mestre". Destaque uma confirmação no painel superior e um arquivo no canto inferior direito e você verá o diff dessa confirmação no canto inferior esquerdo.

SmartGit :

1. No menu, habilite para exibir arquivos inalterados: Exibir / Mostrar arquivos inalterados
2. Clique com o botão direito do mouse no arquivo e selecione 'Log' ou pressione 'Ctrl-L'

A resposta que eu estava procurando e que não estava nesse segmento é ver as alterações nos arquivos que eu havia preparado para confirmar. ie

git diff --cached

Se você usa o TortoiseGit, poderá clicar com o botão direito do mouse no arquivo e fazer TortoiseGit --> Show Log. Na janela exibida, verifique se:

• Show Whole Projectopção ' ' não está marcada.

• All Branchesopção ' ' está marcada.

git diff -U <filename> dar-lhe um diff unificado.

Deve ser colorido em vermelho e verde. Caso contrário, execute: git config color.ui autoprimeiro.

Se você estiver usando o eclipse com o plug-in git, ele possui uma excelente visualização de comparação com o histórico. Clique com o botão direito do mouse no arquivo e selecione "comparar com" => "histórico"

Provavelmente, eu sou sobre onde o OP estava quando isso começou, procurando algo simples que me permita usar o git difftool com o vimdiff para revisar as alterações nos arquivos no meu repositório a partir de um commit específico. Eu não estava muito feliz com as respostas que estava encontrando, então juntei esse script git inc remental rep orter (gitincrep) juntos e isso tem sido útil para mim:

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

Chamado sem argumentos, isso começará no início do histórico do repositório, caso contrário, começará com o hash de confirmação abreviado que você fornecer e prosseguirá para o presente - você pode pressionar Ctrl-C a qualquer momento para sair. Qualquer argumento após o primeiro limitará os relatórios de diferença para incluir apenas os arquivos listados entre eles (que eu acho que é o que o OP queria, e eu recomendaria para todos os projetos, exceto pequenos). Se você estiver verificando alterações em arquivos específicos e quiser começar desde o início, precisará fornecer uma sequência vazia para arg1. Se você não é um usuário do vim, pode substituir o vimdiff por sua ferramenta de diff favorita.

O comportamento é gerar os comentários de confirmação quando alterações relevantes são encontradas e começar a oferecer execuções vimdiff para cada arquivo alterado (esse é o comportamento do git difftool , mas funciona aqui).

Essa abordagem provavelmente é bastante ingênua, mas, analisando muitas das soluções aqui e em um post relacionado, muitas envolveram a instalação de novas ferramentas em um sistema onde eu não tenho acesso de administrador, com interfaces que tinham sua própria curva de aprendizado. O script acima fez o que eu queria sem lidar com nada disso. Analisarei as muitas sugestões excelentes aqui quando precisar de algo mais sofisticado - mas acho que isso responde diretamente ao OP.

Eu encontrei uma solução muito simples para encontrar rapidamente o histórico do arquivo.

1. Faça uma alteração aleatória no arquivo
2. Aparecerá como alterações não confirmadas no seu sourcetree
3. Clique com o botão direito do mouse no arquivo e selecione 'Log Selected'

Isso mostraria a história de todos os commits.