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

O de­sen­vol­vi­mento co­la­bo­ra­tivo de softwares não ocorre apenas in­ter­na­mente, em empresas privadas. Co­mu­ni­da­des de código aberto, com centenas ou milhares de vo­lun­tá­rios (de­pen­dendo do tamanho do projeto), se en­car­re­gam da ma­nu­ten­ção, oti­mi­za­ção, de­sen­vol­vi­mento e mo­di­fi­ca­ção de softwares “públicos”. Projetos assim seriam inviáveis sem um sistema de ge­ren­ci­a­mento, res­pon­sá­vel por registrar todas as mudanças feitas por di­fe­ren­tes pro­gra­ma­do­res.

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 ge­ren­ci­a­mento de software, para que você comece a utilizá-lo com confiança.

O que é Git?

Git é um sistema de controle de versões de­sen­vol­vido 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 re­po­si­tó­rio central, todos os usuários en­vol­vi­dos em um de­sen­vol­vi­mento fazem download de uma cópia do diretório lo­cal­mente, no dis­po­si­tivo próprio.

Cada cópia funciona como um backup completo do re­po­si­tó­rio, o que significa que de­sen­vol­ve­do­res não precisam ficar o tempo todo co­nec­ta­dos e podem trabalhar off-line. Além disso, essas cópias podem ser usadas para restaurar projetos, caso o re­po­si­tó­rio principal apresente falhas ou seja da­ni­fi­cado. Al­te­ra­ções podem ser com­par­ti­lha­das com todos os demais membros de um projeto a qualquer momento, e também incluídas no re­po­si­tó­rio central, quando ne­ces­sá­rio.

Como instalar o Git?

Quem deseja aprender a gerenciar projetos de softwares com o Git precisa se fa­mi­li­a­ri­zar com ele primeiro. O Git está dis­po­ní­vel para Windows, Unix/Linux e macOS, mas apresenta pequenas di­fe­ren­ças em cada pla­ta­forma. Após instalar a versão correta para o seu sistema ope­ra­ci­o­nal, você con­se­guirá controlar a solução de forma in­de­pen­dente, usando linha de comando ou a interface gráfica do usuário.

Para exibir esse vídeo pre­ci­sa­mos usar cookies de terceiros. Você pode acessar e mudar suas con­fi­gu­ra­ções de cookies here.

Arquivos de ins­ta­la­ção binários, guias para ins­ta­la­ção de ge­ren­ci­a­do­res de pacotes (sistemas Unix) e edições portáteis prontas para uso estão dis­po­ní­veis para di­fe­ren­tes sistemas ope­ra­ci­o­nais no site oficial do projeto Git. Faça o download do pacote adequado ou use a opção cor­res­pon­dente no ge­ren­ci­a­dor de pacotes. Depois, siga as ins­tru­ções do as­sis­tente de ins­ta­la­ção. Se você optar pela edição portátil, o processo de ins­ta­la­ção não precisará ser executado.

Tutorial Git passo a passo

Depois de instalar o Git no seu dis­po­si­tivo, você poderá usar o sistema de controle de versões para gerenciar seus projetos de software. Assim como com qualquer outra fer­ra­menta, você terá de aprender os prin­ci­pais comandos e funções do Git para apro­vei­tar ao máximo suas pos­si­bi­li­da­des. Por isso, nosso tutorial Git ensinará você a con­fi­gu­rar o Git e apre­sen­tará as prin­ci­pais ins­tru­ções de linha de comando, para facilitar a criação e a ma­nu­ten­ção de re­po­si­tó­rios.

Crie ou clone um re­po­si­tó­rio Git

O re­po­si­tó­rio Git é o diretório central de um projeto, assim como o principal ponto de encontro entre todos os usuários que par­ti­ci­pam do de­sen­vol­vi­mento dele. É a partir do re­po­si­tó­rio que o ge­ren­ci­a­mento completo de versões é realizado. Por isso, sua primeira tarefa no nosso tutorial Git será criar um re­po­si­tó­rio central. Se você já estiver par­ti­ci­pando de um projeto de de­sen­vol­vi­mento co­la­bo­ra­tivo ge­ren­ci­ado com o Git, poderá clonar o re­po­si­tó­rio central (em forma de cópia de trabalho).

