Tutorial Git: Primeiros passos no sistema de controle de versões

O desenvolvimento colaborativo de softwares não ocorre apenas internamente, em empresas privadas. Comunidades de código aberto, com centenas ou milhares de voluntários (dependendo do tamanho do projeto), se encarregam da manutenção, otimização, desenvolvimento e modificação de softwares “públicos”. Projetos assim seriam inviáveis sem um sistema de gerenciamento, responsável por registrar todas as mudanças feitas por diferentes programadores.

Uma das soluções mais populares para gerenciar versões de programas é o Git, por ser gratuito e fácil de usar. Nosso tutorial Git apresenta todos os recursos básicos deste sistema de gerenciamento de software, para que você comece a utilizá-lo com confiança.

O que é Git?

Git é um sistema de controle de versões desenvolvido pelo criador do Linux, Linus Thorvalds. Lançado em 2005, ele funciona sob a licença gratuita GNU GPLv2. No Git, embora cada projeto tenha um repositório central, todos os usuários envolvidos em um desenvolvimento fazem download de uma cópia do diretório localmente, no dispositivo próprio.

Cada cópia funciona como um backup completo do repositório, o que significa que desenvolvedores não precisam ficar o tempo todo conectados e podem trabalhar off-line. Além disso, essas cópias podem ser usadas para restaurar projetos, caso o repositório principal apresente falhas ou seja danificado. Alterações podem ser compartilhadas com todos os demais membros de um projeto a qualquer momento, e também incluídas no repositório central, quando necessário.

Como instalar o Git?

Quem deseja aprender a gerenciar projetos de softwares com o Git precisa se familiarizar com ele primeiro. O Git está disponível para Windows, Unix/Linux e macOS, mas apresenta pequenas diferenças em cada plataforma. Após instalar a versão correta para o seu sistema operacional, você conseguirá controlar a solução de forma independente, usando linha de comando ou a interface gráfica do usuário.

Arquivos de instalação binários, guias para instalação de gerenciadores de pacotes (sistemas Unix) e edições portáteis prontas para uso estão disponíveis para diferentes sistemas operacionais no site oficial do projeto Git. Faça o download do pacote adequado ou use a opção correspondente no gerenciador de pacotes. Depois, siga as instruções do assistente de instalação. Se você optar pela edição portátil, o processo de instalação não precisará ser executado.

Tutorial Git passo a passo

Depois de instalar o Git no seu dispositivo, você poderá usar o sistema de controle de versões para gerenciar seus projetos de software. Assim como com qualquer outra ferramenta, você terá de aprender os principais comandos e funções do Git para aproveitar ao máximo suas possibilidades. Por isso, nosso tutorial Git ensinará você a configurar o Git e apresentará as principais instruções de linha de comando, para facilitar a criação e a manutenção de repositórios.

Crie ou clone um repositório Git

O repositório Git é o diretório central de um projeto, assim como o principal ponto de encontro entre todos os usuários que participam do desenvolvimento dele. É a partir do repositório que o gerenciamento completo de versões é realizado. Por isso, sua primeira tarefa no nosso tutorial Git será criar um repositório central. Se você já estiver participando de um projeto de desenvolvimento colaborativo gerenciado com o Git, poderá clonar o repositório central (em forma de cópia de trabalho).

Se quiser configurar o gerenciador de versões ou instalar ferramentas para aprender a trabalhar com o Git, você precisará criar um novo repositório. Para fazer isso, alterne para o repositório local desejado no seu dispositivo, usando o comando cd (change directory):

cd caminho para diretório desejado

Depois, execute o comando abaixo para gerar um repositório Git:

git init

Se o repositório Git do seu projeto já existir, você só precisará do endereço web ou do endereço de rede dele para criar uma cópia de trabalho no seu computador. Para isso, use o comando git clone:

git clone https://um-teste.site/repositorio-git

Verifique o status do repositório e adicione novos arquivos para controlar versões

