[Tutorial] Aprendendo sobre versionamento de código com Git

O Git é uma ferramenta que não pode faltar no cinto de utilidades de um desenvolvedor, principalmente quando se produz código em grupo.

Segundo a própria Wikipédia: "Git é um sistema de controle de versões distribuído", ou seja, é ele quem irá auxiliar no gerenciamento das diferentes versões que um projeto pode ter e facilitar o time a integrar seus códigos sem o perigo de um sobrescrever o trabalho do outro.

Então se você quer aprender a utilizar esta poderosa ferramenta, continue descendo e aproveite a leitura!

Iniciando os conceitos básicos - git init

Vamos começar criando um novo diretório e iniciando o git no mesmo. Para iniciar o git no seu diretório, utilize o comando git init, como mostrado a seguir:

Perfeito! Agora com o diretório criado e o git inicializado, vamos entender alguns conceitos. Para isso, considere a imagem a seguir:

Essa é a representação do seu ambiente de desenvolvimento local. Nele você tem o seu diretório de trabalho (Working Directory), a Staging Area e o Local Repository. A Staging Area recebe este nome pois é justamente o local onde os arquivos irão ficar "se preparando" antes de irem para o Local Repository, que por sua vez, é o local de armazenamento onde o git gerencia as versões do seu código.

Verificando status - git status

Agora vamos abrir um editor de código e criar um novo arquivo.

Ótimo! Agora com nosso novo arquivo criado, vamos aprender nosso próximo comando git, o git status. Ele serve para nos dar um pequeno relatório sobre a situação dos arquivos no nosso diretório. Veja um exemplo:

Adicionando arquivos na Staging Area - git add

Como podemos ver na saída do comando anterior, temos um arquivo que não foi 'trackeado', ou seja, o git não está monitorando-o. Isso quer dizer que o git não irá guardar informações sobre as alterações desse arquivo. Para mudar isso, precisamos movê-lo para a Staging Area, onde ele ficará esperando para ser lançado numa versão do nosso projeto. Para fazer isso, utilizaremos o comando git add.

Podemos utilizar esse comando de duas formas: com o nome do(s) arquivo(s) específicos após o comando ou utilizando um '.' para sinalizar que queremos adicionar todos os arquivos com modificações. Veja a seguir:

Como você pode ver, o VS Code também detectou as alterações que fizemos. Agora, invés do 'U' ao lado do nosso arquivo, agora temos um 'A', sinalizando que o arquivo foi movido para a Staging Area.

Salvando nosso trabalho no Local Repository - git commit

O nosso arquivo na Staging Area está pronto para ser salvo no nosso Local Repository. Para isso, precisamos 'commitar' nosso código, isto é, salvar o estado dos arquivos da Staging Area no nosso Local Repository, gerando um commit que armazenará essas informações. Utilizaremos o comando git commit.

Se checarmos o status do git, veremos que a mensagem mudou:

Agora ele nos informa que temos arquivos a serem commitados e é exatamente o que faremos agora.

Todo commit precisa de uma mensagem. Geralmente ela deve ser uma pequena descrição do trabalho que foi commitado. Existem diversos padrões de commit e podemos falar deles em outro momento.

Como podemos ver também, ele nos retorna algumas informações a respeito do commit criado.

Perfeito, agora nosso trabalho está salvo no nosso Local Repository.

Removendo arquivos da Staging Area - git restore

Em algum momento, podemos querer remover alguma mudança que adicionamos na Staging Area. Para isso, podemos utilizar o comando git restore, que irá remover o arquivo da Staging Area. Para demonstrar isso, criaremos um novo arquivo.

Perfeito, agora temos um novo arquivo no nosso Working Directory. Vamos movê-lo para a Staging Area.

Note que o próprio git nos auxilia ao informar como podemos retirar algum arquivo da Staging Area. Precisaremos do comando git restore juntamente com a flag --staged.

