Alteração de detalhes após o Git pull

Após um pull do Git, sua saída fornece um resumo do valor da alteração.

Como posso ver cada um ou alguns dos arquivos alterações detalhadas?

Ok, aqui está a minha pergunta para Jefromi:

1. Como sei se eu estava tentando dominar? Tudo o que fiz foi "git pull".

2. O que o master aponta e qual é a diferença entre master e HEAD, os dois chefes padrão do Git?

3. Como vejo a alteração detalhada em um arquivo específico?

4. Como vejo a alteração na saída do resumo pelos últimos git pullnovamente?

5. Qual a diferença entre git diffe git whatchanged?

Suponha que você esteja tentando dominar. Você pode consultar a posição anterior de masterby master@{1}(ou mesmo master@{10.minutes.ago}; consulte a seção de especificação de revisões da página do manual git-rev-parse ), para que você possa fazer coisas como

• Veja todas as alterações: git diff master@{1} master

• Veja as alterações em um determinado arquivo: git diff master@{1} master <file>

• Veja todas as alterações em um determinado diretório: git diff master@{1} master <dir>

• Consulte o resumo das alterações novamente: git diff --stat master@{1} master

Quanto à sua pergunta "como sei se estou no mestre" ... bem, o uso de branches é uma parte importante do fluxo de trabalho do Git. Você deve sempre estar ciente de qual ramo você está - se você efetuou alterações, deseja obtê-las para o ramo certo! Você pode ver uma lista de todos os ramos, com um asterisco pela atualmente check-out um, com o comando git branch. O nome da filial atual também é impresso junto com a saída de git status. Eu recomendo examinar as páginas de manual dos comandos a serem usados ​​- é uma ótima maneira de adquirir lentamente algum conhecimento.

E sua última pergunta: HEADé o nome da ramificação com check-out atualmente. Você pode realmente usar HEADe também HEAD@{1}neste contexto, mas é um pouco mais robusto usar os desvios, pois se você for verificar outro desvio. HEADagora é o segundo ramo e HEAD@{1}agora master- não é o que você deseja!

Para evitar ter que fazer muitas pequenas perguntas como essa, você provavelmente deve dar uma olhada no tutorial do Git. Há um milhão na web, por exemplo:

• O livro Pro Git
• Git Magic
• e os 4,5 milhões de acessos no Google para o "tutorial Git"

Digamos que você faça um git como este:

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

Você pode ver a diferença do que mudou usando os números de revisão:

$ git diff a407564..9f52bed

1. Como sei se estava tentando dominar? Tudo o que fiz foi "git pull".

O comando em si funciona assim:

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

e por padrão refere-se à ramificação atual. Você pode verificar suas filiais usando

git branch -a

Isso listará suas ramificações locais e remotas, como por exemplo (Adicionado um --- divisor entre local e remoto para tornar mais claro)

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

Quando você examinar um repositório remoto, verá a que se refere:

git remote show origin

listará da seguinte maneira:

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

Portanto, é muito fácil ter certeza de onde puxar e pressionar.

3. como ver os detalhes mudarem em um arquivo específico?

4. como ver a mudança na saída do resumo pelo último git pull novamente?

A maneira mais fácil e elegante (imo) é:

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

Isso fornecerá dois blocos de informações sobre as alterações entre sua última solicitação e o estado atual do trabalho. Exemplo de saída (eu adicionei um --- divisor entre --state --dirstatsaída para torná-lo mais 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/

Dessa forma, é meio hacky, mas permite que você use ferramentas gráficas como gitkou gitgou git-gui:

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

A resposta com a maioria dos votos positivos fornece a melhor maneira de usar a ferramenta git, mas eu uso esse método porque posso utilizar ferramentas com a GUI para ver as alterações: P

Eu teria então a etapa extra de fazer uma git checkout .e, em seguida, git pullnovamente, para poder puxar e mesclar adequadamente, mas valorizo ​​a capacidade de examinar as diferenças em uma GUI o suficiente para lidar com as duas etapas extras.