Git: Os novos comandos git restore e git switch

Jonilson Sousa
Jonilson Sousa

Compartilhe

Como se não bastassem as dúvidas iniciais de Git e GitHub, o Git pode ser um tanto confuso em alguns comandos, como o é o caso do git checkout. Ele não só permite criar e alternar entre branchs, mas também permite remover arquivos.

Para facilitar e dividir as responsabilidades, o Git, a partir da versão 2.23.0, incorporou dois novos comandos: o git restore e o git switch.

A confusão do git checkout

Temos um projeto já criado com a branch master e precisamos inserir um novo código.Seguindo as convenções de desenvolvimento temos que criar uma nova branch para inserirmos essas alterações e posteriormente enviamos para uma análise e um possível merge na master.

Nesse cenário o comando git checkout é nosso grande aliado, com ele podemos criar branchs usando a flag -b dessa forma:

git checkout -b novo-codigo

E com isso já criamos e selecionamos nossa branch chamada novo-codigo, sendo uma grande facilidade tendo em vista que precisaríamos utilizar dois comandos:

git branch novo-codigo

git checkout novo-codigo

Porém como vocês já devem saber também podemos utilizar o git checkout para alterar entre branch já existentes, poderíamos simplesmente usar o seguinte comando para voltarmos para a branch master do nosso projeto:

git checkout master

imagem 1

Além disso podemos utilizar o git checkout a nível de arquivo, e assim podemos descartar todas as alterações que fizemos em um determinado arquivo.

Assim, podemos desejar descartar todas as alterações do arquivo index.html do nosso projeto, e como estávamos fazendo essas alterações na nossa nova branch novo-codigo então precisamos alternar para ela e depois descartar as alterações, para isso podemos utilizar os dois comandos:

git checkout novo-codigo

git checkout -- index.html

imagem 2

Pronto, agora temos o arquivo index.html sem nenhuma modificação, igual ao estado do último commit. E ainda podemos ter outras utilizações do comando git checkout, vocês podem verificar na documentação todas as possibilidades.

Porém com podemos perceber o git checkout, faz muitas coisas, tem muitas responsabilidades e isso em um momento pode nos confundir e nos deixar pensando a respeito da utilização do comando, que é bastante semelhante para várias ações.

Devemos estar sempre atentos ao nível de escopo em que vamos utilizar o comando git checkout. A nível de escopo de arquivo ele tem um comportamento, a nível de commit tem um outro comportamento e a nível de branch outro comportamento.

A divisão de responsabilidades

Pensando nisso, os mantenedores do Git incorporaram dois novos comandos a partir da versão 2.23.0 e ambos vêm com o intuito de dividir responsabilidades, e de serem mais específicos para as funções que se propõem realizar.

Os novos comandos são o git restore e o git switch, veremos nas próximas seções com mais detalhes como esses comandos funcionam e como podemos ir aos poucos utilizando eles no lugar de utilizar somente o git checkout.

Git restore

O git restore é uma nova opção quando estamos trabalhando e precisamos restaurar algum arquivo ou o projeto por completo, e isso o git checkout também faz, porém o git restore é especificamente para trabalhar com essa parte de restauração de arquivos ou projeto ao um ponto anterior que chamamos de fonte de restauração (source).

Em nosso projeto que já está sendo versionando temos o arquivo index.html, e já fizemos três commits:

commit 6c24206deec5be5b4ff08281d77c3097df3e6e98
Author: paulo <[email protected]>
Date:   Thu Feb 20 20:56:49 2020 -0300

    Adicionado barra de pesquisa

commit fa151c6535a7d0dcd1c6d792ffd2233afefa56r7
Author: paulo <[email protected]>
Date:   Thu Feb 20 20:47:03 2020 -0300

    Adicionando o Title do site

commit c776f0cdefd3c6e05165feecbfe6d6a484436f16
Author: paulo <[email protected]>
Date:   Thu Feb 20 20:45:52 2020 -0300

    Estrutura inicial do HTML5

Os dois últimos commits (Adicionando o Title do site, Adicionado barra de pesquisa) não foram aprovadas e nesse momento precisamos voltar todo o projeto (para isso usamos o ponto final: .) ao estado do primeiro commit (Estrutura inicial do HTML5), poderíamos fazer isso usando o git checkout informando o ID do commit da seguinte forma:

