O Git é um software de controle de versão distribuído, ele foi criado para verificar alterações no código fonte, no processo de desenvolvimento de software. Ele monitora um conjunto de arquivos, e checa se houve alguma modificação nestes arquivos. Se ocorrer alguma modificação nos arquivos, ele marca o arquivo para que as modificações possam ser registradas.

O Git funciona em um esquema de linha do tempo, onde se tem uma linha do tempo principal, a partir desta linha do tempo pode ser criado outras linhas que são os ramos . Estes ramos devem retornar para a linha do tempo principal para que o fluxo continue. A imagem abaixo demonstra bem isso.

Na imagem acima a linha vermelha representa a linha do tempo principal. No Git a linha do tempo principal é a branch master. As outras linhas verdes representam outras linhas do tempo, estas são outras branch que são criadas conforme o desenvolvimento de cada funcionalidade do projeto.

Git comandos

Após vermos um pouco do GIT na teoria, vou abordar alguns comandos úteis do GIT que são utilizados no dia a dia do desenvolvimento de software. Abaixo uma lista com alguns comandos do GIT.

Setar usuário:	git config –global user.name “Anderson Irias”
Setar email:	git config –global user.email contato@irias.com.br
Setar editor:	git config –global core.editor vim
Setar ferramenta de merge:	git config –global merge.tool vimdiff
Listar configurações:	git config –list
Criar novo repositório:	git init
Clonar um repositório:	git clone https://github.com/andersonirias/api-http-rest.git
Verificar estado dos arquivos:	git status
Adicionar arquivo/diretório (staged area):	git add meu_arquivo.txt
Comitar um arquivo:	git commit meu_arquivo.txt
Remover arquivo:	git rm meu_arquivo.txt
Exibir histórico:	git log
Desfazendo alteração local(Antes do commit):	git checkout — meu_arquivo.txt
Desfazendo alteração local(Depois do commit):	git reset HEAD meu_arquivo.txt
Desfazer o último commit:	git reset HEAD~1
Enviar arquivos/diretórios para o repositório remoto:	git push
Atualizar os arquivos no branch atual:	git pull
Criando um novo branch:	git branch minha_branch
Apagando um branch:	git branch -d minha_branch
Trocando para um branch existente:	git checkout minha_branch
Fazendo um merge entre as branchs:	git merge minha_branch
Fazendo um rebase entre as branchs:	git rebase master
Criar um stash:	git stash
Listar stashes:	git stash list
Voltar para o último stash:	git stash apply

gitkeep

O gitkeep não é um recurso ou comando do Git, mas sim uma convenção. Em muitos projetos, existe a necessidade de adicionar no Git diretórios vazios. Mas por padrão o Git não rastreia diretórios vazios, assim criou-se a convenção de adicionar um arquivo chamado: .gitkeep em um diretório vazio em que se deseja que o Git realize o rastreio. Este arquivo é criado com o . na frente para ser um arquivo oculto. Ele também é criado vazio, e logo após de ser inserido conteúdo no diretório, é feita a sua exclusão.

gitignore

O arquivo .gitignore é utilizado para informar ao Git quais arquivos não devem ser rastreados. Seu funcionamento é bem simples, basta criar o arquivo: .gitignore e adicionar no mesmo linha após linha, o caminho dos arquivos qual não deseja rastrear. Abaixo exemplo de conteúdo do gitignore.

