O Git se popularizou fortemente nos últimos anos.
Dificilmente iremos encontrar um desenvolvedor que não use ou tenha usado o Git alguma vez na vida.
De fato, versionar código transcendeu as boas práticas, e passou a ser um aspecto fundamental para qualquer projeto de software.
O Git é um sistema completíssimo para controle de versão de forma distribuída.
Isso porque ele permite inúmeras estratégias de versionamento, e atualmente está integrado a uma infinidade de ferramentas relacionadas a processos de desenvolvimento de software.
Mas será que usamos todo o potencial desse sistema? No dia a dia, estamos aproveitando os comandos e opções que o Git possui nativamente para facilitar nossa vida?
Pois bem, nesse post vamos começar falando sobre cinco comandos que o Git oferece e que podem trazer algumas facilidades consideráveis para o cotidiano de alguém que versiona código, são eles:
- Analisando diferenças: git diff;
- Avaliando alterações: git log;
- Visualizando objetos: git show;
- Guardando alterações temporariamente: git stash;
- Copiando e colando commits: git cherry-pick.
Vamos lá!
Analisando diferenças: git diff
Embora pareça óbvio, preciso lhe dizer isso: fique sempre atento ao que você está alterando.
Isso porque é muito comum mudarmos um código para realizar um teste ou uma prova de conceito e esquecermos de desfazer a alteração. Então, use e abuse do comando:
$ git diff O comando git diff, sem parâmetros, permite visualizar as alterações ainda não selecionadas para o commit.
Portanto, na linha de comando, o Git indica essas alterações como: Changes not staged for commit.
Arquivos não versionados (untracked files) ou alterações selecionadas para o commit não são consideradas pelo git diff. Mas, por experiência própria, revisar as alterações antes de incluí-las no commit pode ser muito útil. 🙂
Por outro lado, uma vez que você já tenha feito o commit, você ainda pode usufruir do comando para revisar as diferenças que ainda não foram enviadas para o repositório remoto, evitando transtornos. 😉
Assim, o comando git diff possui parâmetros que lhe permitem comparar versões incluindo referências por commit, branches, tags.
Vejamos alguns exemplos
Para revisar as diferenças entre seu código atual e uma branch local chamada development:
$ git diff development Para revisar as diferenças entre seu código atual e uma branch remota chamada development:
$ git diff origin/development Para revisar as diferenças entre dois commits:
$ git diff 22dbbf5a1113e76493834ed70fecfd23c9052cd1 4a129c8f8a5f52501a9bfc8c5f720b3a75b8c2eb Dica: você também pode usar parte do SHA1 (usado para identificar um commit de forma única), desde que não seja uma referência ambígua:
$ git diff 22dbbf5 4a129c8 Para revisar as diferenças entre seu código atual e um commit nomeado com uma tag chamada 1.0:
$ git diff 1.0 Avaliando alterações: git log
Os commits do seu repositório Git contam a história do seu projeto. Por isso, é recomendado que você cuide bem dele. 😉
Com o comando git log, você pode visualizar o que vem sendo feito em uma determinada branch ou avaliar as alterações de um arquivo em especial.
Isso pode ser útil para você entender como alguma parte do código vem sendo evoluída, ou pode ajudar a avaliar os commits locais antes de dar git push.
Para ver o histórico de commits, com informações tais como SHA1, autor, data e descrição, você pode usar o comando sem parâmetros:
$ git log Mas pode ser útil para você também visualizar as alterações nos commits em geral, ou as mudanças que ocorreram em um arquivo.
Então, vamos ver algumas possibilidades interessantes desse comando:
Para visualizar o detalhamento de alterações incluídas em cada commit:
$ git log -p Para visualizar as alterações de um determinado arquivo chamado file.txt, por commit:
$ git log -p file.txt Para visualizar uma lista simplificada dos commits (pode ser útil para automações):
$ git log --oneline Para visualizar os últimos 5 commits:
$ git log -5 Para visualizar apenas os commits de merge:
$ git log --merges Visualizando objetos: git show
Vamos dizer que você esteja passeando por aí e queira dar uma espiada no último commit neste momento ou no topo de uma branch.
Ou talvez queira fazer um script para automatizar algum procedimento que precise de dados do último commit em questão. Pois bem, então você pode se beneficiar com o comando git show.
O comando git show sem parâmetros mostra a você detalhes do commit atual:
$ git show Por outro lado, se você gostaria de saber rapidamente sobre o commit da versão nomeada com a tag 1.4:
$ git show 1.4 Para ver o último commit da branch master:
$ git show master Você também pode escolher o formato no qual gostaria de visualizar os detalhes do commit usando a opção –pretty. Por exemplo:
$ git show --pretty=oneline Guardando alterações temporariamente: git stash
Certamente você já se deparou com a situação em que precisava urgentemente trocar de branch ou coisa do tipo, para realizar outra alteração, mas já havia “sujado” seu diretório de trabalho.
Então será útil para você saber que o Git oferece um recurso bem interessante chamado stash.
O comando git stash permite a você “esconder” suas alterações. Cada vez que você executa o comando git stash, o Git gera um stash para guardar suas alterações.
Obviamente, o comando só funciona quando seu diretório de trabalho atual está “sujo” (com alterações não versionadas ainda).
Supondo que você esteja querendo colocar de canto algumas alterações, pode usar o comando sem parâmetros:
$ git stash Para saber quantos e quais stashes você tem, pode usar o comando de listagem:
$ git stash list E se você esqueceu o que tem em um stash, use:
$ git stash show stash@{1} Ou para visualizar os detalhes da alteração do stash:
$ git stash show -p stash@{1} Agora, vamos supor que você deseje aplicar novamente as alterações do último stash que você criou, sem apagá-lo. Para tanto, use:
$ git stash apply Você também pode indicar o stash que deseja recuperar (use a nomenclatura mostrada pelo git stash list):
$ git stash apply stash@{3} Por outro lado, se você quer aplicar o stash e apagá-lo logo depois, use:
$ git stash pop E se definitivamente você quer apagar um stash em especial, pode usar o comando:
$ git stash drop stash@{2} Copiando e colando commits: git cherry-pick
O histórico de alterações é muito importante para o projeto, pois nos conta como ele está evoluindo.
Por isso, todo o cuidado é pouco na hora de escolher uma mensagem de commit, de fazer um merge ou de aplicar alterações em uma determinada branch.
Então, tendo isso em mente, o Git oferece um recurso que muitos desconhecem chamado cherry-pick.
O comando git cherry-pick permite que você aplique alterações introduzidas por commits que você tenha feito anteriormente.
Talvez fique melhor de entender usando um exemplo. Então, vamos supor que você tenha feito uma alteração pontual em uma branch.
Então, você cochilou sobre o teclado e sonhou que precisava levar aquele commit para outra branch. Para fazer isso de forma rápida, depois que você estiver na branch alvo, você pode usar o comando:
$ git cherry-pick 22dbbf5a1113e76493834ed70fecfd23c9052cd1 Por outro lado, se você gostaria de aplicar no diretório de trabalho atual o commit do topo de uma branch chamada master, pode fazer assim:
$ git cherry-pick master Para todos os comandos apresentados, você pode buscar mais informações na documentação do Git na web ou usando a opção –help na linha de comando.
Ficou interessado em saber mais sobre comandos do Git? E que tal git hooks e outros recursos? Então deixe seu comentário e fale mais sobre o que você gostaria de ler por aqui. 😉
Confira também:
O que pode mudar com a compra do GitHub pela Microsoft?
Controle de versões do seu WordPress com GIT
Do GitHub à Umbler em apenas um push