-
Você já pensou em voltar no tempo
para corrigir um problema
-
ou mesmo só para entender
como algo estava antes
-
de uma nova funcionalidade?
-
Enfim, vamos ver como nós
podemos fazer isso com o Git.
-
A gente já sabe criar commits
usando o Git
-
e com isso a gente consegue manter
um histórico decente
-
das nossas alterações.
-
Mas e se a gente precisa voltar
no tempo por algum motivo para,
-
não sei, ver como o código
estava antes da criação
-
de determinado arquivo
ou mesmo recuperar alguma feature
-
que foi perdida ao longo do tempo,
mas que está lá no histórico.
-
Enfim, para isso
nós conseguimos juntar
-
o comando do "git log"
com outros utilitários
-
e recuperar o conteúdo
que a gente tinha lá anteriormente.
-
Então,
vamos lá para a nossa máquina,
-
para a gente criar um repositório
e entender como tudo isso funciona.
-
Vamos usar a pasta "Projetos"
que eu já tenho aqui
-
na área de trabalho para criar
o nosso primeiro repositório.
-
Então, vamos começar criando
uma pasta chamada "meu aplicativo".
-
E dentro dela vamos abrir uma
instância do "Git Bash".
-
Aqui dentro nós já sabemos como
prosseguir.
-
"git status"
para iniciar um repositório vazio
-
e vamos adicionar
dois arquivos lá dentro.
-
Ou melhor,
vamos fazer dois commits,
-
cada um adicionando um arquivo.
-
Vamos começar criando o arquivo
"pagina-inicial.txt".
-
Vamos lá dentro do Windows Explorer
e editar o conteúdo desse arquivo
-
colocando alguma coisa
como por exemplo,
-
"Bem vindo".
-
Salvamos o arquivo
e vamos registrar essa alteração
-
dentro de um commit.
-
Para isso,
"git add"
-
e o nome do arquivo
"pagina-inicial.txt"
-
Vamos usar o "git status" apenas
para conferir se o nosso arquivo
-
realmente está aqui.
-
Conferimos.
-
Vamos usar o "git commit"
para de fato persistir
-
essa alteração no nosso histórico,
"adicionando pagina inicial".
-
Pronto!
-
Vamos limpar o terminal
e usar o comando "git status".
-
Tudo está limpo por aqui,
-
então vamos implementar
um outro arquivo
-
para que a gente
tenha um histórico de fato
-
de alterações
que aconteceram no nosso projeto.
-
Voltando aqui para a tela visual
do Windows Explorer,
-
vamos dessa vez criar um outro
arquivo que vai se chamar "carrinho"
-
e dentro desse arquivo
nós colocaremos o conteúdo
-
"Carrinho de compras".
-
Agora com o arquivo criado,
vamos adicioná-lo também no Git,
-
mas dessa vez um pouco diferente.
-
Já usamos o comando "git add"
passando o nome do arquivo,
-
mas dessa vez
vamos passar apenas ponto
-
e dessa forma
adicionar o diretório atual inteiro.
-
Lembre,
o comando "git add",
-
ele recebe o diretório que queremos
adicionar ao versionamento
-
e não necessariamente
o nome do arquivo.
-
Passando o ponto,
-
estamos adicionando
o diretório atual inteiro
-
e todos os arquivos que foram
alterados entrarão no próximo commit.
-
Vamos fazer isso então.
-
"git add ."
-
e "git commit -m
"Carrinho de compras adicionado"."
-
E pronto.
-
Agora, se usarmos o comando "git log",
-
conseguimos ver que há dois
commits no nosso histórico.
-
Chegou a hora então da gente
manipular um pouco esse histórico.
-
Imagine que a gente quisesse ver
como o repositório
-
estava durante o momento
do primeiro commit.
-
Se nós acessarmos o Windows Explorer
nesse momento,
-
veremos que tem dois arquivos.
-
Mas nós sabemos que no primeiro
commit tínhamos apenas um.
-
Então,
vamos executar o comando "git log"
-
para que a gente consiga
pegar o identificador
-
daquele nosso primeiro commit.
-
Vamos usar o botão
direito para copiá lo
-
e com ele em mãos,
vamos usar o comando "git checkout".
-
Esse comando
pegará o diretório atual
-
e vai movê-lo para aquele ponto
na história específico
-
em que nós especificarmos.
-
Então,
vamos ver como isso funciona.
-
"git checkout" e o dif
que nós copiamos.
-
Ao dar enter,
-
repare que várias coisas
foram informadas para a gente.
-
Não se preocupe,
-
isso daqui basicamente
está nos informando
-
que o nosso diretório atual,
o nosso repositório,
-
está apontando para algo
que está fora do histórico.
-
É como se nós tivéssemos criado
uma linha do tempo temporária
-
que apenas aponta
para aquele momento específico.
-
Ok?
-
Então se nós voltarmos
para o Windows Explorer,
-
veremos que não temos
mais os dois arquivos,
-
apenas aquele
nosso arquivo principal.
-
Mas novamente,
não se preocupe,
-
esse arquivo ele não foi excluído.
-
Você está apenas navegando
no histórico do Git.
-
Usar o Git como ferramenta
de controle de versão
-
permite que você faça
esse tipo de coisa muito simples
-
e sem correr o risco
de perder os seus arquivos.
-
Caso nós queiramos voltar
para o histórico
-
que nós tínhamos atualmente,
-
basta usar o comando
checkout novamente,
-
Só que dessa vez,
-
ao invés de usar o Hash
de algum commit específico,
-
vamos usar a main,
-
que é a nossa branch principal
que escolhemos durante a instalação.
-
Vamos voltar para o terminal
e ver isso então.
-
Usando o comando "git checkout"
vamos informar "main" dessa vez.
-
E repare que agora uma mensagem
informa que nós voltamos
-
para branch "main" e se voltarmos
para o Windows Explorer,
-
veremos que os nossos dois
arquivos estão lá,
-
assim como o nosso histórico
completo com os nossos dois commits.
-
Essa estratégia funciona muito bem
-
para quando nós queremos
apenas visualizar o que foi alterado
-
ou mesmo como o repositório estava
em um ponto específico do tempo.
-
Mas imagine um cenário diferente,
-
e que você quer de fato
desfazer alguma alteração.
-
Imagine,
por exemplo,
-
que nós não precisamos mais
do carrinho de compras
-
e nós queiramos excluir tudo
relacionado a ele.
-
Uma possibilidade,
seria de fato,
-
a gente remover
esse convite da história do tempo,
-
mas alguém gastou tempo
implementando aquilo.
-
E embora essa funcionalidade
não seja mais útil agora,
-
nós podemos querer
recuperá-la no futuro
-
e tê-la no histórico
é muito importante.
-
Então, o que nós vamos fazer agora
é criar um novo commit,
-
mais um commit especial
e quem vai fazê-lo é o Git.
-
Esse commit será feito apenas
para desfazer tudo o que foi feito
-
em um ponto da história específico.
-
Claro, nós vamos precisar do hash
do commit que nós queremos desfazer
-
e o comando que vamos usar
é o "git reset".
-
Vamos ver como isso funciona.
-
Vamos começar
usando o comando "git log"
-
para que a gente recupere
os hashs dos commits que nós temos.
-
Imagine que esse daqui seja o commit
que nós queremos desfazer,
-
ou melhor,
reverter.
-
Nós vamos copiá-lo
e usar o comando "git revert"
-
informando aquele hash específico.
-
Ao ter 40,
-
repare que essa tela aqui
abriu para nós.
-
Não se assuste,
esse daqui é o editor de texto VIM
-
que nós escolhemos como opção
padrão durante a instalação do Git.
-
Existem algumas características
desse editor
-
que tornam a sua utilização
um pouco complicada,
-
mas não se preocupe,
é bem simples de usar esse editor.
-
No momento ele está apenas
pedindo que nós escrevamos
-
a mensagem que vai ser anexada
a esse commit.
-
Esse commit
tem uma única responsabilidade,
-
reverter um commit específico.
-
Então ele já formatou para a gente
a seguinte mensagem:
-
Revert e o texto que havia naquele
commit que nós informamos
-
e logo abaixo uma descrição
um pouco mais complexa.
-
Esse commit reverte o commit tal.
-
Essa mensagem está perfeita
para o que a gente quer,
-
então basta que saiamos desse editor
usando o seguinte atalho.
-
Vamos apertar "ESC"
-
para garantir que o VIM entenda
que nós queremos entrar
-
no modo específico
e então digitar ":WQ".
-
Isso fará com que o VIM escreva
no arquivo o que está na tela
-
e então saia dele.
-
Uma vez que nós fizemos isso,
vamos voltar para o terminal
-
e não estranhem se ele limpar algum
conteúdo que estava anteriormente.
-
Isso é normal.
-
Vamos usar o comando "git log"
-
e dessa vez nós conseguimos
conferir o seguinte.
-
Temos os dois commits
que nós já tínhamos anteriormente
-
e um novo.
-
só que esse commit
fomos nós que fizemos,
-
mas quem de fato realizou
as ações foi o Git.
-
E se voltarmos no Windows Explorer
nós conseguimos ver
-
que aquele arquivo
não está mais aqui.
-
Então com sucesso,
nós conseguimos remover um arquivo
-
sem de fato perder aquele conteúdo
na linha do tempo.
-
Agora imagine que seu objetivo
não é necessariamente
-
apagar alguma coisa
e mantê la no histórico,
-
mas sim apagar de vez,
remover do histórico por completo.
-
Em que cenários
nós conseguiríamos usar isso?
-
Imagine que você sobe uma senha
sem querer dentro do seu projeto.
-
Você não quer que essa senha
fique no histórico,
-
porque, como nós já vimos,
nós conseguimos remover coisas.
-
Mas acessando o histórico
com o git checkout
-
é possível a gente acessar
aquele momento da linha do tempo
-
e ler a sua senha
sem nenhum problema.
-
Então, nesse cenário,
nós utilizaremos o Git reset.
-
Ele tem o poder de não
só voltar no tempo
-
como apagar
tudo o que estava dali para frente.
-
Vamos ver como que ele funciona.
-
Voltando aqui na máquina,
-
o comando git log nos mostra
que nós temos três commits.
-
Imagine então
-
que nós quiséssemos voltar no tempo
para o nosso primeiro commit,
-
apagando por completo
tudo o que aconteceu dali em diante.
-
Então, dessa vez
nós usaremos o comando git reset,
-
passando o nosso como o nosso resto
do primeiro commit.
-
Então vamos copiá lo
e colocá lo aqui na frente
-
para que esse comando de fato
apague o histórico.
-
Nós vamos usar a flag
menos menos hard
-
e quando eu tecla enter
tudo aconteceu como esperado.
-
Se eu volto no Windows Explorer
eu não tenho mais o meu arquivo
-
que foi excluído.
-
E se eu tentar acessar o git log
-
para pegar o histórico
de todos os meus commits,
-
eu vejo que eu só
tenho apenas um commit
-
e aqueles meus outros dois commits
foram perdidos para sempre.
-
Dessa forma,
-
a gente consegue se livrar
de alguns convites indesejáveis
-
que podem acabar acontecendo dessa
forma, nós conseguimos se livrar
-
completamente de algum
commit indesejado, excluindo,
-
por exemplo, o vazamento de alguma
senha ou coisa do tipo.