Como podemos ver, após utilizar o comando, a mensagem exibida pelo git status é a mesma de quando criamos o arquivo, e caso verifiquemos o nosso arquivo no VS Code, ele continua o mesmo, a única diferença é que retornou ao status de untracked.

Lendo o histórico de commits - git log

Caso você queira verificar o histórico dos commits no seu projeto, você pode utilizar o comando git log. Ele exibirá uma lista com os commits, bem como algumas informações sobre cada um deles. Vamos lá testar:

Como você pode ver, temos informações como o nome do autor do commit, o hash (que é um código aleatório único para identificar aquele commit), a data de criação e sua mensagem.

No topo, podemos também ver a mensagem HEAD. Isso significa que esse commit foi o último a ser realizado, ou seja, está no topo (na cabeça) do histórico do nosso projeto.

Revertendo o último commit - git reset

Vamos supor que você commitou algum arquivo que não estivesse completo ou com alguns bugs e agora precisa desfazer seu último commit. Nessa situação, você pode utilizar o comando git reset. Para demonstrar o uso, vamos novamente adicionar o nosso novo arquivo na Staging Area e então fazer o commit:

Agora, se verificarmos o histórico, veremos que o novo commit está no topo:

Certo, agora é hora de desfazermos nosso último commit:

Como podemos ver, o nosso arquivo voltou ao seu estado de untracked, o que significa que o nosso commit foi desfeito. Para ter certeza, vamos checar o log:

Voalá! O nosso commit não está mais lá.

Renomeando commits - flag --amend

Vamos supor que na hora de nomear o seu commit você acabou digitando algo errado da qual não percebeu, como você faria para renomear seu último commit?

Felizmente, o git nos oferece essa opção também e de maneira bem simples. Tudo o que você precisará fazer é novamente utilizar o
git commit, mas dessa vez, com uma flag chamada --amend. Ela permitirá que você dê um novo nome para seu último commit. Vamos ver na prática.

Como podemos ver, o nosso último commit ainda está como antes. Vamos renomeá-lo:

Como podemos ver pelo git log, a mensagem do último commit foi editada com sucesso!

Removendo arquivos do git - git rm

Bom, mas e se quisermos remover de vez um arquivo do nosso sistema de versionamento? Simples: utilizamos o comano git rm.

Vamos remover o arquivo que commitamos:

Como podemos ver, na mensagem retornada pelo git status, o arquivo foi deletado. Para confirmar a remoção precisamos fazer o commit, assim salvando um novo state onde o arquivo é removido do versionamento. Como eu não desejo executar a remoção, vou somente reverter o processo utilizando o comando git restore --staged e em seguida o git restore para reverter as alterações e voltar ao estado inicial.

Salvando suas alterações sem commitar - git stash

O git nos oferece também a opção de salvarmos alterações no nosso código sem precisar fazer o commmit. O comando git stash nos permite salvar alterações de forma separada dos commits para utilizarmos em um momento futuro, caso desejemos.

Vamos começar modificando nosso arquivo já commitado:

Agora, com o arquivo alterado, vamos executar o stash:

Como podemos ver, inicialmente temos o git status nos informando que o arquivo havia sido alterado, em seguida, executamos o comando git stash push -m que nos permite associar uma mensagem ao nosso stash, assim como fazemos com os commits. Por fim, executamos novamente o git status e vemos que o diretório está limpo como se nada tivesse acontecido.

Vamos agora conferir a lista de stash para ter certeza de que nosso stash foi salvo. Utilizaremos o comando git stash list:

E aí está, o nosso stash salvo com sucesso. Agora vamos aplicar as alterações que salvamos nesse stash no nosso código novamente.

Prontinho, as alterações que havíamos salvo estão de volta no nosso diretório.

O git stash oferece outras opções como

• git stash: para fazer o stash sem passar uma mensagem.
• git stash show: para listar os arquivos modificados que foram salvos no último stash.
• git stash pop: para remover em forma de pilha (do mais recente para o mais antigo).
• git stash clear: para remover todos os stashs.

Comments

[Rogério Silva]

Great job!

[Kauê Cavalcante]

Thank you!