Se quiser con­fi­gu­rar o ge­ren­ci­a­dor de versões ou instalar fer­ra­men­tas para aprender a trabalhar com o Git, você precisará criar um novo re­po­si­tó­rio. Para fazer isso, alterne para o re­po­si­tó­rio local desejado no seu dis­po­si­tivo, usando o comando cd (change directory):

cd caminho para diretório desejado

Depois, execute o comando abaixo para gerar um re­po­si­tó­rio Git:

git init

Close

Se o re­po­si­tó­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 com­pu­ta­dor. Para isso, use o comando git clone:

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

Verifique o status do re­po­si­tó­rio e adicione novos arquivos para controlar versões

Or­ga­ni­za­ção eficiente do re­po­si­tó­rio de trabalho é um dos pilares mais im­por­tan­tes do Git. A solução permite que você proponha al­te­ra­ções e adições a um projeto, para que sejam adotadas como “commits”, e também que acesse in­for­ma­ções sobre ajustes feitos por outros usuários. Você pode verificar o status atual da sua cópia de trabalho exe­cu­tando o seguinte comando:

git status

No caso de um re­po­si­tó­rio recém-criado, ou se o re­po­si­tó­rio central e sua cópia de trabalho forem idênticas, você receberá uma mensagem in­for­mando que não há novas al­te­ra­çõ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”).

Close

Para adicionar um novo arquivo ao ge­ren­ci­a­mento 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 re­po­si­tó­rio de trabalho). Nosso tutorial Git adi­ci­o­nará um arquivo de texto chamado “Test”, como exemplo:

git add Test.txt

Se você realizar uma ve­ri­fi­ca­ção de status do re­po­si­tó­rio novamente, o arquivo do exemplo será apontado como potencial candidato à próxima atu­a­li­za­ção oficial do projeto (“Changes to be committed”):

Close

Confirme al­te­ra­ções por commit e inclua-as no HEAD

Todas as al­te­ra­ções que você envia ao ge­ren­ci­a­dor de versões (conforme descrito na seção anterior) precisam ser con­fir­ma­das 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á au­to­ma­ti­ca­mente o editor que você se­le­ci­o­nou durante o processo de ins­ta­la­ção, ou o editor padrão do sistema de ge­ren­ci­a­mento de versões. Neste momento, você poderá adicionar um co­men­tá­rio ao commit planejado. As linhas incluídas, separadas por ponto e vírgula, não serão exibidas pos­te­ri­or­mente. Assim que você fechar o editor, o Git criará o commit:

Close

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 re­po­si­tó­rio de trabalho também é o re­po­si­tó­rio central) que adotou as al­te­ra­ções, esoma de ve­ri­fi­ca­ção (checksum) SHA-1docommit(no caso,c0fdc90). Na sequência, o co­men­tá­rio escolhido (“Test”, no nosso exemplo) será exibido, assim como in­for­ma­ções es­pe­cí­fi­cas sobre al­te­ra­ções feitas.

Edite ou reverta commits gerados

Caso você adote al­te­ra­ções na forma de commits, é possível editá-las e até removê-las. Por exemplo, edições podem ser ne­ces­sá­rias caso você gere um commit antes da hora, es­que­cendo-se de arquivos ou ajustes im­por­tan­tes. Neste caso, você deverá fornecer arquivos novos ou editados re­tro­a­ti­va­mente, usando o comando git add, e repetir sua entrada no re­po­si­tó­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 re­ver­ti­dos ao status de al­te­ra­ções pla­ne­ja­das (“Planned changes for the next commit”). Para excluir per­ma­nen­te­mente 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, jus­ta­mente por causa de seus recursos de ver­si­o­na­mento. Uma das grandes vantagens deste sistema de código aberto é que você consegue vi­su­a­li­zar as últimas al­te­ra­ções feitas no re­po­si­tó­rio. Para fazer isso, execute o seguinte comando:

git log