/config/.env
/logs/*
/tmp/*
/vendor/*

GIT Flow

Existem vários modos de se utilizar o GIT, empresas podem ter processos diferentes no fluxo de trabalho com ele. Como exemplo, vou demonstrar aqui um fluxo básico de trabalho com o GIT.

Primeiro temos a branch master que é a branch principal, nesta branch fica todo o código que está em produção. Da branch master é criada somente uma branch de desenvolvimento, no início do projeto. Após isso nenhuma branch é criada a partir dela.

Temos a branch desenvolvimento, nesta branch fica o código que está sendo feito. E temos as branchs das funcionalidades, cada branch é referente a uma funcionalidade do sistema.

Na imagem abaixo temos a representação deste processo, a linha vermelha representa a branch master, a linha verde representa a branch desenvolvimento e as linhas rosas representam as branchs das funcionalidades.

Vou apresentar alguns pontos, para que seja possível deixar o gráfico do GIT igual ao apresentado acima.

1 – Para desenvolver novas funcionalidades, deve ser criado uma branch nova a partir da branch de desenvolvimento. As novas branchs devem sempre ser criadas da branch de desenvolvimento e não da master.

Crie a branch de desenvolvimento: git branch desenvolvimento
Acesse a branch de desenvolvimento: git checkout desenvolvimento
Crie a branch da funcionalidade: git branch nova-funcionalidade

2 – Após concluída a nova funcionalidade deve ser solicitado o merge, assim deve ser feito o merge da funcionalidade com a branch de desenvolvimento e não direto na master.

3 – Caso tenha sido iniciado uma branch após a branch que está sendo feito o merge, e está branch já foi feito o merge, deve ser feito o rebase para que a sequência fique organizada como a da imagem.

Git merge

O comando git merge é utilizado para juntar duas ou mais branchs de desenvolvimento.

Acesse a branch para onde será feito o merge: git checkout desenvolvimento
Realize o merge: git merge –no-ff nova-funcionalidade
Verifique se está tudo correto: git log
Envie as alterações: git push

Git rebase

O comando git rebase é utilizado para integrar uma branch com a outra. Com isso podemos atualizar o histórico de uma branch, para que ela fique atualizada com sua branch de origem.

Acesse a branch de onde será feito o rebase: git checkout nomedabranch (Geralmente a branch da funcionalidade)
Realize o rebase: git rebase nomedabranchdestino (Geralmente a branch de desenvolvimento)
Verifique se está tudo correto: git log
Envie as alterações: git push -f

Git rebase interativo

Para fazer um git rebase interativo com os commits, siga o mesmo processo descrito acima, adicionando o -i e os commits que deseja manipular.

Exemplo de rebase interativo com os dois últimos commits da branch: git rebase -i HEAD~2

O commit que quer manter deixa como pick, e o commit que quer apagar coloca como drop.

Git cherry pick

O git cherry pick é um comando que permite copiar commits de uma branch para outra.

Acesse a branch onde está o commit que deseja copiar: git checkout nomedabranch
Visualize os commits da branch com o comando: git log e pegue o código do commit que deseja copiar.
Acesse a branch para onde deseja copiar o commit: git checkout nomedabranch
Realize o cherry pick: git cherry-pick codigo-do-commit-que-deseja-copiar

Git tag

O git tag é um comando que permite a criação de tags no repositório Git. É comum a utilização de tags no código de um projeto para marcar as releases realizadas. Assim podemos identificar qual parte do código se refere a uma versão, e qual parte se refere a outra o deixando assim mais organizado.

Para criar uma tag utilize o comando: git tag -a nome-da-tag -m “Comentário da tag”. Exemplo: git tag -a v1.0.0 -m “Versão inicial do projeto 1.0.0”
- Para listar as tags utilize o comando: git tag
- Para subir a tag para o repositório remoto utilize o comando: git push origin nome-da-tag. Exemplo: git push origin v1.0.0

Git e GitHub diferença

O Git é um software de código aberto, para controle de versão de forma distribuída. Ou seja, o Git é o sistema que fornece os comandos para o gerenciamento dos arquivos e seu versionamento. Já o GitHub, é um serviço de hospedagem na nuvem que utiliza o Git. O GitHub é uma plataforma que usando o Git, podemos hospedar os arquivos de nossos softwares e os utilizar de forma compartilhada. Além disso, o GitHub fornece outras funcionalidades que auxiliam no desenvolvimento e gestão do código.

Git – Tutorial para iniciantes