Esse tópico é sobre uma ferramenta muito útil e importante, conhecida por muita gente da área de programação e necessária para qualquer pessoa que queira uma oportunidade no mercado de trabalho, o GIT.

Você já deve ter ouvido falar e talvez até já trabalhe com essa tecnologia feita de branches e commits, mas como que você utiliza o GIT atualmente? Pela UI do VS Code ou do WebStorm? Por algum programa específico como o Git Desktop? Ou pelo terminal?

Por mais que seja muito legal utilizar interfaces que deixam o GIT mais interativo para nós - e eu mesmo utilizo essas interfaces - eu acredito que temos que ir além e aprender como utilizar os comandos diretamente pelo terminal, porque nem tudo esses programas conseguem resolver.

Por isso eu separei os comandos que mais usei e uso até hoje e vou passar um por um, utilizando um repositório no GitHub que vamos criar.

git clone

O primeiro comando que quero apresentar é o git clone. Esse comando é utilizado para baixar repositórios existentes, seja no GitHub ou qualquer outra plataforma que usa GIT, mas esse download é feito de forma local dentro da sua máquina.

Vamos utilizar o exemplo do thon-ui que é um projeto open source que estou trabalhando.

git clone <url_do_projeto>

# Exemplo
git clone https://github.com/guscsales/thon-ui.git

Para subir código em repositórios alheios é necessário fazer um fork - que é uma cópia do projeto original, mas atrelado a sua conta, e então fazer as alterações e abrir uma pull request, que é uma forma de o dono do repo analisar seu código e aprovar o mesmo para ser mergado. Caso o projeto seja seu, você pode executar qualquer comando que quiser.

git init

Agora indo para projetos que você vai criar do zero, o principal comando para inicializar o git é o git init. Ao executar esse comando uma pasta chamada .git é criada no diretório onde ele foi executado e nessa pasta você pode fazer o link para a origem (origin) remota, que no nosso caso será o GitHub.

Antes de executar o init, vamos criar um projeto no GitHub. Vá até o "New Repository” no lado direito superior da tela:

Então dê o nome do repositório de "comandos-principais-git” e deixe como público, logo após pode clicar em "Create repository”.

Logo que criamos o repo, o GitHub nos da 2 opções de blocos de comandos, que sao, 1) criar um novo repo do zero utilizando git init ou 2) adicionar a um projeto git já existente. Vamos seguir a primeira opção que engloba todos os comandos que quero passar aqui.

git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin <url_do_seu_projeto>
git push -u origin main

Crie uma pasta chamada "comandos-principais-git” em qualquer lugar que desejar e logo após em seu terminal, execute o git init. Você irá ver uma mensagem de inicialização feita com sucesso.

git add

Logo depois que o projeto git foi criado nós precisamos executar o comando git add. Esse comando vai transportar todos os arquivos, sejam novos ou modificados para um lugar chamado "stage”. Podemos adicionar arquivo por arquivo, ou então todos de uma vez.

Crie um arquivo index.html e um outro chamado README.md apenas para fins didáticos. Logo após você pode executar o git add dessas formas:

git add <. ou arquivo ou pasta>

# Adicionando todos os arquivos e pastas
git add .

# Adicionando um arquivo
git add index.html

# Adicionando uma pasta
git add assets

git status

Antes de ir para o próximo comando da linha eu quero mostrar outro muito útil que é o git status. Com ele nós conseguimos ver o que está no "stage” e o que não está. Assim fica mais claro entender o que vai para o commit e o que não vai.

git status

git commit

Você pode estar se perguntando: "ok Gus, mas o que é commit?”, e eu quero responder isso agora mesmo para você. Provavelmente esse é o comando mais usado de todos, eu mesmo já perdi as contas de quantos commits já fiz na minha vida como dev.

O git commit cria para você um registro com uma mensagem daquilo que você jogou em "stage” através do comando add.

E aí que está o pulo do gato no GIT, tudo o que você faz fica registrado e versionado, quando se tem commits bem feitos e organizados é muito fácil de entender qualquer parte do projeto, não importa quanto tempo ele tem de existência, por isso procure sempre ser bem organizado em seus commits, e procure dividir as modificações em vários commits, evitando subir muitos arquivos de uma vez com uma mensagem genérica.

Para executar siga o comando abaixo (sem esquecer o -m):

git commit -m <mensagem_do_commit>

# Exemplo
git commit -m "feat(auth): create login screen"

É muito legal se você puder seguir o padrão de conventional commits criados pela comunidade, são como se fossem boas práticas para criar commits e tem um artigo aqui que aborda um pouco essa forma de commits.

git push

Como estamos criando o repo e subindo ele para o GitHub é necessário executar dois comandos antes do push, mas você não precisa fazer isso sempre.

O comando git branch com -M define qual a sua branch, ou seja, sua ramificação de código principal, vamos falar mais sobre branches logo no próximo tópico. Por padrão o Git já está criando com o nome main e nós vamos manter assim, então não é necessário executar esse comando.