Organização eficiente do repositório de trabalho é um dos pilares mais importantes do Git. A solução permite que você proponha alterações e adições a um projeto, para que sejam adotadas como “commits”, e também que acesse informações sobre ajustes feitos por outros usuários. Você pode verificar o status atual da sua cópia de trabalho executando o seguinte comando:

git status

No caso de um repositório recém-criado, ou se o repositório central e sua cópia de trabalho forem idênticas, você receberá uma mensagem informando que não há novas alterações no projeto (“No commits yet”). Além disso, o Git avisará que você ainda não enviou nenhuma alteração para o próximo commit (“nothing to commit”).

Para adicionar um novo arquivo ao gerenciamento de versões ou enviar um arquivo revisado para o próximo commit, adicione o comando git add ao arquivo em questão (ele deve estar contido no repositório de trabalho). Nosso tutorial Git adicionará um arquivo de texto chamado “Test”, como exemplo:

git add Test.txt

Se você realizar uma verificação de status do repositório novamente, o arquivo do exemplo será apontado como potencial candidato à próxima atualização oficial do projeto (“Changes to be committed”):

Confirme alterações por commit e inclua-as no HEAD

Todas as alterações que você envia ao gerenciador de versões (conforme descrito na seção anterior) precisam ser confirmadas por meio de um commit, para que sejam incluídas no HEAD. OHEADé um tipo de índice que se baseia no últimocommitefetivado pelo seu ambiente de trabalho atual no Git (também chamado debranch). Use o comando a seguir neste passo:

git commit

Depois de executar o comando, o Git iniciará automaticamente o editor que você selecionou durante o processo de instalação, ou o editor padrão do sistema de gerenciamento de versões. Neste momento, você poderá adicionar um comentário ao commit planejado. As linhas incluídas, separadas por ponto e vírgula, não serão exibidas posteriormente. Assim que você fechar o editor, o Git criará o commit:

Como é possível observar na captura de tela, você receberá um resumo sobre o commit depois de executar o comando git commit. Entre colchetes serão exibidos nome do branch(que, nesse caso, chama-semaster, já que nosso repositório de trabalho também é o repositório central) que adotou as alterações, esoma de verificação (checksum) SHA-1docommit(no caso,c0fdc90). Na sequência, o comentário escolhido (“Test”, no nosso exemplo) será exibido, assim como informações específicas sobre alterações feitas.

Edite ou reverta commits gerados

Caso você adote alterações na forma de commits, é possível editá-las e até removê-las. Por exemplo, edições podem ser necessárias caso você gere um commit antes da hora, esquecendo-se de arquivos ou ajustes importantes. Neste caso, você deverá fornecer arquivos novos ou editados retroativamente, usando o comando git add, e repetir sua entrada no repositório central. Para fazer isso, adicione o trecho --amend ao comando padrão:

git commit --amend

No entanto, se você deseja retirar o commit mais recente, deverá usar o seguinte comando:

git reset --soft HEAD~1

Ele reverterá o último commit incluído no HEAD. Os arquivos nele contidos serão revertidos ao status de alterações planejadas (“Planned changes for the next commit”). Para excluir permanentemente os arquivos, insira o comando abaixo:

git reset --hard HEAD~1

Acesse o histórico de commits

Vale a pena aprender a gerenciar projetos com o Git, justamente por causa de seus recursos de versionamento. Uma das grandes vantagens deste sistema de código aberto é que você consegue visualizar as últimas alterações feitas no repositório. Para fazer isso, execute o seguinte comando:

git log

O comando git log lista os commits gerados em ordem cronológica inversa e exibe, por padrão, a verificação de soma SHA-1, o autor (nome e endereço de e-mail) e a data do commit. Além disso, oscomentários também podem ser visualizados, fornecendo a você e aos demais usuários informações importantes sobre cada uma das alterações.

Você já aprendeu, com este tutorial Git, a gerar um commit simples, com o comentário “Test”. Essas informações serão apresentadas da seguinte forma:

O comando log também pode ser modificado por diversos parâmetros. A tabela a seguir apresenta algumas opções úteis:

Inclua commits no repositório central

