O Git é um dos sistemas de controle de versão mais utilizados no mundo de desenvolvimento de software. Ele é um projeto de código aberto desenvolvido em 2005 por Linus Torvalds, o criador do kernel do Linux.

Você provavelmente já deve ter passado pelo momento em que está fazendo um projeto, precisa enviá-lo a alguém e começa a criar vários arquivos com pequenas modificações entre eles, utilizando o nome do arquivo para diferenciar “final”, “final_1”, “final_final”, “final_agora_vai”, e por aí em diante, né? Essa é uma das dores que o Git vem pra resolver!

Ele permite ver o código de outras pessoas colaboradores, as diferenças que foram adicionadas ou removidas e mantém o histórico deles, ou seja, você pode voltar para qualquer versão anterior que estava funcionando, por exemplo. Nesse post você vai conseguir entender mais a fundo o que é o Git, como ele funciona, e como você pode usá-lo! Vamos lá? 

• O que é Git?
• Como surgiu o sistema de controle de versão Git? História!
• Onde o Git pode ser usado?
• Quais as vantagens e desvantagens de usar Git?
• O que são repositórios, commits e branches?
• Porque usar vários branches?
• Como funciona um repositório local e quais suas zonas virtuais?
• Quais as diferenças entre Git e GitHub?
• Git vs SVN: qual é melhor?
• 3 boas práticas ao usar Git
• 3 ferramentas gráficas para usar em Git
• Download e instalação do Git
• Git config: como configurar o seu git?
• Conheça 17 comandos Git e saiba para que servem!

O que é Git?

Git é o sistema de controle de versão open source mais usado no mundo atualmente! Ele é usado para controlar o histórico de alterações de arquivos e principalmente de projetos de desenvolvimento de software. Ele permite mais flexibilidade no fluxo de trabalho, segurança e desempenho. 

O que é um sistema de controle de versão?

Um sistema de controle de versão é uma ferramenta que ajuda equipes a gerenciar alterações em código fonte ao longo do tempo. Além disso, ele ajuda os times a trabalharem de forma mais rápida e inteligente. Isso acontece pois a ferramenta de controle de versão mantém um registro de todas as versões do código, ou seja, de todas as modificações. Isso ajuda a pessoa que desenvolve a conseguir voltar para qualquer versão anterior ou compará-las, ajudando a descobrir e corrigir erros muito mais rápido.

Como surgiu o sistema de controle de versão Git? História!

O Git foi desenvolvido pelo criador do kernel do Linux, Linus Torvalds, em 2005. Tudo começou com o rompimento de relações entre a comunidade que desenvolvia o kernel do Linux e a BitKeeper, que é um sistema de controle de versão que foi usado dentro do projeto do kernel. Com esse rompimento, a ferramenta do BitKeeper passou a ser paga.

Com tudo isso, Linus Torvalds decidiu construir um sistema de controle de versão que tivesse a melhor performance e usou a experiência que teve com a BitKeeper para construir o Git, que se tornou o sistema de controle de versão mais utilizado no mundo. Linus tinha como principais metas para o seu projeto:

• velocidade;
• suporte para desenvolvimento não-linear;
• distribuído;
• lidar com projetos grandes de forma eficiente.

Desde sua criação em 2005, o Git conseguiu amadurecer, tornar-se simples de usar e ainda manter esses pontos iniciais.

Onde o Git pode ser usado?

O Git pode ser usado em todo e qualquer projeto que tenha arquivos de diferentes tipos, podendo ser código, texto, imagens, vídeos, áudios, entre outros. O objetivo principal é permitir o controle de histórico e versão desses projetos, melhorar o trabalho em time e o fluxo de trabalho, proporcionar a segurança dos seus arquivos e outras tantas vantagens faladas nesse post. 

Quais as vantagens e desvantagens de usar Git?

Vantagens: porque usar Git?

Você já deve ter percebido algumas vantagens em usar Git até aqui, mas vamos falar mais sobre elas:

Desempenho

O Git pode ser considerado um dos melhores softwares de controle de versão quanto a performance. Todas as operações são pensadas para trazer praticidade e desempenho. Como ele também é distribuído, isso traz ainda mais agilidade para o desenvolvimento, já que você consegue fazer alterações no seu projeto sem uma conexão à internet.

Flexibilidade

