-
Chegou o momento
da gente criar história.
-
A gente já entendeu
como o Git consegue nos ajudar.
-
Então, agora chegou a hora
de colocar a mão na massa
-
e, de fato,
criar o nosso primeiro repositório.
-
Antes da gente começar a criar
de fato a nossa aplicação,
-
vamos entender
o que é um repositório.
-
Trata-se nada mais nada menos
do que uma pasta,
-
mas uma pasta
com controle de versão.
-
Tudo o que colocarmos
dentro dessa pasta,
-
o Git vai observar e permitir
-
que a gente transforme isso
em commits,
-
que são pontos na linha do tempo.
-
Então, ao longo do tempo,
-
conforme a nossa aplicação
for crescendo,
-
a gente consegue consultar
essa linha do tempo
-
e entender as evoluções
que nós tivemos,
-
o que foi implementado
e entender até mesmo quais arquivos
-
precisaram ser mexidos
e quais conteúdos deles
-
que mudaram como a nossa
aplicação funciona.
-
Então, vamos lá para a máquina
para começar isso de fato.
-
Eu já criei uma pasta
chamada "projetos"
-
aqui na minha área de trabalho
-
e é nela que a gente vai criar
todos os nossos repositórios.
-
Então,
vamos começar abrindo ela aqui
-
e criando uma nova pasta aqui dentro
chamada "meu aplicativo".
-
Dentro dessa pasta,
eu vou abri-la
-
e é muito importante que a gente
use um terminal aqui dentro,
-
porque o Git é uma ferramenta de CLI.
-
Então, podemos usar o PowerShell,
o CMD
-
ou qualquer outro de nossa
preferência.
-
Mas como nós instalamos o Git
e ele traz o próprio bash,
-
vamos usar o Git Bash
para fazer essa tarefa.
-
Então, usando novamente
o botão direito,
-
vamos escolher a opção
"open Git Bash here".
-
Um terminal será aberto
e você verá
-
que ele é bem semelhante
ao Windows.
-
Vamos começar usando o comando
"git status",
-
que é o comando
que nós usamos do Git
-
para ver como o repositório atual
está se comportando.
-
Repare que nós recebemos
um erro.
-
Isso acontece porque trata-se
apenas de uma pasta comum,
-
não é um repositório do Git.
-
Para que essa pasta vire de fato
um repositório
-
e a gente possa versionar arquivos,
-
nós precisamos usar o comando
"git init".
-
Vamos executar
para ver o que acontece.
-
Executando o comando "git init",
nós temos uma mensagem
-
de que um novo repositório vazio
foi inicializado nesse diretório
-
e veja que interessante.
-
Se nós voltarmos aqui
no Windows Explorer,
-
nós veremos
que tem uma nova pasta
-
que a gente não criou,
a ponto git.
-
Essa pasta é oculta e talvez
não apareça no Windows Explorer,
-
mas nós conseguimos acessá-la
através do terminal do Git Bash.
-
Veja só como.
-
Voltando aqui,
nós conseguimos usar o comando "ls",
-
que serve para listarmos os arquivos
de um diretório atual.
-
Só que novamente,
quando a gente executa,
-
não tem nada,
porque aquela pasta é oculta.
-
Se nós quisermos usar o comando "ls"
para listar os arquivos ocultos,
-
nós precisamos passar a flag "LA"
no final do comando.
-
Veja só.
-
"ls -la".
-
E agora sim,
a gente consegue ver a pasta Git.
-
Ter uma pasta git
dentro de uma pasta
-
indica basicamente que aquela pasta
trata-se de um repositório.
-
Se você tem o repositório
e a pasta git não está lá,
-
provavelmente tem algo errado.
-
E é muito importante que você
não apague essa pasta por acidente.
-
Se você fizer isso,
perderá todo o track de histórico
-
que você tem naquela aplicação.
-
Então, vamos lá.
-
Agora que temos
um repositório em mãos,
-
vamos usar o comando "clear"
e adicionar o nosso primeiro arquivo.
-
Vamos usar o próprio terminal
para criar um arquivo
-
chamado "página.txt".
-
Será apenas um arquivo de texto,
-
mas vamos simular uma criação
de uma página de verdade.
-
Então, vamos escrever o comando
"touch página.txt".
-
Se voltarmos no Windows Explorer
nós veremos que o arquivo foi criado,
-
então, vamos usar o Notepad
-
para colocar algum conteúdo
lá dentro.
-
Eu vou vir aqui e vou colocar
"minha página" e salvar esse arquivo.
-
A partir desse momento,
um arquivo novo foi criado,
-
então eu posso usar o comando
"git status"
-
para entender o que mudou aqui
dentro do meu repositório,
-
"git status"
eu consigo ter algumas informações.
-
Repare aqui,
-
que eu ainda não tenho
nenhum commit, ou seja,
-
o meu repositório está vazio
-
e não há nenhum histórico
antes do momento atual.
-
E aqui eu tenho a seção
de "untracked files"
-
e dentro dela, em vermelho,
eu tenho o arquivo "página.txt"
-
que eu acabei de criar.
-
Isso significa que o Git entendeu
-
que um novo arquivo apareceu aqui,
-
mas ele ainda não fará nada
a respeito desse arquivo.
-
A gente comentou que existem pontos
na história que são commits
-
e são eles que de fato
marcam as alterações que eu fiz
-
ao longo do tempo.
-
Mas para que eu consiga adicionar
esse arquivo
-
e a minha alteração
dentro de um novo commit,
-
eu preciso mover esse arquivo
para um outro estado chamado stage.
-
E para fazer isso,
a gente usa o comando "git add".
-
Vamos ver.
-
Vamos usar o comando "git add"
e informar o caminho do nosso arquivo
-
"página.txt" para que ele entre
nesse novo estado.
-
Então,
"git add página.txt".
-
Pronto.
-
Não temos nenhum feedback visual,
-
mas se nós executarmos
o comando "git status"
-
para entender o que mudou,
nós veremos algo interessante.
-
"git status".
-
Vemos que dessa vez
a gente ainda não tem nenhum commit,
-
mas o nosso arquivo "página.txt"
está em verde
-
e o git já o identificou
como um novo arquivo.
-
A partir desse momento,
-
nós conseguimos
criar o nosso primeiro commit
-
descrevendo o que a gente fez aqui.
-
Como nessa nossa primeira
implementação,
-
nós basicamente adicionamos
uma página, digamos,
-
a página principal.
-
É isso que nós colocaremos
como descrição no nosso commit.
-
E para, de fato, fazer o commit,
vamos usar o comando "git commit"
-
e essa mensagem vem
no parâmetro "-m".
-
Vamos ver.
-
"git commit -m "adicionando
página principal"".
-
E assim que eu dei enter,
-
o git dessa vez retorna
um feedback visual para a gente,
-
informando algumas coisas.
-
A primeira delas é a branch
em que eu estou.
-
Falaremos mais sobre isso no futuro.
-
Um hash que é o ID único
desse commit ao longo do tempo
-
e a minha informação,
a minha descrição que eu associei
-
com esse commit, ou seja,
-
uma descrição breve do que eu
implementei naquela mudança.
-
E aqui embaixo
nós conseguimos ver também
-
os arquivos que foram alterados,
-
que compõe de fato
esse ponto na história.
-
Então,
se nós limparmos o terminal
-
e executarmos novamente
o "git status",
-
nós veremos que não tem
nada de modificado
-
dentro da nossa "working tree"
ou da nossa árvore de trabalho.
-
O que vamos fazer agora é entender
-
como nós conseguimos ver o conteúdo
que compõe uma alteração atual.
-
Ou seja,
imagine que nós estamos adicionando
-
uma nova funcionalidade,
como, por exemplo,
-
um carrinho de compras.
-
Imagine que antes de fato
criar o commit
-
e registrar as minhas alterações
na linha do tempo do meu repositório,
-
eu desejo entender os arquivos
que foram alterados
-
ou por exemplo,
o conteúdo deles.
-
Vamos ver como a gente
consegue fazer isso agora.
-
Dessa vez então,
vamos usar o Windows Explorer
-
para criar um novo arquivo
chamado "carrinho.txt".
-
A ideia é a mesma.
-
Vamos usar aqui o botão direito
"novo", "carrinho".
-
E dessa vez vamos editar aqui
o conteúdo do arquivo para conter
-
"meu carrinho de compras".
-
Repare que o arquivo foi salvo.
-
Eu posso fechar e novamente
voltar para o meu terminal
-
para poder executar
os comandos do Git.
-
Executando o "git status",
eu consigo ver que o arquivo
-
"carrinho.txt" foi adicionado,
-
mas ele ainda não está
no controle de versão do Git,
-
Então,
vamos usar o comando "git add"
-
para que o Git consiga ler
as mudanças que eu fiz nesse arquivo.
-
Vamos lá.
-
"git add carrinho.txt".
-
Vamos limpar o terminal
e usar o "git log"
-
para recuperar
o histórico de commits.
-
Repare que aqui nós temos o nome
de quem fez esse commit,
-
o e-mail,
a data em que esse commit aconteceu
-
e a descrição que eu coloquei.
-
Mas também muito importante,
a gente tem um hash
-
que é um código único
gerado para cada commit
-
ao longo do tempo.
-
Com esse hash,
conseguimos fazer várias operações,
-
como por exemplo,
voltar no tempo para ver o conteúdo
-
que estava naquela época
e entre outras tarefas.
-
Dessa vez, a gente vai usar
esse hash para comparar
-
o que mudou dele com o código
que nós temos atualmente
-
no nosso repositório.
-
E para fazer isso,
a gente usa o comando "git diff".
-
Vamos ver como isso funciona.
-
Vamos executar o comando "git diff"
-
e informar o hash do commit anterior
que a gente fez.
-
Então,
eu vou vir aqui em cima,
-
copiar e então colar
e dar enter.
-
Pronto.
-
Agora nós temos um resumo bem claro,
-
tanto dos arquivos
que foram alterados,
-
mas dos conteúdos novos
que foram adicionados nele.
-
E a partir desse momento,
se nós estivermos de acordo,
-
podemos fazer um novo commit
e enfim colocar essa nossa alteração
-
dentro do histórico.
-
Vamos então escrever novamente
um commit,
-
só que com uma outra mensagem
informando que o carrinho de compra
-
está sendo adicionado.
-
Então para isso,
"git commit - m"
-
"adicionando carrinho de compras"
-
e pronto.
-
Se nós executarmos o git status
mais uma vez,
-
veremos que a nossa árvore
de trabalho está limpa
-
e executando o git log,
-
nós conseguimos ver que agora
há dois commits no nosso histórico.
-
O primeiro,
adicionando a página inicial
-
e o segundo
adicionando o carrinho de compras.
-
Incrível, não é mesmo?
-
A gente acabou de ver
como podemos usar o Git para, de fato,
-
criar um versionamento semântico
para o nosso repositório
-
e acompanhar ao longo do tempo
que foi alterado.
-
Então, a partir de agora,
você não precisa mais recorrer a criar
-
V1, V2 ou qualquer outra estratégia
mirabolante
-
para fazer um controle de versão
-
e entender de forma clara
o que foi alterado no seu projeto.
