Quando eu preciso fazer “git pull”, antes ou depois de “git add, git commit”?

97

Qual é o caminho certo?

git add foo.js
git commit foo.js -m "commit"
git pull
git push

Ou

git pull
git add foo.js
git commit foo.js -m "commit"
git push

Ou

git add foo.js
git pull
git commit foo.js -m "commit"
git push

UPD:

Esqueci de mencionar que, neste caso, git addcostumo preparar um arquivo rastreado e modificado . Não incluir um novo arquivo no repositório. Isso muda a ordem dos comandos?

git Verde
fonte
Pergunta relacionada: stackoverflow.com/questions/813822/…
leo9r

Respostas:

101

Acho que a melhor maneira de fazer isso é:

Esconda suas mudanças locais:

git stash

Atualize a filial com o código mais recente

git pull

Combine suas alterações locais no código mais recente:

git stash apply

Adicione, confirme e envie suas alterações

git add
git commit
git push

Na minha experiência, este é o caminho para a menor resistência com Git (na linha de comando, pelo menos).

johnjo
fonte
4
Você pode explicar por que isso é melhor? Que problemas isso evita? Em particular, por que isso é melhor do que um simples commit> pull> push? (Acho que esta poderia ser a melhor resposta, mas não tenho informações suficientes agora para sequer ser considerada uma boa resposta.)
dallin
8
Talvez isso fosse muito anedótico, mas sempre achei essa abordagem (na linha de comando, em vez de em algo como a árvore de origem) muito mais fácil. Fazer um commit e, em seguida, puxar, enquanto trabalha em uma grande equipe, sempre leva a grandes conflitos de mesclagem, pois o git não era muito bom em mesclar minhas alterações em um arquivo com o de entrada. Com o stashing, ele me permitiu extrair as novas alterações e usar o código atualizado como base para adicionar minhas alterações. Lidar com os conflitos era mais fácil porque eles eram mais claros para mim (já que minhas mudanças agora eram os conflitos). Em retrospectiva, talvez fosse apenas mais fácil para a minha situação.
johnjo
1
Portanto, parece algo do tipo "Como você come um elefante? Uma mordida de cada vez". ou seja, dividir o processo em mais algumas etapas para simplificar as fusões e ter menos alterações e, possivelmente, mais claras. Faz sentido.
dallin
O git add é necessário aqui? Se todos os arquivos já foram adicionados ao teste!
Sharp Edge
E se você não estiver usando git stash?
Aaron Franke
77

puxar = buscar + mesclar.

Você precisa confirmar o que fez antes de mesclar.

Então, puxe após o commit.

Arnaud Denoyelle
fonte
8
Isso significa que você acaba fazendo um commit extra para cada commit que você faz e torna o repo negligente? Além disso, sua mensagem de confirmação inicial termina seguida por um comentário de mesclagem a cada vez. Nesse caso, estaria inclinado a usar o método de armazenamento mencionado abaixo por @johnjo.
Segunda-
3
@DanielM Sim, há um commit extra para a fusão (com uma mensagem de commit padrão explícita). Isso é uma coisa muito boa, porque permite que você verifique seu último commit ou o último commit de seu colega ou o commit de mesclagem. Se você quiser evitá-lo e colocar seus commits após os commits de seus colegas, você pode ao rebaseinvés de merge. Você pode fazer isso com git commit && git rebaseou git pull --rebase.
Arnaud Denoyelle de
Obrigado pela dica, @Arnaud. Depois de ler muitas perguntas diferentes do SO, este comentário chegou. Minha opção preferida quando os colegas estão trabalhando em arquivos diferentes é git pulldepois de preparar minhas alterações, pois acho isso mais natural. Embora eu saiba que muitos fluxos de trabalho diferentes funcionam (esconderijo também é bom), então é provavelmente uma questão de gosto.
sobrinho de
52

Eu sugiro puxar do branch remoto sempre que possível para minimizar grandes fusões e possíveis conflitos.

Dito isso, eu escolheria a primeira opção:

git add foo.js
git commit foo.js -m "commit"
git pull
git push

Faça commit de suas mudanças antes de puxar para que seus commits sejam mesclados com as mudanças remotas durante o pull. Isso pode resultar em conflitos com os quais você pode começar a lidar sabendo que seu código já foi confirmado caso algo dê errado e você tenha que abortar a fusão por qualquer motivo.

Tenho certeza que alguém vai discordar de mim, não acho que haja uma maneira correta de fazer esse fluxo de mesclagem, apenas o que funciona melhor para as pessoas.

Jasarien
fonte
1
Você poderia ver minha atualização para a pergunta? Esqueci de explicar para que git addserve exatamente no meu exemplo.
Verde
1
Não deve fazer nenhuma diferença se era um novo arquivo ou um arquivo rastreado / modificado. Ainda se compromete e depois puxa.
Jasarien
7

eu acho que git pull --rebase é a maneira mais limpa de definir seus commits recentes localmente além dos commits remotos que você não tem em um certo ponto.

Assim, você não precisa puxar toda vez que quiser começar a fazer alterações.

Mohyaddin Alaoddin
fonte
Isso é o que eu também faço, mas apenas para apontar que existem definitivamente duas escolas principais de pensamento sobre isso (centradas em saber se é melhor corrigir conflitos entre commits individuais ou uma vez no commit de fusão) com o próprio Linus no campo de fusão . Felizmente, a ferramenta em si não é opinativa, então use-a da maneira que funcionar melhor para você e para as necessidades do seu projeto :-)
Luke Usherwood
3

Você deseja que sua mudança assente no estado atual do branch remoto. Então, provavelmente você quer puxar bem antes de se comprometer. Depois disso, envie suas alterações novamente.

Arquivos locais "sujos" não são um problema, desde que não haja conflitos com o branch remoto. Se houver conflitos, a fusão falhará, portanto, não há risco ou perigo em puxar antes de comprometer as alterações locais.

AlexE
fonte
1
Não funciona, como Arnaud mencionou, o pull requer que você confirme suas alterações primeiro.
Jasarien
Meu git parece feliz em fazer várias mudanças locais. Obviamente, se os mesmos arquivos forem alterados no branch remoto, a parte de mesclagem do pull falhará. Para criar um conflito de mesclagem adequado, eu teria que confirmar primeiro, com certeza. Portanto, se o conjunto de arquivos alterados local e remotamente for desmembrado, puxar e enviar está bem. Caso contrário, o git não puxará. Nenhum dano pode ser causado ao tentar.
AlexE
Essa é minha opção preferida quando as pessoas estão trabalhando em arquivos diferentes, e acho que é a mais natural.
sobrinho de
0

A melhor maneira para mim é:

  1. criar um novo branch, check-out para ele
  2. criar ou modificar arquivos, git add, git commit
  3. de volta ao branch master e extraia remotamente (para obter as últimas alterações do master)
  4. fundir o ramo recém-criado com o mestre
  5. remover ramo recém-criado
  6. empurre mestre para remoto

Ou você pode empurrar o branch recém-criado no remoto e mesclar lá (se você fizer isso desta forma, no final você precisa puxar do master remoto)

Jane Tasevski
fonte