Uma das grandes vantagens do Git é você conseguir adaptar formatos de trabalho não lineares e ainda conseguir rastrear cada uma dessas ramificações. Independente se o seu projeto é grande ou pequeno, você consegue adaptá-lo para o seu fluxo.

Segurança

Uma das prioridades é a integridade do código fonte do seu projeto. Todas as informações, conteúdos de código, versões, commits, tudo é protegido com SHA1, que é um algoritmo seguro de hash de criptografia. Isso proporciona mais segurança contra alterações acidentais ou maliciosas e também permite que o histórico de alterações seja totalmente rastreável.

Desvantagens

Como toda e qualquer decisão, precisamos olhar as desvantagens, e na escolha de um controle de versão não seria diferente. As principais desvantagens no uso do Git são:

Maior complexidade

O Git pode ser mais complexo de se entender no início, por conta da enorme possibilidade de combinações e de ramificações do seu código. Todo esse entendimento pode ficar mais complicado de entender. 

Além disso, exige que as pessoas desenvolvedoras tenham um conhecimento maior sobre o seu uso. Mas, depois dessa curva de aprendizado, agiliza o desenvolvimento e a entrega do time. Isso faz com que necessite de uma maior preparação tanto da equipe quanto dos processos do time.

O que são repositórios, commits e branches?

Repositórios

Um repositório, ou repo, é um diretório onde você armazena os arquivos do seu projeto, que podem ser códigos, imagens, áudios, vídeos ou qualquer coisa relacionada a esse projeto. Ele pode ficar armazenado no seu computador, um repositório local, ou também ser armazenado em alguns serviços como GitHub, BitBucket ou GitLab, ou seja, um repositório remoto.

Branches

Branch significa “ramo”, ou seja, uma ramificação do seu código. Imagine a seguinte situação: você tem o seu código que já está funcionando em produção e precisa desenvolver uma nova funcionalidade (“feature”). Mas você não pode mexer direto no código em produção. 

Para isso, você cria uma ramificação do seu código, uma branch, em que você pega o estado atual daquele código e cria um novo ambiente para desenvolver a nova feature a partir dali. 

Dessa forma, você não altera a versão principal do seu código, consegue desenvolver sua funcionalidade com segurança, e quando esse código estiver funcionando, você poderá colocar ele na principal (ou fazer o merge, que falaremos mais adiante nesse post).

Commits

Um commit é um conjunto de alterações que você fez em um projeto. Ele marca uma versão do seu código. Um commit guarda as alterações feitas nos arquivos, quem fez essas alterações e uma mensagem que resume essa alteração. 

Além disso, cada commit tem um hash único SHA1 que pode ser usado para acompanhar todas as alterações feitas no passado e inclusive pode ser usado para voltar em alguma alteração específica ou em algum ponto no tempo específico do seu código.

Porque usar vários branches?

A grande vantagem na possibilidade de ter várias branches é conseguir ter mais de uma “área de trabalho” sem alterar a branchprincipal. Vamos trazer um exemplo: imagine que você tenha um sistema que está funcionando e já está em produção. Agora você vai precisar implementar uma nova feature para ele. Você não pode alterar direto o código que está lá em produção, por isso, você cria uma nova branch (a feature por exemplo), e você vai partir do código que estava funcionando em produção.

Mas enquanto você estava implementando essa nova feature (lá pelo commit 4 da imagem abaixo), apareceu um bug no sistema e você tem que parar o que está fazendo e consertá-lo. Para isso, você novamente cria uma nova branch a partir do que está em produção para corrigir o problema. Depois de pronto, você consegue voltar para a sua feature sem problemas. 

Essa é uma das maiores vantagens de você trabalhar em branches. Poder focar em pequenas implementações, sem afetar o que já está funcionando, e poder trocar esses contextos, voltar e criando essas ramificações, enquanto a sua branch main continua funcionando. 

Como funciona um repositório local e quais suas zonas virtuais?

Quando estamos trabalhando em um repositório, temos três diferentes tipos de zonas virtuais:

• Working directory; 
• Staging area;
• Commit area.

O Working Directory, também conhecido como Working Tree, é a área em que você está trabalhando. Onde estão todos os seus arquivos, onde você criará novos arquivos, deletará os velhos ou alterará os que já existem. Também é onde estão os arquivos untracked.

