[pt-br] Guia rápido e prático dos principais comandos git
Tags: git, gitlab, github, codequality
Published: 2022-04-11 00:02:36

[Git](https://pt.wikipedia.org/wiki/Git) é um sistema de controle de versão gratuito e de código aberto, originalmente criado por [Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds) no ano de 2005. Ao contrário de sistemas de controle de versão centralizados mais antigos, como o SVN e CVS, o Git é distribuído, pois todo desenvolvedor tem o histórico completo de seu repositório de código localmente.

O Git também oferece excelente suporte para ramificação, mesclagem e reescrita do histórico do repositório, o que levou a muitos fluxos de trabalho e ferramentas inovadoras e poderosas. As solicitações pull é uma ferramenta popular que permite que as equipes colaborem em ramificações do Git e revisem com eficiência o código uns dos outros. Atualmente, o Git é o sistema de controle de versão mais utilizado no mundo e é considerado o padrão moderno para desenvolvimento de software.

## Certo! mas por onde eu começo? 🤔
 
É simples: instale o Git na sua máquina! fácil, não é? atualmente o Git está disponível para as mais diversas plataformas e você pode encontrar como realizar esse download/instalação no seu próprio site.

🔗 [Git para todas as plataformas ](http://git-scm.com/)

## Configure o Git em sua máquina 
Configure informações de usuário para todos os repositórios. 👨‍💻

- Primeiramente, podemos configurar o nome que você quer ligado as suas transações de commit:

```bash
$ git config --global user.name "seu nome"
```

- De maneira análoga, o email:

```bash
$ git config --global user.email "endereco-de-email"
```

Com isso, você já está apto a usar o git e ter suas informações vinculadas a seus commits.

## Criando Repositórios 
Inicie um novo repositório ou obtenha algum já existente.

- Inicia um novo repositório `local` com um nome específico:

```bash
$ git init "nome-do-projeto"
```

- Realiza o download de um projeto existente, bem como todo o seu histórico de versão:

```bash
$ git clone "url"
```

## Realizando e revisando alterações
Revise edições, verifique o status de arquivos e crie transação de commit 🧐

- Lista todos os arquivos novos, modificados e/ou deletados para serem commitados:

```bash
$ git status
```

- Mostra diferenças nos arquivos que ainda não foram adicionadas:

```bash
$ git diff
```

- Adiciona o seu estado atual para ser commitado e realiza um snapshot 📸 do arquivo:

```bash
$ git add "arquivo"
```

- Mostra a diferença entre arquivos selecionados e a suas últimas versões já 'commitadas':

```bash
$ git diff --staged
```

- Desmarca o arquivo, mas preserva seu conteúdo atual:

```bash
$ git reset "arquivo"
```

- Salva o último snapshot realizado no arquivo permanentemente no histórico de versão:

```bash
$ git commit -m "mensagem descritiva do commit"
```

## Mudanças agrupadas 
Nomeie uma série de commits e, em seguida, combine as alterações adequadamente em uma ramificação

- Lista todas as ramificações (branches) locais no repositório atual:

```bash
$ git branch
```

- Cria uma nova ramificação:

```bash
$ git branch "nome-da-ramificação"
```

- Muda para uma ramificação específica e atualiza o diretório de trabalho atual:

```bash
$ git checkout "nome-da-ramificação"
```

- Combina o histórico de uma ramificação específica com a ramificação atual:

```bash
$ git merge "nome-de-uma-ramificação"
```

- Exclui uma ramificação específica:

```bash
$ git branch -d "nome-da-ramificação"
```

## Alterações de nomenclatura
 
Mude e remova os arquivos versionados

- Remove o arquivo do diretório atual de trabalho e seleciona o mesmo para ser removido:

```bash
$ git rm "arquivo"
```

- Remove o arquivo do controle de versão, mas preserva seu estado localmente:

```bash
$ git rm --cached "arquivo"
```

- Muda o nome do arquivo e o seleciona para o commit:

```bash
$ git mv "arquivo-com-nome-atual" "arquivo-com-nome-renomeado"
```

## Evite o rastreamento não desejados
 
Crie exceções para arquivos que você deseja que não sejam rastreados e adicionados ao histórico de versão do seu projeto. Para isso, se torna necessária a criação de um arquivo de texto comum na raiz do projeto de nome específico: `.gitignore` 🕵️

Este arquivo serve para suprimir o versionamento acidental de arquivos e diretórios correspondentes aos padrões especificados, como por exemplo:

```bash
build/
.env
```

Essas especificações não permitem que arquivos presentes no diretório `build`, ou arquivos que possuem extensão `.env` presente em **todo o projeto**, sejam rastreados ou adicionados acidentalmente para o histórico de versão.

Para listar os arquivos ignorados no projeto a partir dos padrões presentes no `gitignore`, use o comando abaixo:


```bash
$ git ls-files --other --ignored --exclude-standard
```

## Salve fragmentos de código 
Arquive, restaure e/ou exclua estágios e alterações incompletas presentes no projeto.

- Armazena temporariamente as modificações de todos os arquivos já rastreados:

```bash
$ git stash
```

- Aplica as alterações presentes no último stash:

```bash
$ git stash apply
```

- Restaura os arquivos recentes em stash:

```bash
$ git stash pop
```

- Lista todos os conjuntos de alterações presentes em stash:

```bash
$ git stash list
```

- Descarta os conjuntos de alterações mais recentes em stash:

```bash
$ git stash drop
```

## Revise seu histórico de versão 
Navegue, valide e inspecione a evolução dos arquivos presentes no projeto.

- Lista todo o histórico de versões para o branch atual:

```bash
$ git log
```

- Lista o histórico de versões para um arquivo, incluindo mudanças em seu nome:

```bash
$ git log --follow "arquivo"
```

- Mostra a diferença de conteúdo entre duas ramificações:

```bash
$ git diff "primeira-ramificação"..."segunda-ramificação"
```

- Retorna mudanças de metadata e conteúdo para o commit especificado:

```bash
$ git show "commit"
```

## Reabra seus commits
 
Desfaça enganos cometidos e crie um histórico substituto 

- Volta o histórico de versão ao estado do commit passado, mas mantendo as alterações no espaço de trabalho:

```bash
$ git reset "commit"
```

- Retorna ao estado do commit passado, mas desfazendo todas as alterações e commits realizados após ele:

```bash
$ git reset --hard "commit"
```

- Sincronize e salve as suas alterações 
Baixa todo o histórico de um marcador de repositório:


```bash
$ git fetch "marcador"
```

- Combina o marcador da ramificação passada na ramificação local:


```bash
$ git merge "marcador"/"branch"
```

- Envia todos os commits da ramificação local para a sua versão remota:


```bash
$ git push "alias" "branch"
```

- Baixa o histórico presente no repositório remoto e incorpora as mudanças no repositório local:


```bash
$ git pull
```

Ufaa! 😅

Sem dúvidas você está com mais do que o necessário para versionar o seu código de maneira correta e segura. O bom de se utilizar do git é que, como foi citado anteriormente, ele é globalmente utilizado, o que possibilita aplicarmos esse conhecimento adquirido em qualquer plataforma que disfrute de seus serviços, como o [Github](https://github.com/), [GitLab](https://gitlab.com/), etc.

Pode ter certeza que existem muitos outros comandos presentes no git que poderão te ajudar no dia a dia, mas essa listagem de comandos acima consegue te dar um ferramental muito forte para começar. Contudo, como de costume, deixo abaixo algumas referências que você poderá utilizar para desbravar esse mundo do versionamento de código.

Espero que tenha gostado dessa postagem e que ela tenha te ajudado de alguma forma a encontrar o que você procurava! 💙

_Veja mais em meu [blog](https://blog.ernane.dev/)!_

## Links 
- [Documentação do Git em seu site oficial](https://git-scm.com/docs/);
- [Folha de dicas de Git proporcionado pelo GitHub](https://training.github.com/downloads/pt_BR/github-git-cheat-sheet.pdf).