O comando git log lista os commits gerados em ordem cro­no­ló­gica inversa e exibe, por padrão, a ve­ri­fi­ca­ção de soma SHA-1, o autor (nome e endereço de e-mail) e a data do commit. Além disso, osco­men­tá­rios também podem ser vi­su­a­li­za­dos, for­ne­cendo a você e aos demais usuários in­for­ma­ções im­por­tan­tes sobre cada uma das al­te­ra­ções.

Você já aprendeu, com este tutorial Git, a gerar um commit simples, com o co­men­tá­rio “Test”. Essas in­for­ma­ções serão apre­sen­ta­das da seguinte forma:

Close

O comando log também pode ser mo­di­fi­cado por diversos pa­râ­me­tros. A tabela a seguir apresenta algumas opções úteis:

Inclua commits no re­po­si­tó­rio central

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

git push origin master

O Git adi­ci­o­nará au­to­ma­ti­ca­mente todos os commits gerados ao master, nome do re­po­si­tó­rio central — antes eles só existiam na sua cópia de trabalho. Se você subs­ti­tuir 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 im­por­tan­tes, pontos se­le­ci­o­na­dos no histórico de um re­po­si­tó­rio. Essas tags costumam ser usadas para sinalizar lan­ça­men­tos de um software (por exemplo, versão 1.0, 2.0, 3.0 e assim por diante), para que elas sejam fa­cil­mente acessadas, prin­ci­pal­mente em projetos maiores. O Git suporta dois tipos de tags:

• Tags “anotadas”: Salvas como objetos in­de­pen­den­tes no banco de dados. Incluem soma de ve­ri­fi­ca­ção própria, mensagem de tagging, data, nome e endereço de e-mail do autor, bem como as­si­na­tura GNU Privacy Guard (GPG) opcional.
• Tags “leves”: Agem como branches e servem apenas como re­fe­rên­cia para um commit. Adequadas para marcações tem­po­rá­rias ou quando não se deseja salvar in­for­ma­ções adi­ci­o­nais.

Você pode criar tags “anotadas” no Git usando o comando git tag -a no res­pec­tivo commit. Ao adicionar o parâmetro -m como sufixo, você poderá escrever a mensagem de taggingque quiser, di­re­ta­mente 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 re­po­si­tó­rio, você poderá exibi-las com o comando git tag e os pa­râ­me­tros opcionais -l e --list:

git tag
git tag -l
git tag --list

Close

Para excluir uma tag do re­po­si­tó­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 trans­fe­ri­das ma­nu­al­mente para o re­po­si­tó­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 trans­por­tará todas as tags geradas para o re­po­si­tó­rio.

git push origin --tags

Crie, gerencie e exclua branches

Branches usados neste tutorial Git cor­res­pon­dem a versões de trabalho in­di­vi­du­ais do re­po­si­tó­rio central. O re­po­si­tó­rio central, por sua vez, também é clas­si­fi­cado como um branch, neste caso chamado de “master”. É por esses branches que o Git oferece a base perfeita para o de­sen­vol­vi­mento de funções e recursos isolados, com­bi­nando-os somente em estágios pos­te­ri­o­res. Ao processo de com­bi­na­çã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

Close

Se você quiser fazer merge em branches, use o comando git merge. Antes, insira o comando checkout, para alternar para o re­po­si­tó­rio que integrará o outro branch. Depois, execute o comando de merge, jun­ta­mente com o nome do branch a ser mesclado. No nosso tutorial Git, mes­cla­re­mos ao re­po­si­tó­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 de­ter­mi­na­dos branches an­te­ri­o­res. Exclua-os, se for o caso. Para fazer isso, adicione o comando git branch -d ao branch a ser des­car­tado. Nosso tutorial Git excluirá o exemplo “test_branch”, exe­cu­tando o comando a seguir:

git branch -d test_branch

Para efetuar um processo de exclusão de um branch, você ne­ces­sa­ri­a­mente terá de estar em um branch diferente. É por esse motivo que al­ter­na­re­mos para o re­po­si­tó­rio central antes de exe­cu­tar­mos o comando, conforme mostra a captura de tela abaixo:

Close