git checkout c776f0cdefd3c6e05165feecbfe6d6a484436f16 .

Porém com o git restore também podemos fazer o mesmo, entretanto precisamos informar o ID do primeiro commit como um valor para a flag source, que é o ponto ou fonte de restauração da seguinte maneira:

git restore --source c776f0cdefd3c6e05165feecbfe6d6a484436f16 .

Mas podemos parar e pensar que usando o comando git restore a sintaxe é mais verbosa, agora temos que passar uma flag (--source) indicando qual o ponto, ou seja qual o estado que desejamos voltar?

A resposta é sim, e isso é uma tendência, antes tínhamos isso não só no Git, mas em muitas outras ferramentas, essa ideia de um comando realizar diversas tarefas. Porém agora os mantenedores estão dividindo as responsabilidades e deixando os comando um pouco mais verbosos, porém semanticamente melhores de identificar cada parte do comando, bem como deixa o mesmo mais organizado e de fácil compreensão para outras pessoas.

git switch

O git switch surge como alternativa quando estamos trabalhando com branchs. Com o git checkout podemos criar novas branchs e também alternamos entre os mesmos, e com o git switch podemos fazer o mesmo.

No nosso projeto precisamos criar uma nova branch com o nome nova-branch no nosso projeto, poderíamos utilizar o seguinte comando:

git switch -c nova-branch

Agora se executarmos o comando git branch para visualizar a lista de branchs que temos atualmente no projeto temos uma lista como essa:

master
*novo-codigo
nova-branch

Note que o asterisco (*) significa qual o branch está em uso no momento, nesse caso é o branch novo-codigo que criamos numa seção anterior. Assim, precisamos alternar para esse “novo-branch”, e para isso podemos utilizar um comando bastante semelhante:

git switch novo-branch

Pronto, já estamos utilizando o nova-branch, para confirmarmos isso podemos executar o comando git branch novamente, dessa vez a saída deve ser com o nova-branch selecionado:

master
novo-codigo
*novo-branch

Uma outra possibilidade que temos usando o git switch é usá-lo juntamente com o comando git branch, assim poderíamos criar a branch com o comando git branch e apenas selecionarmos o mesmo com o switch:

git branch novo-branch

git switch novo-branch

O switch também nos fornece um atalho bastante interessante quando precisamos selecionar a branch master, podemos simplesmente utilizar um sinal de subtração ( - ) no lugar do nome do branch:

git switch -

Se executarmos o comando git branch podemos perceber que estamos novamente com a branch master selecionada:

*master
novo-codigo
novo-branch

Mais um possibilidade que o switch disponibiliza é alternamos para um branch remoto, no caso um branch que nosso projeto não tenha localmente ainda, então primeiro precisamos executar o comandogit fecth para atualizarmos as informações do projeto remoto:

git fetch

E logo em seguida usamos o comando com a seguinte sintaxe:

git switch -c <nome-do-branch-local> --track <remoto-origin>/<nome-do-branch-remoto>

Conclusão

Assim, podemos entender que a divisão das responsabilidades do comando git checkout com os comandos git restore e git switch faz com que os comandos fiquem mais claros e mais bem definidos.

Torna mais fácil o aprendizado, bem como o entendimento acerca das tarefas que cada um pode executar. E são de grande ajuda quando estamos versionando código, seja em um projeto pequeno, ou em um grande projeto de uma grande empresa. Entender e saber como utilizar esses novos recursos é muito importante. Ainda não sabemos com certeza mas talvez o comando git checkout possa nem existir em versões futuras do Git!

Gostou do artigo e quer saber mais sobre Git, aqui na alura temos o Curso de Git e Github: Controle e compartilhe seu código que é um curso introdutório e também o Curso de Git e Github: Estratégias de ramificação, Conflitos e Pull Requests que é mais avançado e trata também de GitHub, e como usar essa poderosa ferramenta a nosso favor.

Jonilson Sousa
Jonilson Sousa

Atualmente sou desenvolvedor de software no Grupo Alura. Trabalhando com as mais diversas tecnologias, como nas linguagens Java, Python, Javascript, usando frameworks como Spring Boot, Flask.

Veja outros artigos sobre DevOps