Introdução ao Git: Controle de Versões Simplificado

Se você é desenvolvedor(a) ou está começando na área de tecnologia, já deve ter ouvido falar em Git. Ele é a principal ferramenta para controle de versões, ajudando equipes e indivíduos a colaborarem em projetos de forma organizada e eficiente.

Neste post, vamos explorar os comandos básicos do Git e como usá-los para gerenciar seu código.

O que é Git?

O Git é um sistema de controle de versão distribuído que permite gerenciar, acompanhar e registrar todas as mudanças feitas em arquivos/códigos de um projeto. Ele é amplamente utilizado no desenvolvimento de software, mas pode ser aplicado a qualquer projeto que envolva a manipulação de arquivos.

Principais características do Git

Controle de versão distribuído: Diferente de sistemas centralizados, cada cópia de um repositório Git contém todo o histórico do projeto. Isso permite trabalhar offline e sincronizar as alterações posteriormente.

Histórico de alterações: O Git armazena um registro detalhado de todas as mudanças realizadas, permitindo a recuperação de versões anteriores e facilitando a identificação de quem fez cada alteração.

Facilidade de colaboração: Equipes podem trabalhar simultaneamente no mesmo projeto, sincronizando suas mudanças sem conflitos ou perda de dados.

Qual a diferença de Git e GitHub?

O Git é uma ferramenta para controle de versões (local), enquanto o GitHub é uma Plataforma que hospeda repositórios Git (online) e facilita a colaboração.

O que você aprenderá?

Neste post, você aprenderá como utilizar o Git para gerenciar e versionar seus projetos de forma eficiente. Vamos abordar os comandos essenciais, desde a configuração inicial até o uso de branches, commits e merge. Ao final, você estará pronto para organizar suas alterações, colaborar com equipes e manter o controle do histórico do seu código de maneira simples e eficaz.

Instalando o Git

Antes de começar, realize a instalação do Git em seu dispositivo.

Para sistemas Linux (Debian, Ubuntu, etc…), basta digitar o seguinte comando:

sudo apt install git

Para Windows, use o seguinte link para realizar o download do Git:

https://git-scm.com/downloads/win

Durante a instalação, recomendo habilitar o Git Bash como terminal padrão do sistema. O Git Bash fornece um ambiente semelhante ao do Linux no Windows, com comandos que facilitam o uso do Git e outras tarefas de desenvolvimento.

Por fim, para confirmar se o Git foi instalado corretamente tanto no Windows quanto no Linux, basta digitar o seguinte comando no Git Bash:

git --version

Caso o Git tenha sido instalado corretamente, ao digitar esse comando, será exibida a versão instalada no seu dispositivo, como mostrado na imagem abaixo:

Configurando o Git pela Primeira Vez

Agora, vamos configurar seu nome e e-mail no Git. Eles serão usados para identificar seus commits.

git config --global user.name "Seu Nome"  

git config --global user.email "seu.email@exemplo.com"  

Para verificar se tudo está configurado corretamente:

git config --global --list  

Por padrão, é recomendável nomear a branch principal como main. Para isso, vamos configurar o Git para que, sempre que você iniciar um novo repositório, a branch principal criada seja chamada de main.

git config --global init.defaultBranch main

Agora, você pode iniciar seu repositório local com o comando git init. Esse comando criará um diretório oculto chamado .git dentro do diretório escolhido, onde o Git armazenará todos os dados e informações de versionamento do seu projeto. A partir daí, você poderá adicionar arquivos, realizar commits e começar a acompanhar a evolução do seu código, mantendo um histórico completo e organizado das alterações feitas.

git init

Adicionando Arquivos ao Controle de Versão

Para começar a versionar um arquivo, é necessário adicioná-lo à área de staging (ou área de preparação). A área de staging funciona como uma zona intermediária no Git, onde você organiza e seleciona as alterações que serão incluídas no próximo commit.

Vamos iniciar criando um arquivo Python para adicionarmos à área de staging. Para isso, digite o seguinte comando:

nano meu_codigo.py

O nano é um editor de texto que já vem integrado ao Git Bash. Com ele, podemos criar e editar arquivos diretamente pelo terminal. No exemplo acima, estamos criando um novo arquivo chamado meu_codigo.py.

Ao executar o comando, o editor será aberto no próprio terminal, permitindo que você escreva o conteúdo do arquivo. Para não deixá-lo vazio, vamos fazer um print em python da famosa frase “Hello World!”. Para isso, digite a seguinte linha de código em Python:

print("Hello World!")

Para salvar o arquivo, pressione:

