Tutorial de redefinição e reversão do Git para iniciantes

Visão geral do Git Revert e Reset 

O Git revert e o Git reset são dois comandos usados no Git para desfazer alterações no código e no histórico de um projeto, mas de maneiras diferentes. Nesta seção, forneceremos uma visão geral de como usar a reversão e a redefinição. Antes de mergulhar no processo, vamos criar um projeto Git.

Criar um projeto Git

Abaixo estão as instruções para que você crie um projeto git e o inicialize com alguns arquivos:

mkdir git_revert_reset
cd git_revert_reset
git init .

• mkdir git_revert_reset cria uma pasta chamada git_revert_reset. 

• cd git_revert_reset você vai para a pasta. 

• git init . inicializa a pasta como um repositório git.

Considerando isso como um projeto de ciência de dados, podemos criar os seguintes arquivos para aquisição de dados, pré-processamento de dados e treinamento de modelos usando este comando touch:

touch data_acquisition.py data_preprocessing.py model_training.py

Esse é o conteúdo final da pasta do projeto.

git_revert_reset
      |---------- data_acquisition.py
      |---------- data_preprocessing.py
      |---------- model_training.py

Redefinição do Git 

Diagrama de redefinição do Git(Fonte)

O comando git reset é usado para desfazer as alterações em seu diretório de trabalho e voltar a um commit específico, descartando todos os commits feitos depois desse. 

Por exemplo, imagine que você fez dez commits. Usar git reset no primeiro commit removerá todos os nove commits, levando você de volta ao estágio do primeiro commit.

Antes de usar o git reset, é importante considerar o tipo de alteração que você pretende fazer; caso contrário, você criará mais caos do que benefícios. 

Você pode usar várias opções junto com git reset, mas estas são as principais. Cada um deles é usado de acordo com uma situação específica: git reset --soft, git reset --mixed, e git reset --hard

git reset --soft

O objetivo do --soft é alterar a referência HEAD (onde está o último commit em seu computador local) para um commit específico. Por exemplo, se você perceber que se esqueceu de adicionar um arquivo ao commit, poderá voltar atrás usando o --soft em relação ao seguinte formato:

• git reset --soft HEAD~n para voltar ao commit com uma referência específica (n). git reset --soft HEAD~1 volta ao último commit.

• git reset --soft volta para a cabeça com o .

Vamos dar uma olhada em alguns exemplos.

git add data_acquisition.py data_preprocessing.py

git add data

git commit -m "added data acquisition and preprocessing scripts"

Esse é o resultado do comando anterior. 

[master (root-commit) faf864e] added python scripts and data folder
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py

Você pode verificar o status do commit da seguinte forma:

git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
model_training.py

nothing added to commit but untracked files present (use "git add" to track)

Porém, esquecemos de adicionar o script model_training.py ao commit.

Como o último commit está localizado em HEAD, podemos corrigir esse problema executando as três instruções a seguir. 

• Volte para a fase de pré-compromisso usando git reset --soft HEAD, permitindo que o arquivo git reset.

• Adicione o arquivo esquecido com git add. 

• Faça as alterações com um commit final git commit.

git reset --soft HEAD

git add model_training.py

git commit -m "added all the python scripts"

O resultado a seguir fez com que o git reset se tornasse mestre após todas as etapas anteriores: 

[master (root-commit) faf864e] added all the python scripts
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py
create mode 100644 model_training.py

git reset --mixed

Esse é o argumento padrão para git reset. A execução desse comando tem dois impactos: (1) desfazer o commit de todas as alterações e (2) remover o palco. Imagine que adicionamos acidentalmente o arquivo model_training.py e queremos removê-lo porque o treinamento do modelo ainda não foi concluído. Veja a seguir como você deve proceder: 

• Remova os arquivos que estavam no commit com git reset HEAD
• Adicione apenas os arquivos necessários para o commit

git reset HEAD

git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
model_training.py
data_acquisition.py
data_preprocessing.py

nothing added to commit but untracked files present (use "git add" to track)

Agora, podemos adicionar apenas os dois últimos arquivos a serem confirmados e fazer a confirmação.

git add data_acquisition.py data_preprocessing.py

git commit -m "Removed the model_training.py from the commit"

git reset --hard

Essa opção pode ser perigosa. Portanto, tenha cuidado ao usá-lo! 

Basicamente, ao usar o hard reset em um commit específico, você força o HEAD a voltar para esse commit e exclui todo o resto depois disso.

Antes de executar a reinicialização a frio, vamos dar uma olhada no conteúdo da pasta.

ls
data_acquisition.py data_preprocessing.py model_training.py

git reset --hard
HEAD is now at 97159bc added data acquisition and preprocessing scripts

Agora, vamos verificar o conteúdo da pasta:

ls
data_acquisition.py data_preprocessing.py

Observamos que o arquivo não rastreado model_training.py foi excluído. Novamente, certifique-se de entender o que você está fazendo com a declaração de redefinição, pois as consequências podem ser dramáticas!

Reversão do Git

Antes e depois da reversão(fonte)

