O sistema de controle de versão é um sistema que registra as mudanças realizadas em um ou mais arquivos de um projeto. Neste sistema ficam gravados todas as mudanças realizadas ao longo do desenvolvimento, permitindo resgatar versões específicas se necessário. Como geralmente os projetos são criados através de um time, o controle de versão permite este trabalho em equipe, sem que um interfira ou conflite com o código do outro. O GIT é um sistema de controle de versão, e assim como outros, como CVS, SVN, que são mais antigos, guardam o histórico completo dos arquivos desenvolvidos e alterados, que permitem acompanhar revisões sem acesso a uma rede ou um servidor central.

Inicie com Github

O Github é um servidor de web hosting compartilhado para projetos que utilizam GIT.

Para começar, crie uma conta em github.com, e em seguida, crie um repositório para treinar e aprender a utilizar o controle de versão:

…or create a new repository on the command line
echo "# teste" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin git@github.com:thabata-marchi/teste.git
git push -u origin master

Digite este passo a passo em sua linha de comando e comece a treinar com GIT.

[!Dica] Utilize o CMDER.org ao invés do comando original do Windows. Ele funciona exatamente como um prompt de comando, porém com muito mais possibilidades e mais organização para o desenvolvimento de suas tarefas.

Após instalar o CMDER, abra o mesmo, entre no local que deseja criar seu projeto, siga as instruções do Github e comece!

Para criar pastas através do CMDER, entre no caminho das pastas utilizando o comando ‘cd’ e em seguida para criar uma nova pasta, digite o comando:

~ mkdir nome-da-pasta

Crie um arquivo html (index.html) e após isso, faça modificações no seu código. Veja os arquivos modificados através do comando:

~ git status

Mas, o que foi alterado em determinado arquivo?

~ git diff

Com este comando, você consegue visualizar as linhas alteradas em um determinado arquivo, utilizando o nome do arquivo que apareceu em seu “status”, ou em todo o projeto.

Arquivo modificado. Agora é necessário adicionar estas alterações para que toda a equipe trabalhe em cima dos arquivos? Se for imprescindível que todos os arquivos subam ao repositório, utilize o comando:

~ git add -A

Se não puder subir todos os arquivos, e sim, um ou mais arquivos específicos, utilize então:

~ git add [nome-do-arquivo-de-acordo-com-status]

Para ver se o seu código foi adicionado, digite o comando:

~ git status

Depois que adicionado, é necessário realizar um commit para o repositório:

~ git commit -m "Descrição da suas alterações que serão comitados"

Antes de enviar os arquivos para o repositório, ou mesmo começar o seu trabalho, é sempre importante verificar se existem outras mudanças, realizados pelos integrantes da sua equipe. Para “sincronizar” seu projeto, utilize sempre o comando:

~ git pull

Com a utilização do comando acima, foi verificado se existem alterações e puxados estas modificações do repositório. Agora pode subir suas alterações, utilizando o comando a seguir:

~ git push

Pronto! Suas alterações foram enviadas para o seu servidor Github. Atualize seu Github e veja seu projeto atualizado!

[!Outros comandos]

Conheça mais alguns comandos necessários para o seu dia a dia como desenvolvedor:

~ git checkout -- <file>

Utilize este comando para desfazer alterações no arquivo

~ git cherry-pick [commit-especifico]

Este comando tem como objetivo, pegar somente o commit especificado, ao invés do comando comum: git pull, que pega todas as alterações realizadas naquela ‘branch’.

~ git branch

Para ver a lista das branchs que tem no projeto.

~ git checkout [nome-da-branch]

Para alterar a branch.

~ git commit -a

Adiciona ao índice todos os arquivos registrados que foram modificados, antes de fazer o commit. Isso confirma arquivos alterados e excluídos, mas não novos.

~ git remote add git@nome-do-repositorio.git

Para adicionar um novo repositório remoto no Git.

~ git pull [nome-do-repositorio] [nome-branch-especifica]

Aqui eu pego as alterações apenas deste repositório e branch específica.

~ git push --set-upstream origin [nome-da-branch]

Para enviar uma branch recém criada.

~ git pull --all

Puxa as branches que foram criadas.

~ git checkout -b [nome-branch]

Para criar um branch e mudar para ele ao mesmo tempo.

~ git branch -d [nome-branch]

Para deletar uma branch recém criada.

~ git branch -a

Para ver todas as branches remotas.

git pull branch [nome-da-branch]

Para puxar a git específica [nome-da-branch] que esta remota.

Comandos STASH:

~ git stash

Guarda as alterações realizadas (como se fosse um pré-commit).

~ git stash list

Lista as alterações realizadas (seus pré-commits).

~ git stash apply

Aplica as alterações realizadas e continua guardado na lista.

~ git stash pop

Aplica as alterações realizadas e remove da lista.

~ git stash --keep-index

Grava e desfaz suas mudanças pendentes que não estejam no índice e reinicializa sua árvore de trabalho para corresponder ao índice.

Comandos DIFF

~ git diff

mostra suas alterações que não sofreram ainda stage, ou seja, a diferença entre a árvore de trabalho e o índice.

~ git diff --staged

mostra suas alterações que já sofreram stage, ou seja, a diferença entre o commit mais recente e o índice. Estas são as alterações que serão incluídas no próximo commit. –cached é um sinônimo de –staged.

Você pode passar um commit alternativo, pois o padrão é o HEAD.

~ git diff <nome-do-commit>

Mostra a diferença entre a árvore de trabalho e o commit mencionado.

[!Importante]

~ git pull

Pega as alterações do servidor, mas por exemplo, o dev “A” está trabalhando na mesma branch que o dev “B”. Dev “A” faz commit e push, dev “B” faz o push e commit, então aparece duas linhas, que ao dar “pull” se encontram, como no exemplo abaixo:

A ————————–> —————————– GIT PULL (se encontram)
B —————————>

~ git pull --rebase

Pega as alterações do servidor, mas por exemplo, o dev “A” está trabalhando na mesma branch que o dev “B”. Dev “A” faz commit e push, dev “B” faz o push e commit, então aparece duas linhas, que ao dar “pull –rebase” se encontram, porém, não ficam com as duas linhas como no exemplo acima, mas unifica em uma linha só, ficando mais organizado:

A B —————————–> (git pull –rebase)

Obs.: Desse modo fica mais organizado visualmente, e se por exemplo, ocorrer algum erro em algum commit, através do comando ’gitk’ conseguimos encontrar mais facilmente o commit que deu erro.

Com o GIT é possível gerenciar seus repositórios remotamente,  colaborar com outros projetos e trabalhar em paralelo com outros desenvolvedores sem que um sobreponha o código do outro. Comece logo com GIT!