Git é um software para rastrear alterações em qualquer conjunto de arquivos, geralmente usado para coordenar o trabalho entre programadores que desenvolvem código-fonte de forma colaborativa durante o desenvolvimento de software. Seus objetivos incluem velocidade, integridade de dados e suporte para fluxos de trabalhos não-lineares distribuídos.
Vamos supor que temos um projeto, como um site, e nosso cliente peça alterações no visual do mesmo, por exemplo. Nós alteramos e modificamos o projeto. Vamos supor que de repente nosso cliente acaba voltando a querer a primeira versão do projeto, se nós fizemos muitas modificações, fica difícil encontrarmos versões mais antigas. Podemos fazer o versionamento criando pastas ou ZIPs com várias versões, inclusive com um arquivo de texto citando as alterações, mas isso acumularia muito arquivos e consumiria muito espaço em disco. É para resolver todos esses problemas que o Git existe.
Com o Git, podemos, de forma mais inteligente:
featuresdiferentes sem bagunçar o código original do projeto.
Os nossos projetos serão hospedados remotamente num servidor, no caso, no GitHub.
GitHub Inc. é um provedor de hospedagem na internet para desenvolvimento de software e controle de versão usando Git. Ele oferece o controle de versão distribuída e a funcionalidade de gerenciamento de código-fonte do Git, além de seus próprios recursos.
No GitHub, nós podemos:
Hostearo seu código em um local seguro.
Essencialmente, Git repositório é um diretório chamado .git (oculto) dentro do seu projeto.
Este repositório rastreia todas as mudanças feitas nos arquivos do seu projeto, construindo um histórico ao longo do tempo.
O commit é como se fosse uma marcação histórica no qual seu projeto já está com alguma parte importante definida (como, por exemplo, adicionando forma de pagamento, ou adicionando integração com Whatsapp). É de forma parecida com as fases salvas de um jogo de videogame. Para um commit ser realizado, alguma coisa no projeto deverá ser modificada para isso, os estados, são esses:
commitados).
PS: Os commits são feitos no repositório local, antes de serem enviados para o repositório remoto (push).
As branches são uma linha do tempo no projeto principal, cuja branch principal geralmente é a master ou main, e desta deriva outras linhas do tempo paralelas, que não interferem uma na outra, e que podem ser fundidas na branch principal.
Para clonar um repositório, basta copiar o link do diretório do GitHub e escrever no terminal git clone https://github.com/nomedousuario/NomeDoRepositorio.git. Podemos clonar nossos próprios repositórios e também repositório de outros usuários.
PS: Ao clonar um repositório, ele clonará todas as branches do mesmo, mas apenas a master estará verificada (checkout) e ativa. Não se preocupe com isso agora.
Para entrar com seu e-mail e usuário do GitHub no seu repositório Git na máquina local, digite esses comandos:
git config --global user.email "nomedeusuario@servidor.com"
git config --global user.name "Nome do Usuário"
Para deslogar depois, basta digitar:
git config --global --unset user.name
git config --global --unset user.email
Esses dados serão armazenados num arquivo .gitconfig que ficará no diretório do usuário do seu sistema (como C:\Users\NomeDoUsuario no Windows e /home/NomeDoUsuario no Linux).
Para verificar os usuários inseridos, faça assim:
git config --global user.name
git config --global user.email
Para definir a branch padrão, digite esse comando:
git config --global init.defaultbranch master
E para ver a mesma:
git config --global init.defaultbranch
Podemos ver esses e outros dados na configuração do Git, usando o comando git config --list.
Para ver a versão do Git instalada, digite git --version.
Para criar um repositório, primeiramente crie duas pastas, pode ser pelo terminal mesmo, com os nomes Projeto-1 e Projeto-2 (evite acentuação e espaços).
Dentro do diretório Projeto-1, digite git init para iniciar um novo repositório nela, ele criará uma pasta oculta com o nome .git
dentro dessa pasta, onde estará as configurações do repositório. Por enquanto não mexeremos no Projeto-2. A branch padrão será a main ou a master (depois criaremos outras).
No repositório Projeto-1, vamos criar um arquivo, por exemplo, index.html, com algum código básico. Esse arquivo e quaisquer outros inseridos nesse repositório, serão monitorados pelo Git, que identificará quaisquer alterações neles, por mínimas de sejam.
Para ver o estado atual do repositório local, digite git status. Ele mostrará se o repositório tem arquivos sendo monitorados e commits realizados. No caso ele mostrará que tem arquivos que ainda não estão sendo rastreados pelo Git (no caso, nosso index.html) e nenhum commit.
Para adicionar o arquivo pra ser rastreado pelo Git, digite git add index.html.
Para remover um arquivo do rastreamento do Git, digite git rm --cached index.html. Pode ser necessário especificar -rf para excluir diretórios.
No Projeto-2, inicie o Git com git init e crie mais arquivos, como o index.html e um de estilo.css, que pode estar numa pasta. Nesse caso, para adicionar todos os arquivos do diretório apenas com git add . (sem esquecer do ponto), para remover, podemos usar git rm --cached *.
Remova o Projeto-2 e deixe apenas o Projeto-1, nesse projeto, vamos adicionar os arquivos com git add . (não esqueça do ponto, que significa tudo
), caso não seja adicionado e vamos colocar um ponto no tempo desse projeto, que vamos chamar de commitar
.
Para fazer o commit, digite git commit -m "Motivo do Commit". Veja o status de novo com git status para ver se o commit foi executado com êxito.
Para ver o histórico de commits, basta digitar no terminal git log. Ele mostrará o autor do commit, a data do mesmo e seu hash. Para sair da tela basta digitar q
. Para ver resumido, digite git log --oneline.
Coloque um conteúdo básico no HTML e no CSS, para eles serem alterados. Novamente, digite esses comandos na ordem:
git status
git add index.html
git commit -m "Adicionando Conteúdo HTML"
git status
git log
Como sabemos, cada commit é um ponto no histórico do seu repositório. Há necessidade de voltar a um commit anterior ao último. Existem três formas de desfazer um commit:
checkout: Um comando seguro, que não altera o histórico do Git. Permite navegar até um commit antigo ou mudar de branch. Pode ser usado para visualizar um estado anterior do projeto, mas não desfaz commits, apenas muda o ponto de trabalho temporariamente.revert: Também seguro, pois não apaga nem reescreve o histórico. Cria um novo commit que desfaz as alterações de um commit anterior. É recomendado quando é necessário desfazer mudanças mantendo o histórico intacto, especialmente em projetos já compartilhados.reset: O comando mais arriscado, pois reescreve o histórico do Git. Pode remover completamente commits posteriores ao commit para o qual se está retornando. Se usado com --hard, também apaga alterações nos arquivos e no staging. Deve ser usado com cuidado, especialmente em repositórios compartilhados.Altere mais uns arquivos e crie mais uns três commits, para exemplificarmos melhor. Depois dê um git status --oneline para ver os commits.
Vamos voltar pro terceiro commit, pegar o código dele mostrado no status e digite dessa forma: git checkout d874777. Para desfazer essa alteração, digite git checkout main que ele fica novamente como antes. Para comprovar, digite git status --oneline de novo.
Agora vamos voltar pro segundo commit, pegar o código dele também e digitar assim: git revert c67f99d. Ele vai adicionar um comentário nos arquivos de configuração, daí pra confirmar digite :q.
Para resetar tudo e que nada fique no histórico, podemos pegar um código do commit e digitar assim: git reset e0323fe. Mas no entanto, caso tenhamos alterado o arquivo nos editores, devemos fazer um novo add e um novo commit para essas alterações. Para resetar totalmente, inclusive commits posteriores, digitamos git reset 0551f68 --hard (esse comando deve ser usado com cautela).
Podemos configurar o Git para que ele não monitore determinados arquivos do repositório, isso é feito num arquivo chamado .gitignore dentro dele. Vamos, por exemplo, criar um robots.txt e colocar ele pra ser ignorado.
Para isso, crie o arquivo .gitignore e adicione essas linhas:
robots.txt
*.gif
dist
No caso, o primeiro é um arquivo robots.txt, o segundo pra todos os arquivos GIF no diretório, e o dist no caso seria outro diretório dentro do repositório.
Quando criamos um repositório, automaticamente ele cria uma branch principal, geralmente chamada main ou master. Então podemos fazer uma branch, que no caso, é uma ramificação da branch principal, paralela à mesma, onde cada branch tem seus commits independentes. Cada desenvolvedor pode ter sua própria branch no mesmo projeto, e elas posteriormente podem ser fundidas à branch principal.
Digite git status para ver o status do repositório e digite git branch para ver as branches no projeto, que no caso só teremos a master (principal). Para criar uma nova branch digitamos, por exemplo, git branch teste para criar uma branch de nome teste. Ao dar git branch de novo, ele mostrará as branches master e teste (a branch na qual estamos atualmente será destacada por um asterisco e de cor verde).
Para mudar pra branch teste, digite git checkout teste. Para ver se ele mudou, digite git branch de novo. O checkout, além de trocar commits, também troca branches.
Tudo que fizermos na branch teste não afetará em nada a branch master. Vamos por exemplo, criar um arquivo Javascript, adicionar e dar commit nele. Digite git log --oneline para vermos os commits realizados no repositório.
Ao digitar git checkout master pra voltar pra branch principal, veremos que nada foi alterado (no caso, não terá arquivos Javascript). Ao dar git log --oneline de novo ele não terá o commit do Javascript.
Para deletar uma branch, digite git branch -d teste, mas caso ela não seja fundida à branch master, ele não deixará excluir. Para forçar exclusão coloque o D
maiúsculo, como git branch -D teste.
Crie uma nova branch, por exemplo, git branch mercado-pago, e mais uma com git branch whatsapp, simulando dois funcionários trabalhando em diferentes coisas no mesmo programa. Para trabalharmos com a branch do Mercado Pago digitamos git checkout mercado-pago, e podemos, por exemplo, colocar um Javascript simulando o uso do mesmo, fazendo a adição e o commit. Mude para a branch do Whatsapp com git checkout whatsapp e veremos que nada colocado do Mercado Pago estará lá, adicione também um Javascript, adicione e commite também. Volte depois pro Mercado Pago com git checkout mercado-pago, e pra master com git checkout master.
Continuando nosso assunto de branches, vamos fundir as duas branches criadas anteriormente. Digite git branch para ver as branches e a branch atual. Digite git checkout whatsapp para ver as alterações.
Para fundir as branches, devemos ir na branch de destino (a que receberá a outra branch), no caso, fundiremos a branch do Mercado Pago com a principal (master). Digite git checkout master para isso, e para fundir o Mercado Pago com a master, digite git merge mercado-pago.
Para fundir a branch do Whatsapp, é o mesmo processo, na branch master, digite git merge whatsapp. Numa segunda fusão, ele poderá abrir o editor de configurações e nesse caso, basta digitar :q.
Ao dar git log novamente, e mostrará incorporado à branch master, os commits das outras branches que foram fundidas com ela.
Podemos continuar trabalhando numa branch mesmo depois dela ser fundida com outra. Vamos supor agora que vamos alterar um estilo na branch do Whatsapp. Primeiro vá pra essa branch com git checkout whatsapp e altere o CSS, como por exemplo, a cor de fundo do site, adicione e commite. Voltando na branch principal com git checkout master, vamos fazer outra alteração de cores no CSS, adicionamos e commitamos.
Ao fazer a fusão no master de novo com git merge whatsapp, ele dará um conflito de código, e não fundirá as branches. No caso você abrirá o editor, que marcará o código com os conflitos, para ser corrigido manualmente. Após a edição, veja o status, adicione e commite ele, e também podemos omitir a mensagem, pois o Git saberá que se trata de um conflito, então digite apenas git commit, ele abrirá os comentários de configuração, nesse caso digite :q, e ele concluirá a fusão.
Vamos pra branch do Mercado Pago digitando git checkout mercado-pago e vamos editar o Javascript dele, add e commite ele, volte pro master com git checkout master, edite o mesmo Javascript do Mercado Pago, adicione e commite também. Vamos fundir novamente o branch do Mercado Pago com o master, digitando git merge mercado-pago e ele mostrará o conflito novamente. Resolva da mesma forma anterior.
PS: Várias IDEs podem oferecer comparações sobre os conflitos dos códigos dos branches para serem corrigidas pela gente.