Git Fetch | Tutorial Online de Git W3Docs

O comando git fetch baixa commits, arquivos e referências de um repositório remoto para o seu repositório local, sem alterar nenhum dos seus próprios trabalhos. É a forma segura de ver o que seus colegas de equipe estão fazendo: nada no seu diretório de trabalho ou nos seus branches locais é alterado até você decidir fazer o merge.

Esta página aborda o que o git fetch faz, como ele atualiza os branches de rastreamento remoto, as opções mais úteis, como fazer fetch de um branch específico ou de um repositório inteiro, e como o git fetch difere do git pull.

Definição

O comando git fetch é usado para baixar commits, objetos e referências de um repositório remoto para o repositório local. Ele é utilizado para ver no que os outros membros da equipe estão trabalhando. Ao contrário do git pull, ele nunca faz o merge automático do trabalho baixado no seu branch atual.

Como funciona com branches remotos

O Git armazena os commits locais e remotos e os separa por meio do uso de referências de branch. As referências dos branches locais são armazenadas em /.git/refs/heads/. Para ver a lista de referências de branches locais, execute o comando git branch.

git branch

git branch
* master
  crossword
  solver

Ao explorar o conteúdo do diretório /.git/refs/heads/, você terá a seguinte saída:

ls ./.git/refs/heads/

ls ./.git/refs/heads/
master
crossword
solver

As referências de branches remotos são armazenadas no diretório ./.git/refs/remotes/. Para ver os branches remotos, use a flag -r com o git branch. Aqui está a saída após fazer fetch de um repositório remoto:

git branch -r

git branch -r
  origin/master
  origin/crossword
  origin/solver
  remote-repo/master
  remote-repo/other-feature

A saída mostra os branches remotos prefixados com origin/. Estes são branches de rastreamento remoto — cópias locais somente leitura que registram onde cada branch estava no remoto na última vez que você fez fetch. Você pode examiná-los com os comandos git checkout e git log. Após revisar as alterações, você pode fazer merge de um branch de rastreamento remoto no seu branch local com git merge. Use git pull para combinar fetch e merge em uma única etapa.

Opções Comuns

Opção	O que faz
`--all`	Faz fetch de todos os remotos configurados, não apenas de um.
`-k`, `--keep`	Mantém o arquivo pack baixado em vez de descompactá-lo.
`-p`, `--prune`	Remove referências de rastreamento remoto que não existem mais no remoto.
`--depth=<depth>`	Limita o número de commits obtidos a partir do topo de cada branch (um fetch superficial).
`--dry-run`	Mostra o que seria obtido sem realmente baixar nada.

Para remover referências de rastreamento de branches que não existem mais no remoto, use --prune:

git fetch --prune

Para fazer fetch de todos os remotos configurados de uma vez, use --all:

git fetch --all

Como fazer git fetch de um branch remoto

Aqui mostraremos os passos para fazer fetch de um branch remoto e atualizar o estado de trabalho local para o conteúdo remoto. No exemplo a seguir, temos um repositório central origin do qual o repositório local foi clonado com o comando git clone. Há outro repositório remoto chamado test_repo contendo feature_branch que precisa ser configurado e obtido.

O primeiro passo é configurar o repositório remoto com git remote:

git remote

git remote add test_repo git@hostname:test/test_repo.git

Usando a URL do repositório do colega, criamos uma referência para ele. Para baixar o conteúdo, faça git fetch do test feature_branch:

git fetch

git fetch test_repo feature_branch
From hostname:test/test_repo
* [new branch]      feature_branch -> test_repo/feature_branch

Isso baixa o conteúdo de test_repo/feature_branch para o seu repositório local como um branch de rastreamento remoto — ele não faz merge no seu branch atual. Agora, use o comando git checkout para inspecionar o branch remoto baixado:

git checkout test_repo/feature_branch

git checkout test_repo/feature_branch
Note: checking out 'test_repo/feature_branch'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can drop all the commits you make in this
state without influencing branches by executing another checkout.

If you want to generate a new branch for maintaining commits you create, you may
do so (now or later) if you use -b with the checkout command again. Example:

git checkout -b &lt;new-branch-name&gt;

A saída mostra que estamos no estado de HEAD desanexado, o que significa que a referência HEAD aponta diretamente para um commit em vez de um branch.

Com o comando git checkout, um novo branch local pode ser criado a partir da referência test/feature_branch:

git checkout -b local_feature_branch test_repo/feature_branch

git checkout -b local_feature_branch test_repo/feature_branch

O novo branch local é criado atualizando HEAD para apontar para o conteúdo remoto mais recente.

Sincronizando origin com git fetch

O exemplo a seguir mostra como sincronizar o repositório local com o branch master do repositório central:

git fetch origin

git fetch origin

A saída mostrará os branches que foram baixados:

git fetch origin output

b341bc3..32a45b1  master     -> origin/master
b341bc3..7a52a22  develop    -> origin/develop
* [new branch]      some-feature -> origin/some-feature

Invoque o git log usando origin/master como filtro para mostrar os commits adicionados ao master upstream:

git log --oneline master..origin/master

git log --oneline master..origin/master

Verifique as alterações e faça merge delas no branch master local:

git checkout master && git log origin/master

git checkout master
git log origin/master

Execute git merge origin/master para sincronizar com os desenvolvimentos upstream:

git merge

git merge origin/master

Um cenário comum de colaboração

Aqui está um cenário para ajudá-lo a entender melhor este conceito.

Suponha que existe uma pequena equipe de desenvolvimento composta por dois desenvolvedores, Alice e Bob. Eles estão trabalhando em um projeto hospedado em um repositório Git remoto chamado origin. Alice clona o repositório em sua máquina local e começa a trabalhar no branch main, enquanto Bob trabalha em um branch separado chamado feature-branch.

1- Alice cria um novo arquivo chamado README.md e faz algumas alterações nele. Ela então faz commit e push das alterações para o branch main no repositório origin:

$ git add README.md
$ git commit -m "Add README file"
$ git push origin main

2- Enquanto isso, Bob fez algumas alterações no feature-branch e as enviou para o repositório origin:

$ git add some_file.txt
$ git commit -m "Add new feature"
$ git push origin feature-branch

3- Alice percebe que precisa incorporar as alterações de Bob ao seu próprio trabalho, então ela faz fetch das alterações do repositório origin:

$ git fetch origin

4- Após o fetch, Alice pode ver que há novas alterações no feature-branch:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

5- Alice agora pode fazer merge das alterações de Bob no seu branch main:

$ git merge origin/feature-branch

6- Alice resolve quaisquer conflitos de merge e depois envia suas alterações para o repositório origin:

$ git push origin main

7- Bob agora pode fazer fetch das alterações feitas por Alice:

$ git fetch origin

8- Bob agora pode ver que há novas alterações no branch main:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

9- Bob pode fazer merge das alterações feitas por Alice no seu feature-branch:

$ git merge origin/main

10- Bob resolve quaisquer conflitos de merge e depois envia suas alterações para o repositório origin:

$ git push origin feature-branch

E assim o ciclo continua, com Alice e Bob usando git fetch para rastrear as alterações feitas um pelo outro e enviar suas próprias alterações para o repositório origin. Ao usar git fetch, eles conseguem manter o repositório local atualizado com as alterações feitas pelos colegas de equipe, o que ajuda a evitar conflitos e garante um processo de colaboração tranquilo.

Git fetch vs git pull

Tanto o git fetch quanto o git pull são usados para baixar conteúdo do repositório remoto. O comando git fetch não faz merge automático das alterações nos seus branches locais; ele simplesmente atualiza os seus branches de rastreamento remoto. O conteúdo obtido não afeta o seu diretório de trabalho local, permitindo que você revise os commits com segurança antes de fazer o merge. O comando git pull baixa o novo conteúdo e faz merge automaticamente no seu branch atual. Isso pode causar conflitos de merge, por isso é recomendado executar git pull somente quando sua cópia de trabalho estiver limpa.

Em resumo, git pull é aproximadamente equivalente a git fetch seguido de git merge:

git pull origin main
# is similar to:
git fetch origin
git merge origin/main

Quando usar git fetch

Use git fetch quando quiser:

Ver o que mudou antes de integrar. Faça fetch primeiro, depois inspecione com git log origin/main.. ou git diff main origin/main, e só faça merge quando estiver pronto.
Atualizar os branches de rastreamento remoto sem tocar no seu trabalho. Útil no meio de uma tarefa quando o seu diretório de trabalho tem alterações não commitadas que um git pull poderia interromper.
Limpar branches obsoletos. git fetch --prune remove referências de rastreamento remoto de branches que foram excluídos no remoto.
Revisar o branch de um colega. Faça fetch, faça checkout para ler o código e decida se deseja fazer merge.

Prática

Quais afirmações sobre o comando git fetch estão corretas?

git fetch baixa commits, arquivos e referências de um repositório remoto para o repositório local.Após usar git fetch, seus branches locais são atualizados automaticamente para corresponder ao repositório remoto.git fetch suporta opções como --all, --dry-run, --keep, --prune e --depth.Usar git fetch coloca você em um estado 'detached HEAD' onde você pode experimentar sem afetar os branches locais.git fetch seguido de git merge é uma forma segura de revisar e integrar alterações de um repositório remoto.git fetch força o merge das alterações remotas no seu branch atual.