CC CAP05 2025 VA03 GIT VIAGEM NO TEMPO

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 é o
disse que nós copiamos ao dar entre.

Repare que várias coisas
foram informadas pra gente.

Não se preocupe, isso aqui
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 resto de algum commit específico,

vamos usar a MEM,

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 mem dessa vez.

E repare que agora

numa mensagem forma
que nós voltamos para bem Gmail

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 que 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 Comente

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 resto
do commit que nós queremos de fazer

e o comando que vamos usar
é o git reset.

Vamos ver como isso funciona.

Vamos começar
usando o comando byte log

para que a gente recupere
os restos dos começos 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
que abriu para nós não se assuste,

está aqui é 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 convite específico.

Então ele já formatou para a gente
a seguinte mensagem Revert

é 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 dois pontos,

a letra W e a letra que 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 glitch 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.