Com este tutorial Git você já aprendeu como salvar alterações como um commit no HEAD do repositório local. No entanto, para que o commit seja incluído no repositório central, mais um passo deve ser tomado. Insira o comando a seguir:

git push origin master

O Git adicionará automaticamente todos os commits gerados ao master, nome do repositório central — antes eles só existiam na sua cópia de trabalho. Se você substituir a palavra “master” no código acima pelo nome de outro branch, os arquivos serão enviados a ele.

Tagging: Cria, exclua e liste tags no Git

Assim como outros sistemas de controle de versões, o Git oferece um recurso de tagging que permite marcar como importantes, pontos selecionados no histórico de um repositório. Essas tags costumam ser usadas para sinalizar lançamentos de um software (por exemplo, versão 1.0, 2.0, 3.0 e assim por diante), para que elas sejam facilmente acessadas, principalmente em projetos maiores. O Git suporta dois tipos de tags:

• Tags “anotadas”: Salvas como objetos independentes no banco de dados. Incluem soma de verificação própria, mensagem de tagging, data, nome e endereço de e-mail do autor, bem como assinatura GNU Privacy Guard (GPG) opcional.
• Tags “leves”: Agem como branches e servem apenas como referência para um commit. Adequadas para marcações temporárias ou quando não se deseja salvar informações adicionais.

Você pode criar tags “anotadas” no Git usando o comando git tag -a no respectivo commit. Ao adicionar o parâmetro -m como sufixo, você poderá escrever a mensagem de taggingque quiser, diretamente na linha de comando (entre aspas retas). Neste tutorial Git, geramos ocommit“Test” e vamos vinculá-lo a umatagcom a mensagem “tag de exemplo”:

git tag -a Test -m "tag de exemplo"

Ao criar tags “leves”, você utilizará abordagem similar. No entanto, só será preciso usar o comando básico git tag, sem a adição de qualquer outro parâmetro ao commit desejado. Nosso tutorial Git utilizará este comando da seguinte forma:

git tag Test

Se houver tags no seu repositório, você poderá exibi-las com o comando git tag e os parâmetros opcionais -l e --list:

git tag
git tag -l
git tag --list

Para excluir uma tag do repositório de trabalho local, use a cadeia de comandos git tag -d. Assim excluímos nossa tag “Test”:

git tag -d Test

Tags precisam ser transferidas manualmente para o repositório central. Para fazer isso, informe o nome da tag e o comando git push origin. Em vez de digitar o nome da tag, você pode adicionar o parâmetro --tags, que transportará todas as tags geradas para o repositório.

git push origin --tags

Crie, gerencie e exclua branches

Branches usados neste tutorial Git correspondem a versões de trabalho individuais do repositório central. O repositório central, por sua vez, também é classificado como um branch, neste caso chamado de “master”. É por esses branches que o Git oferece a base perfeita para o desenvolvimento de funções e recursos isolados, combinando-os somente em estágios posteriores. Ao processo de combinação dá-se o nome de “merge” (mesclar).

É muito fácil criar um branchnovo. Você só precisa usar a instrução git branch e inserir o nome desejado. Para criar um exemplo debranchchamadotest_branch, insira o comando abaixo:

git branch test_branch

Depois, você poderá alternar para esse branch quando quiser, usando o comando git checkout:

git checkout test_branch

Se você quiser fazer merge em branches, use o comando git merge. Antes, insira o comando checkout, para alternar para o repositório que integrará o outro branch. Depois, execute o comando de merge, juntamente com o nome do branch a ser mesclado. No nosso tutorial Git, mesclaremos ao repositório central a versão de trabalho “test_branch”:

git checkout master
git merge test_branch

Depois de fazer o merge, você não precisará de determinados branches anteriores. Exclua-os, se for o caso. Para fazer isso, adicione o comando git branch -d ao branch a ser descartado. Nosso tutorial Git excluirá o exemplo “test_branch”, executando o comando a seguir:

git branch -d test_branch

Para efetuar um processo de exclusão de um branch, você necessariamente terá de estar em um branch diferente. É por esse motivo que alternaremos para o repositório central antes de executarmos o comando, conforme mostra a captura de tela abaixo: