Close

O que faz o Git Checkout

Esta página analisa o comando git checkout. com exemplos de uso e casos extremos. Mas o que faz o git checkout? Em termos Git, um “checkout” é o ato de alternar entre versões diferentes de uma entidade de destino. O comando git checkout opera em três entidades distintas: arquivos, commits e ramificações. Além da definição de “checkout”, o termo “checkout” costuma ser usado para implicar o ato de executar o comando git checkout. No tópico Como desfazer alterações, a gente viu como o git checkout pode ser usado para visualizar commits antigos. O foco para a maioria deste documento vai ser operações de checkout em ramificações.

A verificação de ramificações é semelhante à verificação de commits e arquivos antigos, pois o diretório atual é atualizado para ficar igual às ramificações/revisões selecionadas; no entanto, novas alterações são salvas no histórico do projeto — ou seja, não é uma operação apenas de leitura.


Verificação de branches


O comando git checkout permite navegar entre ramificações criadas pelo git branch. A verificação de uma ramificação atualiza os arquivos no diretório atual para que fique igual à versão armazenada nessa ramificação e diz ao Git para gravar todos os novos commits nessa ramificação. É como uma maneira de selecionar em qual linha de desenvolvimento você está trabalhando.

Ter um branch específico para cada novo recurso é uma diferença drástica do fluxo de trabalho SVN tradicional, que facilita demais o teste de novos experimentos, sem medo de destruir as funcionalidades atuais, além de possibilitar o trabalho em diversos recursos não relacionados ao mesmo tempo. Os branches ainda facilitam vários fluxos de trabalho colaborativos.

O comando git checkout pode, às vezes, ser confundido com o git clone. A diferença entre os dois é que o clone trabalha para buscar código de um repositório remoto, já o checkout serve para alternar entre versões de código já existentes no sistema local.

Janela do console
Material relacionado

Log avançado do Git

Logotipo do Bitbucket
VER SOLUÇÃO

Aprenda a usar o Git com o Bitbucket Cloud

Uso: branch atuais


Supondo que o repositório em que você está trabalhando contenha ramificações preexistentes, você pode alternar entre elas usando o comando git checkout. Para descobrir quais ramificações estão disponíveis e o nome da ramificação atual, execute git branch.

$> git branch 
main 
another_branch 
feature_inprogress_branch 
$> git checkout feature_inprogress_branch

O exemplo acima demonstra como exibir uma lista de ramificações disponíveis executando o comando git branch e alternar para uma ramificação especificada, neste caso, o feature_inprogress_branch.

Novos branches


O comando Git checkout funciona lado a lado com o git branch. O comando git branch pode ser usado para criar uma ramificação. Quando quiser iniciar uma função, crie uma ramificação a partir da main usando git branch new_branch. Então, você vai poder usar git checkout new_branch para mudar para essa ramificação. Além disso, o comando git checkout aceita um argumento -b que atua como método de conveniência que vai criar a ramificação e mudar para ela na hora. Você pode trabalhar em várias funções em um único repositório alternando entre elas com o git checkout.

git checkout -b <new-branch>

O exemplo acima cria e verifica ao mesmo tempo <new-branch>. A opção -b é uma marcação de conveniência que diz ao Git para rodar o git branch antes de rodar o git checkout .

git checkout -b <new-branch> <existing-branch>

Por padrão, o git checkout -b vai usar como base para o new-branch o HEAD atual. Outro parâmetro de ramificação opcional pode ser transmitido para o git checkout. No exemplo acima, o existing-branch> é transmitido e, então, o new-branch toma o existing-branch como base em vez do HEAD.

Alternância de branches


Alternar entre as ramificações é uma operação simples. O comando a seguir vai apontar HEAD para a ponta de <branchname>.

git checkout <branchname>

O Git rastreia um histórico de operações de verificação no reflog. Você pode executar git reflog para visualizar o histórico.

Git checkout em um branch remoto


Ao colaborar com uma equipe, é comum utilizar repositórios remotos. Esses repositórios podem ser hospedados e compartilhados ou podem ser uma cópia local de outro colega. Cada repositório remoto vai conter seu próprio conjunto de branches. Para verificar um branch remoto, você precisa primeiro buscar o conteúdo do branch.

git fetch --all

Em versões mais recentes do Git, você pode então verificar o branch remoto como um branch local.

git checkout <remotebranch>

Versões mais antigas do Git exigem a criação de uma nova ramificação baseada na remota.

git checkout -b <remotebranch> origin/<remotebranch>

Além disso, você pode verificar um novo branch local e fazer a redefinição para o último commit de branches remotos.

git checkout -b <branchname>
git reset --hard origin/<branchname>

HEADS desvinculados


Agora que a gente viu os três principais usos do git checkout em ramificações, é importante discutir o estado “detached HEAD”. Não se esqueça de que o HEAD é a maneira do Git de se referir à captura de tela atual. Por dentro, o comando git checkout apenas atualiza o HEAD para apontar para a ramificação ou commit especificado. Quando aponta para uma ramificação, o Git não se queixa, mas quando você verifica um commit, ele muda para um estado “detached HEAD”.

Este é um aviso dizendo que tudo o que você está fazendo está “separado” do resto do desenvolvimento do projeto. Se você começasse a desenvolver um recurso enquanto em um estado de HEAD desvinculado, não haveria ramificação que permitisse que você voltasse a ele. Quando você fosse verificar outra ramificação (por exemplo, para fazer a mesclagem do seu recurso), não haveria como fazer referência ao seu recurso:

Head anexado vs. head desvinculado

A questão é que você deve sempre fazer o desenvolvimento em uma ramificação — nunca em um HEAD separado. Assim você garante que sempre vai ter uma referência para os novos commits. No entanto, se você está apenas olhando um commit antigo, não importa se você está em um estado HEAD separado ou não.

Resumo


Esta página tratou do uso do comando git checkout para alterar ramificações. Em resumo, o git checkout, quando usado em ramificações, altera o alvo da referência HEAD. Ele pode ser usado para criar ramificações, alternar entre ramificações e verificar ramificações remotas. O comando git checkout é uma ferramenta essencial para a operação padrão do Git. É uma contraparte do git merge. Os comandos git checkout e git merge são ferramentas essenciais para habilitar os fluxos de trabalho git.


Compartilhar este artigo
Próximo tópico

Leitura recomendada

Marque esses recursos para aprender sobre os tipos de equipes de DevOps ou para obter atualizações contínuas sobre DevOps na Atlassian.

Pessoas colaborando usando uma parede cheia de ferramentas

Blog do Bitbucket

Ilustração do DevOps

Caminho de aprendizagem de DevOps

Demonstrações de funções no Demo Den com parceiros da Atlassian

Como o Bitbucket Cloud funciona com o Atlassian Open DevOps

Inscreva-se para receber a newsletter de DevOps

Thank you for signing up