Começando do início: o que é o Git?

O Git é um sistema de controle de versão, criado por Linus Torvalds (o mesmo que criou o Linux), podendo ser utilizado em plataformas de hospedagem, a exemplo do GitLab ou do mais conhecido, o GitHub. Nesses serviços de hospedagem, é possível publicar seus códigos e rastrear alterações, acessando as versões conforme a sua necessidade e a do projeto.

Mas o que vem a ser o controle de versão e qual é a sua importância?

Controle de versão: é isso tudo mesmo?

É só pensar no seguinte cenário: uma pessoa está criando uma calculadora e começou o código com a operação de soma. Após tudo transcorrer perfeitamente, fez os testes necessários e viu que não há erros no código e que tudo está muito bem.

O passo seguinte seria fazer a função de subtração. No entanto, ela tem receio de mexer com a parte da soma (que está funcionando perfeitamente) e resolve abrir um outro arquivo, copiando o código. Ela pensa: "se eu cometer algum erro, é só apagar essa cópia e repetir". Entende como isso é contraproducente? O controle de versão é justamente a solução para isso.

Com o controle de versão, como o nome diz, você cria uma "versão 1.0" da sua calculadora com a função de soma, enviaria essa versão (através do commit, que é uma alteração no repositório) para uma plataforma de hospedagem, como o GitHub e poderia continuar trabalhando no seu código, sem medo de cometer erros ou de "estragá-lo". Eventualmente, com a função de subtração finalizada, devidamente testada e funcionando perfeitamente, você faria outro commit (envio dessa nova versão) para o GitHub e assim sucessivamente, até o momento em que a calculadora possuirá todas as funções que você quis implementar.

Vale ressaltar que conforme são feitos os commits do seu código, é possível informar neles sobre o que se trata a alteração, por exemplo: "Criada a função soma", "Criada a função subtração" etc.

Diante de tudo isso que foi dito, dá para se ter uma ideia do motivo do Git ser tão importante para desenvolvedores. No entanto, para poder fazer uso apropriado dele, é necessário conhecer alguns comandos.

Neste artigo será abordado o comando inicial: o git init.

Primeiros passos

Esse artigo já é sobre o uso de um dos comandos do Git, então se presume que ele já esteja instalado na máquina. Contudo, em caso negativo, é só ir até git-scm.com/downloads e fazer o download do Git.

Dependendo do sistema operacional, principalmente no caso do Linux ou Mac, é possível que o Git já esteja instalado. Para checar, é só abrir o cmd e seguir os passos da imagem abaixo:

Checando se o Git está instalado no Windows 10.

Caso apareça a mensagem acima, vá ao site indicado e instale o software do Git.

Após a instalação, é só ir novamente no cmd do Windows (se for o caso) e refazer o teste:

Indicação no cmd de que a instalação do Git foi bem sucedida.

Se ao digitar "git" aparecer essa resposta do cmd, é sinal de que está tudo certo.

Afinal de contas, o que é o git init?

O git init é o primeiro comando utilizado para começar a enviar o código para um serviço de hospedagem.

Conforme a documentação do próprio site (https://git-scm.com/docs/git-init):

This command creates an empty Git repository - basically a .git directory with subdirectories for objects, refs/heads, refs/tags, and template files. An initial branch without any commits will be created (...)

Traduzindo, o git init transforma o diretório (no caso, a pasta do projeto escolhido) em um repositório Git vazio. Assim, um branch inicial, sem qualquer commit, será criado. Importante mencionar, contudo, que o git init serve apenas para projetos que ainda não estão sob o controle do Git.

Para iniciar, é necessário ir até o diretório onde está localizado o projeto, clicar com o botão direito e selecionar "Open Git Bash here". Veja:

Clicando com o botão direito dentro do diretório e escolhendo a opção "Open Git Bash Here".

Ao clicar, teremos o Git Bash, onde iremos utilizar nosso git init.

Na janela que abrir, digite o comando (apenas o git init, sem o $):

$ git init

Se tudo foi seguido corretamente, deve aparecer um retorno parecido com o abaixo:

Initialized empty Git repository in C:/Users/alexi/OneDrive/Área de Trabalho/Projeto/.git/

Com esse comando, será criada uma pasta .git dentro do diretório. Caso não tenha aparecido nada mesmo após seguir o passo a passo, não há motivos para preocupação: é só verificar se a configuração do gerenciador de arquivos permite a exibição de arquivos ocultos; caso não esteja marcado, é só marcar e provavelmente a pasta .git irá aparecer.

Então o diretório estará da seguinte forma:

Chegando até aqui, pode surgir uma pergunta: para que serve a pasta .git?

A pasta .git

Nesse diretório que é criado após o git init, tem-se uma série de dados fundamentais, a exemplo das pastas abaixo:

As pastas encontradas dentro do diretório .git

Alguns comentários sobre as pastas:

1) Hooks: em termos bem simplificados, um Git hook é um script que realiza determinado tipo de ação automaticamente no repositório Git. Possibilita alterar o comportamento interno do Git, de maneira a torná-lo mais personalizável.

2) Info: no exemplo acima, ela contém apenas o arquivo "exclude", que informa tipos de arquivos ou diretórios que devem ser excluídos do controle de versão, sem que seja necessário fazer uso do .gitignore .

3) Objects: aqui há uma série de subdivisões de pastas. É importantíssimo para preservar o controle de versão e seu histórico.

4) Refs: o termo vem de "referências". Aqui, se subdivide na pasta "heads" e na "tags"; são importantes no sentido de fazer referência a um commit específico realizado, dentre outros.

Em resumo, são pastas fundamentais para o bom funcionamento do controle de versão do código. Na maioria quase absoluta das vezes, não há qualquer necessidade de fazer alterações nessa pasta, sob o risco de causar problemas graves no controle de versão.

Conclusão

Com isso, encerramos o artigo sobre o uso do git init.

Foi visto sobre o que é o Git, a importância do controle de versão, dicas extras de como instalar (caso ainda não tenha sido instalado), além do passo a passo para fazer o uso correto do comando em um projeto fictício, construindo assim o caminho para os passos seguintes rumo a um controle de versão bem executado.