O git add com remote, vai atualizar sua pasta .git adicionando a origem remota do Git, que no caso irá para esse repositório. Então podemos tranquilamente executar esse comando para linkar nosso projeto local, com o projeto criado lá no GitHub.

git remote add origin <url_do_seu_projeto>

Por fim, finalmente vamos executar o git push. Esse comando faz com que todos os nossos commits sejam empurrados (tipo um upload) na origem do repositório, nesse caso aqui, dentro do GitHub. Ao executar com o -u você está dizendo que essa branch faz parte de um repositório remoto, o -u é uma abreviação para o --set-upstream. Não será necessário utilizar o -u o tempo todo, apenas quando novas branches forem criadas para joga-las no GitHub.

git push -u origin main

Após fazer isso, você irá ver que seu projeto está dentro do GitHub!

git pull

Bom, subir commits é algo comum para qualquer dev, porém não para por ai. Normalmente nós trabalhamos em equipe e outros devs também fazer pushes dos seus commits, por isso nós temos que saber como atualizar nosso projeto com os commits deles e aí que entra o git pull.

Ao rodar esse comando em qualquer branch, seja na main ou em outra, você consegue pegar a última versão que está na origem remota, ou seja, todos os commits das pessoas que trabalharam naquele projeto vai diretamente para você.

git pull

# Se precisar buscar na origin, quando não foi feito `git push -u`
git pull origin <nome_da_branch>

Uma nota importante, se você fez um push com -u em algum momento, apenas um git pull dentro da branch será necessário, mas caso você não tenha feito isso, para baixar as atualizações será necessário rodar um git pull com origin <nome_da_branch>.

git checkout

Estamos falando muito de branches, mas até agora eu não falei o que é isso propriamente, muito bem dito por mim: até agora.

O git checkout acessa branches, ou seja, ramificações existentes (locais ou remotas) e também cria uma nova branch a partir de outra que você já esteja, quando acompanhado do -b em sua execução.

Já assistiu aquela série do Loki, quando aparece um monte de linhas temporais ramificada a partir da linha temporal principal, ou até mesmo de outras? O Git pode ser muito bem representado por aquilo.

As branches normalmente são utilizadas para criar novas features sem precisar afetar a linha principal, ou seja, a branch main. E logo depois do trabalho concluído essa branch pode ser mergeada na main ou em qualquer outra branch, seja principal ou não.

Para acessar ou criar uma nova branch, siga o comando abaixo:

git checkout <nome_da_branch>

# Para criar uma nova branch
git checkout -b <nome_da_branch>

git branch

Continuando no assunto de branches, nós vimos que o checkout cria ou acessa uma branch existente. Mas como podemos fazer para saber quais branches existem dentro daquele repositório git? Muito simples, apenas executando o comando git branch.

git branch

Além de apenas listar, é possivel deletar branches locais com esse comando, apenas utlizando o -d antes do nome da branch.

git branch -D <nome_da_branch>

E para deletar branches remotas, basta executar o push novamente, mas com um parâmetro a mais, que é o --delete.

git push --delete origin <nome_da_branch>

Vale lembrar que é sempre legal deixar a branch atualizada com a branch principal, para evitar conflitos.

git rebase

Como posso deixar essa minha branch que foi criada a partir da main atualizada então? Existe um comando muito útil para isso no GIT que é o chamado git rebase.

O rebase basicamente pega todos os commits da branch que você escolheu e que não fazem parte da sua branch e coloca eles lá, de forma ordenada, criando um histórico linear, sem envolver outros commits intermediários.

Então vamos para um exemplo aqui:

• Você criou uma branch chamada tela-de-login com base na main.
• Seu colega de time criou uma branch chamada tela-de-signup com base na main.
• Seu colega então terminou o trabalho que ele estava fazendo e todos os commits da branch dele foram para a main
• Você subiu um novo commit na sua branch minutos depois, mas ao abrir a pull request, percebeu que sua branch não está atualizada com a main
• Então você executa o git rebase para atualizar sua branch, e colocar todos os novos commits feitos pelo seu colega na sua branch e assim ficar "up to date” com a base, que é a main

git rebase <nome_da_branch>

Com o git rebase, normalmente você vai precisar fazer um git push com -f para forçar os novos commits e impedir que conflitos aconteçam.

git push -f

Existem muitos outros comandos, como git merge, git diff, git cherry-pick, git config, git branch, git stash, git log, e outros que são muito úteis no seu dia a dia, além também de todo o processo de abertura de pull request, que é algo bem comum na rotina de um dev. Vale muito a pena se aprofundar em Git cada vez mais!

Obrigado mais uma vez pela oportunidade de compartilhar conhecimento. Adoraria ler o feedback de vocês e discutir sobre.

Autor: Gustavo Sales