Introdução ao controle de versão com Git

Inicialmente, podemos entender o controle de versão como um sistema para podermos controlar projetos conforme o tempo e recuperarmos versões anteriores, caso necessário. O Git, por sua vez, é um sistema de controle de versão.

Para começar…

Antes de começar a utilizar o controle de versão na prática, precisamos abordar o tópico branches, base de nosso versionamento.

O controle de versão é baseado em branches, normalmente havendo uma branch “master” para a versão “em produção” do sistema (em seus projetos você pode entender ela como a branch que possui a versão estável do seu sistema, normalmente com menor número de erros e bugs).

Fluxo de branches — Exemplo

No exemplo da imagem: há uma branch master (common base) que possui determinadas informações nela. Daí, é feita uma cópia de tudo que está contido nesse projeto para uma nova branch (feature tip, em verde), onde serão aplicadas modificações para uma nova feature da aplicação, por exemplo.

Qual vantagem ganhamos com isso? Caso aconteça algum problema com a nova implementação, não temos problemas, pois podemos simplesmente descartar essa branch e ainda teremos a versão anterior às modificações na branch não modificada (master tip).

Contudo, se a implementação for um sucesso poderemos incrementar nossas modificações na branch master, por meio de um merge (ainda vou falar disso).

Entendendo isso, podemos começar a aplicar:

Vou manter todos os exemplos em Java pois é a primeira linguagem de muitos, especialmente os que não tiveram contato com programação antes da faculdade.

Iniciaremos criando uma pasta em nosso sistema. Depois disso, abriremos o terminal nesse diretório (para fazer isso você pode clicar no botão direito do mouse e a opção de “Abrir no terminal” ou algo semelhante deve aparecer):

Primeiro, você precisa ter o git instalado. Você pode verificar se tem executando o comando git --version no terminal.

Caso não tenha, você pode obtê-lo:

  • Em distribuições linux baseadas no Debian (como o Ubuntu), executando o comando: apt-get install git
  • No windows: https://gitforwindows.org/

Depois de instalar, execute o comando de verificação da versão para conferir se a instalação aconteceu corretamente.

Com o terminal aberto, para iniciar o controle de versão precisamos somente digitar o comando git init.

Ele iniciará o controle de versão e automaticamente será criada a branch master.

Agora, você pode ir até sua IDE de preferência e criar um novo projeto no diretório em que você iniciou o controle de versão:

Então, crie a classe Conta e implemente o código a seguir:

public class Conta {
double salario;
    public void saca(double valor) {
// implementação...
}
}

Salve e experimente voltar ao seu terminal e executar o comando git status, ele mostrará as alterações que aconteceram na branch atual desde o último commit. Como já temos o que queremos, vamos agora implementar de fato essas mudanças na branch.

O comando git add . vai colocar todos os arquivos atuais em staging, uma etapa anterior ao commit. Depois, executando o comando git commit -m “Implementação da classe Conta” você terá feito um commit na branch master.

Ou seja, você terá aplicado suas mudanças na branch master com uma mensagem “Implementação da classe Conta” (essa mensagem não afeta seu projeto, mas ela é útil quando queremos analisar o histórico de commits).

Fazendo modificações, utilizando novas branches

Na branch master temos o projeto com uma classe Conta, com o método saca(). Agora, suponha que queremos implementar um método para depósitos na classe Conta, sendo assim, criaremos outra branch e trabalharemos nisso.

Usaremos o comando git checkout -b feature-deposita para criarmos a branch em que faremos a implementação do método.

Agora, iremos até nossa classe e implementaremos o método.

public class Conta {
double salario;
    public void saca(double valor) {
// implementação...
}
    public void deposita(double valor) {
// implementação...
}
}

Feito isso, precisamos fazer o commit de nossas alterações:

Agora, temos a seguinte estrutura:

Precisamos agora adicionar as mudanças existentes na branch feature-deposita na branch master. Para isso, estando na branch master (você pode ir até ela usando git checkout master) utilizaremos o comando a seguir para fazer o merge:

Assim, teremos a seguinte estrutura:

Então, podemos deletar a branch feature-deposita:

Trabalhando com repositórios remotos

No exemplo, trabalharei com o Github, mas, é bom frizar que existem diversos outros: Gitlab e Bitbucket, por exemplo.

Primeiramente, precisamos criar um repositório. Para isso, basta clicar nesse ícone no canto superior direito no site do Github e, em seguida, em "Novo repositório". Dê um nome para ele e depois clique em "Criar repositório".

Perceba que, ao criar o repositório, o Github dá algumas instruções sobre como proceder. Seguiremos as instruções do bloco …or push an existing repository from the command line. Agora, no terminal, dentro do diretório de seu projeto, execute o primeiro comando.

Você pode conferir se tudo ocorreu corretamente com git remote -v:

Agora, vamos fazer um push de nossa branch master para o Github. Ou seja, vamos enviar a informação contida localmente para o nosso repositório remoto.

Perceba que utilizamos um -u, isso para que obtenhamos o retorno mostrado na última linha da imagem acima. Isto é, como é a primeira vez que estamos fazendo um push para o repositório remoto, precisamos estabelecer uma conexão da branch com ele.

Se, por acaso, precisássemos fazer outro push dessa branch para o repositório remoto, somente o comando git push seria o suficiente (talvez dependesse da adição de-f).

Finalizando…

Abordei o básico do controle de versão e repositórios remotos, ainda há muito mais, mas isso deve ser o suficiente para introduzi-lô ao tópico e possibilitá-lo começar a implementar o controle de versão em seus projetos.