Após alterações nos arquivos, o próximo passo é adicionar essas alterações na área de staging. Também conhecida como index, é quando o Git passa a salvar aquele estado dos seus arquivos. É como se fosse uma prévia do seu commit. O interessante é que se você fizer uma alteração em um arquivo, adicionar ele na staging area e depois fizer uma nova alteração nesse mesmo arquivo, essa alteração estará no working directory novamente. E a alteração anterior continuará na staging area.

O próximo passo é pegar todas as alterações de staging e fazer um commit com elas. Quando você faz isso, esse commit vai para a commit area ou também conhecida como local repository. Aqui fica tudo do seu repositório. É por isso que você consegue trabalhar de maneira offline, podendo executar suas tarefas e fazer commits sem precisar se conectar a nenhum repositório remoto.  

Quais as diferenças entre Git e GitHub?

Basicamente, o Github é uma plataforma usada para gerenciar, hospedar códigos e arquivos, além de facilitar a criação de ambientes de colaboração entre pessoas desenvolvedoras. O GitHub usa como sistema de controle de versão o Git. Ou seja, o GitHub facilita e auxilia a usar o Git no dia a dia. 

O Git é um sistema de controle de versão local, ele ajuda quem desenvolve a manter o histórico das versões ao longo do tempo, e traz vantagens para o desenvolvimento individual. Já o GitHub usa os recursos dele para serem usados de forma colaborativa, auxiliando o gerenciamento desses projetos e também dos times, além de também ser uma rede social e contribuir para o universo open source.

Git vs SVN: qual é melhor? 

O SVN, ou Apache Subversion, é também um sistema de controle de versão, mas com algumas diferenças em relação ao Git. Para começar, o SVN armazena todos os projetos e suas versões em um servidor único, ou seja, é centralizado. Com um commit, as alterações vão direto para esse servidor. Enquanto isso, o Git é totalmente distribuído e tem alguns recursos que auxiliam, como ter uma área de staging, branches, merges e pull requests.

O fato do SVN ser centralizado faz com que seja mais simples aprender a usá-lo e a não ter toda aquela complexidade que já falamos que o Git tem. 

Os dois são sistemas de controle de versão viáveis, mas você precisa escolher de acordo com suas necessidades. Fora o que já falamos, o Git tem mais dificuldades em compactar e guardar arquivos binários.

O Git pode funcionar melhor para quem desenvolve e não tem disponibilidade de estar sempre conectado ao repositório principal, porque existe a possibilidade de trabalhar offline. 

3 boas práticas ao usar Git

1. Faça pequenos commits

Não deixe para commitar apenas quando você terminar tudo. Faça pequenos ciclos com o código funcionando e vá commitando. Isso evita que você perca todo o código que fez e também facilita a volta em alguma parte que deu errado.

2. Escreva boas mensagens de commits

Se você é uma pessoa desenvolvedora, provavelmente já esbarrou em algum projeto em que você tentou entender o que o código faz e a mensagem do commit não ajudou em nada! E, se ainda não passou por isso, é provável que um dia vai passar.

Portanto, escrever boas mensagens no commit que representem o que aquela modificação faz ajuda muito outras pessoas do time — ou até mesmo você, quando for revisitar um código daqui uns meses ou anos.

3. Use o .gitignore

Existe um arquivo que você pode criar em todos os repositórios, na raiz, com o nome .gitignore. Nesse arquivo, você pode colocar todas as pastas e arquivos que você quer que o Git ignore e não faça track.

3 ferramentas gráficas para usar em Git

Existem algumas ferramentas gráficas que ajudam você a usar o Git. Há diferentes tipos de ferramentas no mercado, pagas e não pagas, mas vamos te mostrar 3 alternativas multiplataformas que tem planos gratuitos. 

1. Git Kraken

Além de eficiente e visualmente agradável, o GitKraken faz com que as operações do Git sejam mais compreensíveis e simples de entender. 

2. Git-cola

É uma ferramenta mais simples, porém bem poderosa para você executar seus comandos Git.

3. SmartGit

Como o próprio nome já diz, é uma ferramenta inteligente e fácil de usar. Independentemente do sistema operacional que estiver usando, ele funciona da mesma maneira. 

Download e instalação do Git

Como instalar o Git no Windows

Para instalar o Git no Windows, basta baixar o instalador mais recente aqui e seguir os passos da instalação.

Como instalar o Git no Linux

Se você tem um Debian/Ubuntu, pode baixar via apt-get, usando o comando: 

$ sudo apt-get install git

