Ver el historial de cambios de un archivo usando versiones de Git

¿Cómo puedo ver el historial de cambios de un archivo individual en Git, detalles completos con lo que ha cambiado?

He llegado tan lejos como:

git log -- [filename]

que me muestra el historial de confirmación del archivo, pero ¿cómo obtengo el contenido de cada uno de los cambios del archivo?

Estoy tratando de hacer la transición desde MS SourceSafe y eso solía ser un simple right-click→ show history.

Para esto usaría:

gitk [filename]

o para seguir el nombre del archivo renombrados anteriores

gitk --follow [filename]

Puedes usar

git log -p filename

para permitir que git genere los parches para cada entrada de registro.

Ver

git help log

para obtener más opciones, en realidad puede hacer muchas cosas buenas :) Para obtener solo la diferencia para un compromiso específico, puede

git show HEAD 

o cualquier otra revisión por identificador. O usar

gitk

para navegar los cambios visualmente.

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

Esto mostrará el historial completo del archivo (incluido el historial más allá de los cambios de nombre y con diferencias para cada cambio).

En otras palabras, si el archivo nombrado baralguna vez fue nombrado foo, entonces git log -p bar(sin la --followopción) solo mostrará el historial del archivo hasta el punto en el que fue renombrado; no mostrará el historial del archivo cuando se conocía como foo. El uso git log --follow -p barmostrará el historial completo del archivo, incluidos los cambios en el archivo cuando se conocía como foo. La -popción garantiza que se incluyan diferencias para cada cambio.

Si prefiere permanecer basado en texto, puede usar tig .

Instalación rápida:

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

Úselo para ver el historial en un solo archivo: tig [filename]
O explore el historial detallado de repositorios:tig

Similar a gitkpero basado en texto. Soporta colores en terminal!

git whatchanged -p filenameTambién es equivalente a git log -p filenameen este caso.

También puede ver cuándo se cambió una línea de código específica dentro de un archivo git blame filename. Esto imprimirá un ID de confirmación breve, el autor, la marca de tiempo y la línea de código completa para cada línea del archivo. Esto es muy útil después de que hayas encontrado un error y quieras saber cuándo se introdujo (o quién tiene la culpa).

Usuarios de SourceTree

Si usa SourceTree para visualizar su repositorio (es gratis y bastante bueno) puede hacer clic derecho en un archivo y seleccionar Log Selected

La pantalla (a continuación) es mucho más amigable que gitk y la mayoría de las otras opciones enumeradas. Desafortunadamente (en este momento) no hay una manera fácil de iniciar esta vista desde la línea de comandos: la CLI de SourceTree actualmente solo abre repositorios.

Para mostrar qué revisión y autor modificaron por última vez cada línea de un archivo:

git blame filename

o si quieres usar la poderosa GUI de culpa:

git gui blame filename

Resumen de otras respuestas después de leerlas y jugar un poco:

El comando de línea de comando habitual sería

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

Pero también puede usar gitk (gui) o tig (text-ui) para obtener formas mucho más legibles para los humanos de verlo.

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

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

En debian / ubuntu, el comando de instalación para estas herramientas encantadoras es el esperado:

sudo apt-get install gitk tig

Y actualmente estoy usando:

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

para que pueda escribir gdf dirpara obtener un historial enfocado de todo en el subdirectorio dir.

Agregue este alias a su .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

Y usa el comando así:

> git lg
> git lg -- filename

La salida se verá casi exactamente igual a la salida de gitk. Disfrutar.

Últimamente descubrí tig y lo encontré muy útil. Hay algunos casos que desearía que hiciera A o B, pero la mayoría de las veces es bastante ordenado.

Para su caso, tig <filename>podría ser lo que está buscando.

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

Puedes usar vscode con GitLens , es una herramienta muy poderosa. Después de instalar GitLens, vaya a la pestaña GitLens, seleccione FILE HISTORYy podrá explorarlo.

Escribí git-play para este propósito exacto

pip install git-playback
git playback [filename]

Esto tiene la ventaja de que ambos muestran los resultados en la línea de comando (me gusta git log -p) y al mismo tiempo le permiten recorrer cada confirmación utilizando las teclas de flecha (me gusta gitk).

O:

gitx -- <path/to/filename>

si estás usando gitx

