Aprenda o básico de Git em 5 minutos

Se você nunca utilizou o Git em seus projetos anteriormente já deve ter sentido a falta de um mecanismo que armazene seu código e facilite o histórico de alteração dele, mas não se preocupe, hoje iremos aprender o essencial para dominar esta ferramenta tão importante no mundo do desenvolvimento.

Git é o sistema de controle de versionamento mais utilizado. Sua função não se limita apenas ao desenvolvimento, uma vez que pode ser utilizado para registrar o histórico de edições de qualquer tipo de arquivo. Uma das principais funções do Git para além do versionamento é contribuir para a colaboração, permitindo que as alterações feitas por várias pessoas sejam mescladas em uma única fonte.

Instalando o Git

Primeiramente, é válido verificar se você já tem o Git instalado em sua máquina, para tanto, execute isso em seu terminal:

git version 
# git version 2.35.1 //Output

Caso você ainda não tenha, siga as instruções em:

Downloads

Usuários de Mac podem instalá-lo com brew:brew install git

Usuários de Linux podem instalá-lo com sudo: sudo apt-get install git

Configurando o ambiente

git config --global user.name "Fulano de Tal"
git config --global user.email fulanodetal@exemplo.br

O indicado é que os dados informados sejam os mesmos de sua conta no Github, mas não iremos nos aprofundar nisso neste artigo.

Você pode listar sua configuração global com:

git config --list

Criando um repositório

Um repositório nada mais é que uma pasta com todos os arquivos que você deseja versionar.

Para criar um, execute este comando:

git init //em caso de um diretório existente ||
git init <project directory> //caso deseje iniciar em uma nova pasta
git config --global init.defaultbranch main //define main como branch default

Para este tutorial, recomendo que você crie uma novo diretório vazio com:

mkdir gittutorial //cria um novo diretório com o nome "gitutorial"
cd gittutorial //altera para o nossa nova pasta
git init //cria um repostório no nosso diretório vazio

Fazendo alterações

Para isso, vamos criar um arquivo no nosso diretório de exemplo:

echo "Olá, Git" >> hello.txt

Se executarmos git statusveremos que um novo arquivo não rastreado foi criado em nosso diretório:

git status
# On branch main
# 
# No commits yet
# 
# Untracked files:
#  (use "git add <file>..." to include in what will be committed)
#   hello.txt
#
# nothing added to commit but untracked files present (use "git add" to track)

Como sugere a saída, devemos adicionar o novo arquivo. Para isso, execute:

git add . //caso deseje adicionar todo os arquivos da pasta
git add hello.txt //caso deseje adicionar o arquivo especifico

Se rodarmos novamente o git status , a saída indicará que o arquivo foi adicionado - etapa também conhecido como staged , mas ainda não confirmado - etapa denominada commit:

git status
# On branch main
# 
# No commits yet
# 
# Changes to be committed:
#  (use "git rm --cached <file>..." to unstage)
#   new file:   hello.txt

Para confirmar e gravar as alterações, rode o comando git commit:

git commit -m "Adiciona hello.txt"
# [main (root-commit) a07ee27] Adds hello.txt
# 1 file changed, 2 insertions(+)
# create mode 100644 hello.txt

Dica: git commit -m "mensagem" é um comando abreviado, para consultar mais informações você pode utilizar apenas o git commit.

Dica 2: A mensagem que acompanha seu commit deve ser clara e descritiva das alterações realizadas, para que facilite a compreensão do histórico de versionamento quando outra pessoa ou até você mesmo trabalhe no código futuramente.

Criando ramificações (branches)

Em um determinado momento você sentirá a necessidade de ter uma parte separada do código fonte, seja pela necessidade de testes pelo o qual você ainda não tem certeza ou apenas para evitar conflitos de código.

E é nesse sentido que surgem as ramificações — conceito também determinado de branch.

Para criar uma nova branch podemos utilizar git branch NAME , já para alteramos entre as branches existentes git checkout NAME . Vamos aos exemplos:

git branch novaBranch //cria uma nova branch
git checkout -b novaBranch //alterna para a nova branch
# gittutorial git:(novaBranch) //saída indicando nova branch

Vamos realizar uma alteração no nosso arquivo hello.txt através da nossa nova branch:

echo "\nHello, Git Branch" >> hello.txt //altera texto de hello.txt
git commit -am "Alterar hello.txt" //confirma alteração

Se retornamos para nossa branch principal (main), iremos notar que nada foi alterado nela:

git checkout main //alterna para a branch main
cat hello.txt //retorna o que tem no arquivo
# Olá, Git (saída)

Isso acontece porquê como já dito anteriormente, o conceito de ramificações é justamente isolar uma nova implementação do código fonte, para que teste sejam realizados e caso aprovado, será realizado a junção de ambos.

Mesclagem de ramificações (branches)

Como informado no último parágrafo do tópico anterior, em um determinado momento será necessário unificar a alteração feita no código da nova branch com o do código fonte (branch main). Para tanto, utilizamos o comando git merge que de uma tradução direta significa “ mesclar”.

Ainda na branch main vamos realizar a seguinte instrução:

git merge novaBranch
 #Updating 26e1c06..f98f254
 #Fast-forward
 #hello.txt | 1 +
 #1 file changed, 1 insertion(+)
cat hello.txt
 #olá, Git
 #Hello, Git Branch

Como podemos verificar, ao rodarmos o comando merge o conteúdo das branches foram unificados em um só arquivo na main. Agora, caso queiramos deletar a branch “novaBranch” basta inserirmos o comando git -d novaBranch , vejamos:

git branch -d novaBranch
 #Deleted branch novaBranch(was f98f254).

Repositório remoto

Para continuarmos com nosso tutorial será necessário criar uma conta no Github. Após, faça login e crie um novo repositório vazio (privado ou público).

Supondo que o nome do repositório seja “tutorial”, execute o seguinte comando (mude para seu nome de usuário):

git remote add origin git@github.com:USERNAME/tutorial.git
git push -u origin main

Vamos agora desvendar os comandos inseridos anteriormente:

git remote add origin: este comando adiciona um link ou chave SSH que podem ser encontrados na página do seu repositório github, para torná-los o destino de origem das suas alterações.

git push -u origin main: este comando realiza um “push” ou seja, ele puxa todo os arquivos do diretório local da sua máquina e envia para a origem, destino que foi informado com o comando explicado anteriormente.

Para realizar o papel inverso, ou seja, caso seja feito uma alteração no repositório remoto do Github, podemos através do Git unificar essas alterações ao nosso código por meio do comando git pull .

Vejamos:

git pull origin main

É isso, hoje aprendemos o básico de Git e um pouquinho de Github que já será suficiente para expor aquele projetinho para impressionar os recrutadores, mas claro, não se limite a isso existem diversos outro metódos git. Desde já, grato pela leitura!