Agora, se você usa Fedora, pode usar o comando:

$ sudo dnf install git

Para verificar se está instalado, basta rodar:

$ git --version

Como instalar o Git no MacOS

Existem várias formas de instalar o Git no seu Mac. Talvez ele já esteja até instalado, caso você já tiver instalado o Xcode ou suas ferramentas de linha de comando. Para saber se ele já está em sua máquina, abra o seu terminal e digite: 

$ git --version

Se não tiver instalado, aparecerá uma janela para instalar. Agora, se você quiser instalar a versão mais recente, pode ver todas as opções de como instalar neste site. Você pode instalar via Homebrew, usando o comando: 

$ brew install git

Ou também usar o instalador mais recente, que você pode encontrar aqui.

Git config: como configurar o seu git?

Agora que você já tem ele instalado no seu computador, você pode configurar ele com seus dados. Abra um terminal e rode os seguintes comandos lembrando de alterar o que está em aspas pelo seu nome e seu e-mail:

$ git config --global user.name "Seu Nome"
$ git config --global user.email "[email protected]"

Essas configurações ficam em um arquivo chamado .gitconfig. No Linux e Mac, esse arquivo fica em ~/.gitconfig, enquanto no Windows fica em c:\Usuarios\<username>\.gitconfig.

Conheça 17 comandos Git e saiba para que servem!

1. Git init: criando seu repositório local!

O git init serve para que você crie o seu repositório localmente, no seu computador. Para isso, se você quiser criar um novo repositório, crie uma pasta (ou se você quiser iniciar um repositório em uma pasta que já existe, vá até ela) e digite o comando git init e pronto, seu repositório Git foi criado! 

2. Git add: adicionando alterações no repositório!

Quando você cria ou modifica arquivos, você precisa adicionar eles para a área de staging, para isso você usa o comando git add* para adicionar todos os arquivos ou git add<nome-do-arquivo>. Dessa forma, os arquivos estarão prontos para serem commitados.

3. Git commit: confirmando e salvando as alterações no repositórios!

Após você usar o git add, os arquivos vão para a área de commit. Você pode empacotar todas essas alterações em um único commit com uma mensagem que resume aquelas alterações. Para isso você usa o comando git commit-m “Mensagem das alterações”.

4. Git Status: verificando se há alterações na branch

O git status mostra o status do seu repositório naquele momento. Ele mostra o working directory, a staging area com todos os arquivos em cada uma das áreas e qual o estado de cada um deles. Isso ajuda muito quando precisamos pensar em fazer um commit ou até mesmo verificar quais foram todos os arquivos modificados.  

5. Git log: verifique quais commits foram feitos até agora

O git log ajuda a saber quais foram os commits feitos no seu repositório, quem fez, quando e também qual a mensagem de cada um. Além disso, esse comando te mostra a hash de cada um dos commits, o que pode ajudar a executar alguns outros comandos também. 

6. Git reset: desfazendo as alterações de um repositório para um commit anterior!

O git reset é uma forma bem complexa para desfazer alterações. Teremos um post totalmente focado para falar dele, mas para falar sobre a forma mais usada dele, vamos dar dois exemplos. O primeiro deles é quando, localmente, precisamos voltar um commit. No exemplo da imagem abaixo, temos dois commits e queremos voltar para o primeiro. Para isso, usamos o comando:

git reset <hash do commit que queremos voltar>

Se você perceber, após rodar esse comando, o último commit sumiu e as alterações voltaram para o working directory. 

Um outro exemplo bem usado é quando você quer voltar ao estado original que estava no repositório remoto. Importante lembrar que ao rodar esse comando, você perderá o que está localmente! Logo, rodando esse comando, você recuperará o histórico mais recente da branch main do servidor e apagará todas as alterações e commits locais.

git reset --hard origin/main

7. Git revert: Desfazendo um commit sem excluir os dados existentes!

O git revert faz parte de comandos do tipo “desfazer”. Mas ele não é uma opção tão tradicional. Basicamente, ele cria um novo commit desfazendo o commit que você especificar.

Criei um arquivo, adicionei um texto “primeiro conteúdo” e depois adicionei outro texto “conteúdo errado”. Fiz o revert do “conteúdo errado” e como pode ver, ele adicionou um novo commit fazendo o revert. Nesse commit, ele desfez as alterações do último commit. Ou seja, no final, o meu arquivo ficou apenas com o texto “primeiro conteúdo”.