Git revert é semelhante ao git reset, mas a abordagem é ligeiramente diferente. Em vez de remover todos os commits em seu caminho, a reversão APENAS desfaz um único commit, levando você de volta aos arquivos preparados antes do commit.

Portanto, em vez de remover um commit, o git revert inverte as alterações introduzidas pelo commit original, criando um novo commit com o conteúdo inverso subjacente. Essa é uma maneira segura de revogar um commit, pois evita que você perca seu histórico. 

É importante que você saiba que a reversão não terá efeito, a menos que o hash ou a referência do commit seja especificado. 

Vamos explorar algumas opções comuns de reversão do git.

git revert --no-edit <commit ID>

A opção --no-edit permite que o usuário não altere a mensagem usada para o commit que você deseja reverter, e isso fará com que o git reverta o arquivo para o ramo mestre.

Para ilustrar esse cenário, vamos criar dois novos arquivos a serem adicionados. 

touch model_monitoring.py data_monitoring.py

Depois de criar esses arquivos, precisamos adicioná-los à área de preparação da versão modificada.

git add model_monitoring.py

Antes de prosseguir, vamos dar uma olhada no status executando o seguinte comando.

git status
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file:   data_monitoring.py
new file:   model_monitoring.py

Podemos observar que os dois arquivos foram adicionados. Agora, podemos confirmar as alterações.

git commit -m "Added the monitoring script files"
[master (root-commit) eae84e7] Added the monitoring script files
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_monitoring.py
create mode 100644 model_monitoring.py

Em seguida, o hash de confirmação pode ser gerado por meio do seguinte comando. Isso é útil quando você tenta executar uma ação para esse commit específico. 

git reflog
eae84e7 (HEAD -> master) HEAD@{0}: commit (initial): Added the monitoring script files

Agora, vamos imaginar que o commit anterior não foi intencional e queremos nos livrar dele.

git revert --no-edit eae84e7

[master c61ef6b] Revert "Added the monitoring script files"
Date: Sat Nov 12 20:14:17 2022 -0600
2 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 data_monitoring.py
delete mode 100644 model_monitoring.py

Vamos dar uma olhada no registro dos commits:

git log

commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 (HEAD -> master)
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:14:17 2022 -0600

  Revert "Added the monitoring script files"
 
  This reverts commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3.

commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:05:57 2022 -0600

  Added the monitoring script files

No registro, podemos observar que um novo commit foi criado com o ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 para reverter o commit original com o ID eae84e7669af733ee6c1b854f2fcd9acfea9d4a3. 

Neste exemplo, como temos um único commit, poderíamos simplesmente usar git revert HEAD,, que teria o mesmo efeito ao reverter o último commit.

git revert <hash de confirmação>

Isso removerá apenas as alterações associadas a esse hash de commit e não afetará nenhum outro commit.

Qual reversão do git você acha que terá efeito, considerando o ID gerado anteriormente? 

Se sua resposta foi c61ef6b4e86f41f47c8c77de3b5fca3945a7c075, então você está certo. Considerar eae84e7669af733ee6c1b854f2fcd9acfea9d4a3 não terá efeito, pois ele é substituído por um novo. 

Vamos ver o que acontece quando você tenta realizar a reversão.

git revert c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

[master aaead40] Revert "Revert "Added the monitoring script files""

 2 files changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 data_monitoring.py

 create mode 100644 model_monitoring.py

Como você pode ver, os dois arquivos inicialmente criados e confirmados foram trazidos de volta!

git revert --no-commit <identificação do commit>

O objetivo de usar a opção --no-commit ou -n é evitar que o git faça o commit automático da reversão. Isso pode ser útil se você quiser revisar as alterações feitas pelo comando revert antes de confirmá-las.

Vamos considerar o seguinte exemplo: 

git revert --no-commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

Isso reverterá as alterações feitas pelo commit com o ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075, mas não criará automaticamente um novo commit para registrar a reversão. Em vez disso, ele deixará as alterações sem ser processadas para que você possa analisá-las e decidir se deve confirmar a reversão manualmente.

Git Revert vs. Git Revert. Redefinir

Reversão do Git 

• Usando o git revert, você pode voltar a estados anteriores enquanto cria um novo commit.

• Escolha essa opção se você quiser desfazer as alterações em uma ramificação pública por segurança.

Redefinição do Git

• Com git reset, você pode voltar aos commits anteriores, mas não pode criar um novo commit. 

• Essa opção é melhor para desfazer alterações em uma ramificação privada.

Conclusão

Neste tutorial, vimos como realizar alterações em git reset e git revert em seu repositório git. Lembre-se de que uma reinicialização total pode ser muito perigosa porque fará com que você perca os arquivos não rastreados no projeto. 

Então, o que vem a seguir? A DataCano tem vários tutoriais que podem ser uma boa próxima etapa para que você aprimore suas habilidades com o Git, como, por exemplo, o tutorial "Como você pode fazer isso?

• Como resolver conflitos de mesclagem no tutorial do Git
• GitHub e Tutorial do Git para iniciantes
• Tutorial de push e pull do Git