También puede probar esto, que enumera las confirmaciones que han cambiado una parte específica de un archivo (Implementado en Git 1.8.4).

El resultado devuelto sería la lista de confirmaciones que modificaron esta parte en particular. Comando:

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

donde upperLimit es el número_línea_inicial y el Límite inferior es el número_línea_final del archivo.

Más detalles en https://www.techpurohit.com/list-some-useful-git-commands

Si desea ver el historial completo de un archivo, incluso en todas las demás ramas, use:

gitk --all <filename>

Con las excelentes extensiones de Git , vas a un punto en el historial donde el archivo todavía existía (si se ha eliminado, de lo contrario solo ve a HEAD), cambia a la File treepestaña, haz clic derecho en el archivo y elige File history.

Por defecto, sigue el archivo a través de los cambios de nombre, y la Blamepestaña permite ver el nombre en una revisión dada.

Tiene algunos problemas menores, como mostrar fatal: Not a valid object nameen la Viewpestaña al hacer clic en la revisión de eliminación, pero puedo vivir con eso. :-)

Si está utilizando la GUI de git (en Windows) en el menú Repositorio, puede usar "Visualizar el historial del maestro". Resalte una confirmación en el panel superior y un archivo en la esquina inferior derecha y verá la diferencia de esa confirmación en la esquina inferior izquierda.

SmartGit :

1. En el menú, habilite mostrar archivos sin cambios: Ver / Mostrar archivos sin cambios
2. Haga clic derecho en el archivo y seleccione 'Log' o presione 'Ctrl-L'

La respuesta que estaba buscando que no estaba en este hilo es ver cambios en los archivos que había preparado para confirmar. es decir

git diff --cached

Si usa TortoiseGit, debería poder hacer clic derecho en el archivo y hacerlo TortoiseGit --> Show Log. En la ventana que aparece, asegúrese de:

• ' Show Whole Project' la opción no está marcada.

• ' All Branches' la opción está marcada.

git diff -U <filename> darte una diferencia unificada.

Debe ser de color rojo y verde. Si no es así, ejecute: git config color.ui autoprimero.

Si está utilizando eclipse con el complemento git, tiene una excelente vista de comparación con el historial. Haga clic derecho en el archivo y seleccione "comparar con" => "historial"

Probablemente esté sobre dónde estaba el OP cuando esto comenzó, buscando algo simple que me permitiera usar git difftool con vimdiff para revisar los cambios en los archivos en mi repositorio a partir de una confirmación específica. No estaba muy contento con las respuestas que estaba encontrando, así que elaboré este script de git inc remental rep orter (gitincrep) y me ha sido útil:

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

Llamado sin argumentos, esto comenzará desde el comienzo del historial de repositorios, de lo contrario comenzará con cualquier hash abreviado de confirmación que proporcione y proceda al presente: puede presionar Ctrl-C en cualquier momento para salir. Cualquier argumento después del primero limitará los informes de diferencias para incluir solo los archivos enumerados entre esos argumentos (lo que creo que es lo que quería el OP, y lo recomendaría para todos menos los proyectos pequeños). Si está verificando cambios en archivos específicos y desea comenzar desde el principio, deberá proporcionar una cadena vacía para arg1. Si no eres un usuario de vim, puedes reemplazar vimdiff con tu herramienta de diferencias favorita.

El comportamiento es generar los comentarios de confirmación cuando se encuentran cambios relevantes y comenzar a ofrecer ejecuciones de vimdiff para cada archivo modificado (ese es el comportamiento de git difftool , pero funciona aquí).

Este enfoque es probablemente bastante ingenuo, pero al examinar muchas de las soluciones aquí y en una publicación relacionada, muchas implicaron instalar nuevas herramientas en un sistema donde no tengo acceso de administrador, con interfaces que tenían su propia curva de aprendizaje. El script anterior hizo lo que quería sin tener que lidiar con nada de eso. Examinaré las muchas sugerencias excelentes aquí cuando necesite algo más sofisticado, pero creo que esto responde directamente al OP.

He encontrado una solución muy simple para encontrar rápidamente el historial del archivo.

1. Hacer un cambio aleatorio en el archivo
2. Se mostrará como cambios no confirmados en su árbol de origen
3. Haga clic derecho en el archivo y seleccione 'Log Selected'

Mostraría la historia de todos los commits.