DEV Community

Cover image for [Tutorial] Aprendendo sobre versionamento de código com Git
Kauê Cavalcante
Kauê Cavalcante

Posted on • Updated on

[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:

Criação de diretório e inicialização do git

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

Dev Environment

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.

Arquivo criado no VSCode

Ó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:

Git status

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.

Git add schema

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:

Git add example

Codigo apos add

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.

Git commit schema

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

Git status após o add

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

Git commit command line

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.

Novo arquivo criadoGit status após novo arquivo criado

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

Arquivo após ser movido para a Staging AreaArquivo após ser movido para a Staging Area - VSCode

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.

Git restore command line

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.

Arquivo após ser removido da Staging Area

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:

Git log command line

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:

Adicionando e commitando novo arquivo

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

Git log atualizado

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

Git reset command line

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:

Git log atualizado após desfazer último commit

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.

Git log

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

Git commit --amend command lineGit log após commit renomeado

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:

Git rm

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:

Arquivo modificado

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

Git stash command lineVSCode após 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:

Git stash list command line

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

Git stash apply command lineVSCode após git stash apply

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.

Top comments (2)

Collapse
 
rogeriosilvaifpi profile image
Rogério Silva

Great job!

Collapse
 
kauecdev profile image
Kauê Cavalcante

Thank you!