Cambio de detalle después de Git pull

Después de una extracción de Git, su salida ofrece un resumen sobre la cantidad de cambio.

¿Cómo puedo ver los cambios detallados de cada uno de los archivos?

Bien, aquí está mi pregunta a Jefromi:

1. ¿Cómo sé si estaba tirando para dominar? Todo lo que hice fue "git pull".

2. ¿Qué señala master y cuál es la diferencia entre master y HEAD, los dos jefes predeterminados de Git?

3. ¿Cómo veo el cambio detallado en un archivo específico?

4. ¿Cómo veo de nuevo el cambio en la salida de resumen por última git pullvez?

5. ¿Cuál es la diferencia entre git diffy git whatchanged?

Supongamos que estás tirando para dominar. Puede consultar la posición anterior de masterby master@{1}(o incluso master@{10.minutes.ago}; consulte la sección de revisión de especificaciones de la página de manual de git-rev-parse ), para que pueda hacer cosas como

• Ver todos los cambios: git diff master@{1} master

• Vea los cambios en un archivo dado: git diff master@{1} master <file>

• Ver todos los cambios dentro de un directorio dado: git diff master@{1} master <dir>

• Vea el resumen de cambios nuevamente: git diff --stat master@{1} master

En cuanto a su pregunta de "cómo sé si estoy en master" ... bueno, el uso de ramas es una parte importante del flujo de trabajo de Git. Siempre debe saber en qué rama se encuentra: si extrajo los cambios, ¡querrá llevarlos a la rama correcta! Puede ver una lista de todas las ramas, con un asterisco junto al que está actualmente desprotegido, con el comando git branch. El nombre de la rama actual también se imprime junto con la salida de git status. Le recomiendo hojear las páginas del manual de comandos para usar: es una excelente manera de aprender poco a poco.

Y su última pregunta: HEADes el nombre de la rama actualmente desprotegida. De hecho, puede usar HEADy también HEAD@{1}en este contexto, pero es un poco más robusto usar las ramas, ya que si va y echa un vistazo a otra rama. HEADahora es esa segunda rama, y HEAD@{1}es ahora master, ¡no lo que quieres!

Para evitar tener que hacer muchas preguntas pequeñas como esta, probablemente deberías echar un vistazo a un tutorial de Git. Hay un millón en la web, por ejemplo:

• El libro Pro Git
• Git Magic
• y los 4.5 millones de visitas en Google para el "tutorial de Git"

Digamos que haces un git pull así:

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

Puede ver la diferencia de lo que cambió usando los números de revisión:

$ git diff a407564..9f52bed

1. ¿Cómo sé si estaba tirando para dominar? Todo lo que hice fue "git pull".

El comando en sí funciona así:

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

y por defecto se refiere a la rama actual. Puede verificar sus sucursales usando

git branch -a

Esto mostrará una lista de sus sucursales locales y remotas, por ejemplo, por ejemplo (se agregó un --- divisor entre local y remoto para que quede más claro)

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

Cuando eche un vistazo a un repositorio remoto, verá a qué se refiere:

git remote show origin

enumerará como el siguiente:

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

Por lo tanto, es bastante fácil asegurarse de dónde tirar y empujar.

3. ¿Cómo ver el cambio de detalles en un archivo específico?

4. ¿Cómo ver el cambio en la salida de resumen por último git pull nuevamente?

La forma más fácil y elegante (imo) es:

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

Esto le dará dos bloques de información sobre los cambios entre su último tirón y el estado actual del trabajo. Ejemplo de salida (agregué un --- como divisor entre --staty --dirstatsalida para que quede más claro):

 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/

Esta forma es un poco hacky, pero te permitirá usar herramientas gráficas como gitko gitgo git-gui:

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

La respuesta con la mayoría de los votos positivos ofrece la mejor manera de usar la herramienta git, pero uso este método porque puedo utilizar herramientas con GUI para ver los cambios: P

Luego tendría el paso adicional de hacer un git checkout .y luego git pullvolver a hacerlo para poder extraer y fusionar correctamente, pero valoro la capacidad de examinar las diferencias en una GUI lo suficiente como para lidiar con los dos pasos adicionales.