Ctrl + O e, em seguida, ENTER para confirmar.

Depois, pressione Ctrl + X para sair do editor.

Pronto! Seu código Python foi salvo em seu diretório e já está pronto para ser adicionado à área de staging do Git.

Basta digitar o seguinte comando:

Adicionar um arquivo da área staged

git add nome_arquivo.py

Ao adicionar seu arquivo à área de staging, você não o remove do diretório de trabalho, mas indica ao Git que ele está pronto para ser incluído no próximo commit. Em outras palavras, você está preparando esse arquivo para ser registrado no histórico do repositório.

Veja, na imagem abaixo, uma ilustração desse processo:

Imagem retirada do repositório do Git: https://git-scm.com/about/staging-area

Caso deseje remover esse arquivo da área de staging, basta digitar o seguinte comando:

Remover um arquivo da área staged

git rm --cached nome_arquivo.py

Dessa forma, você pode adicionar ou remover diferentes arquivos do seu diretório na área de staging. Lembre-se: todos os arquivos que estiverem nessa área serão salvos pelo Git quando o commit for executado.

Criando um Commit

Após adicionar os arquivos à área de staging usando o comando git add, o próximo passo é salvar essas alterações no histórico do Git através de um commit.

O commit cria um registro permanente do estado atual dos arquivos na área de staging, incorporando essas modificações ao histórico do repositório e permitindo o rastreamento detalhado da evolução do projeto.

No caso do arquivo meu_codigo.py, após adicioná-lo à área de staging, vamos criar um commit para garantir que suas alterações sejam registradas de forma definitiva pelo Git.

Para isso, basta digitar o seguinte comando:

Criar um commit

git commit -m "Meu primeiro commit com mensagem Hello World"

Caso queira editar a mensagem do seu último commit, basta digitar o comando a seguir:

Editar a mensagem do último commit

git commit --amend -m "Meu primeiro commit com mensagem Hello World escrita em Python"

Veja, na imagem abaixo, uma ilustração desse processo:

Imagem retirada do repositório do Git: https://git-scm.com/about/staging-area

Com isso, você conclui o processo de versionamento das alterações realizadas. O arquivo meu_codigo.py passa a fazer parte do histórico do repositório, permitindo que o Git identifique com precisão o que foi modificado, quando e por quem. A partir desse ponto, qualquer nova mudança poderá ser rastreada, revertida ou comparada com versões anteriores, garantindo controle total sobre a evolução do projeto.

Monitorando o Repositório

Monitorar um repositório é fundamental para garantir que o projeto esteja sempre organizado e sob controle. Com os comandos certos, você pode verificar o status dos arquivos, revisar o histórico de commits e identificar mudanças realizadas ao longo do tempo.

Verificar o status dos arquivos

Este comando é usado para monitorar o estado atual do repositório. Ele fornece um resumo das alterações feitas nos arquivos, informando: quais arquivos foram modificados, adicionados ou removidos, quais arquivos estão na área de staging prontos para serem comitados e sugestões de próximos comandos que podem ser utilizados.

No nosso exemplo, após o commit do arquivo meu_codigo.py, veremos o status:

git status

Isso significa que estamos na branch main, não há alterações pendentes para serem salvas (nenhum arquivo modificado, adicionado ou removido) e a pasta de trabalho do projeto está limpa, ou seja, idêntica ao último commit feito.

Revisar o histórico de commits

O comando git log exibe o histórico de commits do repositório, mostrando todas as alterações feitas ao longo do tempo. Ele apresenta informações importantes como: o ID de cada commit, o autor e a data do commit e a mensagem descritiva fornecida no momento do commit.

git log

Assim, você consegue acompanhar de forma clara e detalhada todas as alterações realizadas no repositório, identificar quem fez cada modificação e quando ela ocorreu, além de manter o controle sobre a evolução do projeto. O uso consistente desses comandos garante que seu repositório esteja sempre organizado, facilita a colaboração com outros desenvolvedores e permite tomar decisões mais seguras ao gerenciar versões do código.

Conclusão

O Git é uma ferramenta indispensável para quem deseja manter o controle e a organização no desenvolvimento de software, seja individualmente ou em equipes. Com sua capacidade de registrar mudanças de forma eficiente, gerenciar versões paralelas e permitir a colaboração entre vários desenvolvedores, ele oferece um nível de flexibilidade e segurança que facilita o desenvolvimento de projetos.

Ao dominar os comandos básicos que discutimos neste post, você estará preparado para aproveitar ao máximo o Git e dar os primeiros passos para se tornar mais produtivo e colaborativo no seu trabalho com código.