8. Git diff: verificando as diferenças entre arquivos e repositórios!

Você pode ver as diferenças dos seus arquivos ou também entre os repositórios local e remoto. Para isso, você pode rodar o comando git diff depois das alterações que você fizer no seu repositório local ou, se você precisar ver antes de um merge, por exemplo, você também pode executar git diff <branch origem> <branch destino>.

9. Git remote: ligando seu repositório local a um repositório remoto!

Se você não clonou um repositório, você pode ligar o seu repositório local a um servidor com o comando remote. Para isso, basta usar git remote add origin <servidor>.

10. Git push: enviando as alterações do repositório local para o repositório remoto!

Depois que você fez as alterações, adicionou para a área de staging, fez os commits, você pode fazer o push. Ou seja, você consegue mandar todas essas alterações do seu repositório local para um remoto. Para isso, use o comando git push origin main, no qual main pode ser substituúida por qualquer outra branch que você estiver trabalhando. 

11. Git branch: listando e deletando branches 

Para listar todas as branches que estão em um repositório, basta rodar git branch. Para deletar uma branch específica basta rodar git branch -d nome_da_branch.

12. Git checkout: criando uma nova branch e restaurando arquivos!

Para criar uma nova branch, você deve rodar o comando git checkout -b nome_da_branch. E, para alternar entre branches, basta rodar git checkout nome_da_branch.

Agora, se você tiver feito algo errado e quiser restaurar o arquivo ao seu estado original, você pode rodar git checkout — nome_do_arquivo. Mas, isso só funcionará se o arquivo ainda estiver no working directory. Caso já esteja na área de staging, você terá que, primeiro, fazer um reset para depois conseguir fazer um checkout.

13. Git merge: mesclando as alterações em sua branch à branch master

Quando você precisa trazer as atualizações da branch main, a principal, para a branch que você está trabalhando, basta rodar da sua branch: git branch main. Se não tiver nenhum conflito nos arquivos que você mexeu na sua branch com as alterações da main, você não terá que fazer mais nada. Agora se tiver algum conflito, vai aparecer no seu terminal que houve um conflito e quais os arquivos conflitantes. Você precisará abrir cada um deles e escolher qual versão do código você vai querer manter.  

14. Git pull: atualizando o repositório local com a versão do repositório remoto! 

Quando você precisa atualizar o seu repositório local com a mais nova versão do repositório remoto, basta usar o comando git pull. Dessa forma, ele verificará se tem uma versão mais recente e, se tiver, vai baixar as diferenças para o seu computador.  

15. Git rebase: integrando todas as alterações de um branch em outro branch

O git rebase move e combina sequências de commits para uma nova branch de uma forma mais linear. Uma das diferenças do rebase para o merge é que o rebase mantém esse histórico do projeto de uma forma mais linear e organizada. O comando é simples, mas todo o conceito de como ele funciona é mais complexo. Para rodar, basta usar git rebase <branch>. Na imagem abaixo, mostramos o que acontece com o histórico quando fazemos um rebase:

16. Git stash: criando um backup das alterações atuais do seu projeto

O git stash serve para guardar ou arquivar as alterações que você fez por um determinado tempo. Ele é bem útil quando você precisa mudar de contexto rápido e ainda não está pronto para fazer um commit, ou também quando você precisa fazer um teste de uma nova linha de pensamento e não quer perder tudo que já fez antes de ter certeza que a nova abordagem funcionará. Para usar o comando git stash e para recuperar as alterações, basta usar git stash pop.

17. Git clone: baixando o código fonte de um repositório!

Você consegue clonar, ou copiar, o projeto para o seu computador. Você pode clonar um repositório localmente, fazendo uma cópia dele. Para isso, basta rodar git clone /caminho/para/o/repositório. Ou você também pode clonar um repositório remoto e para isso usar git clone “url”.

Git é algo essencial no universo da programação nos dias de hoje! Você pode achar um pouco difícil de entender no início, mas vai perceber o quanto ele vai ajudar você e seu time no dia a dia. Além de você não precisar mais ter medo de perder código ou de algo dar errado e não conseguir desfazer. Independentemente de qual área da programação você seguir, é uma ferramenta muito importante em qualquer uma delas! 

Gostou de aprender sobre Git? Aprenda agora sobre Python e saiba tudo sobre essa linguagem de programação!