Guia rápido e prático dos principais comandos git

Desenvolva de uma vez por todas a capacidade de versionar e tratar corretamente seus arquivos com o git, o sistema de controle de versão mais utilizado.

Git é um sistema de controle de versão gratuito e de código aberto, originalmente criado por 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

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:
```
git config --global user.name "seu nome"
```

De maneira análoga, o email:

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:
```
git init "nome-do-projeto"
```
Realiza o download de um projeto existente, bem como todo o seu histórico de versão:
```
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:
```
git status
```
Mostra diferenças nos arquivos que ainda não foram adicionadas:
```
git diff
```
Adiciona o seu estado atual para ser commitado e realiza um snapshot 📸 do arquivo:
```
git add "arquivo"
```
Mostra a diferença entre arquivos selecionados e a suas últimas versões já 'commitadas':
```
git diff --staged
```
Desmarca o arquivo, mas preserva seu conteúdo atual:
```
git reset "arquivo"
```
Salva o último snapshot realizado no arquivo permanentemente no histórico de versão:
```
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:
```
git branch
```
Cria uma nova ramificação:
```
git branch "nome-da-ramificação"
```
Muda para uma ramificação específica e atualiza o diretório de trabalho atual:
```
git checkout "nome-da-ramificação"
```
Combina o histórico de uma ramificação específica com a ramificação atual:
```
git merge "nome-de-uma-ramificação"
```
Exclui uma ramificação específica:
```
git branch -d "nome-da-ramificação"
```

Alterações de nomeclatura

Mude e remova os arquivos versionados

Remove o arquivo do diretório atual de trabalho e seleciona o mesmo para ser removido:
```
git rm "arquivo"
```
Remove o arquivo do controle de versão, mas preserva seu estado localmente:
```
git rm --cached "arquivo"
```

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

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:

build/
.env

Essas especificações não permitem que arquivos presentes no diretório build, ou arquivos que possuem extençã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:

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:
```
git stash
```
Aplica as alterações presentes no último stash:
```
git stash apply
```
Restaura os arquivos recentes em stash:
```
git stash pop
```
Lista todos os conjuntos de alterações presentes em stash:
```
git stash list
```
Descarta os conjuntos de alterações mais recentes em stash:
```
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:
```
git log
```
Lista o histórico de versões para um arquivo, incluindo mudanças em seu nome:
```
git log --follow "arquivo"
```

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

git diff "primeira-ramificação"..."segunda-ramificação"

Retorna mudanças de metadata e conteúdo para o commit especificado:
```
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:
```
git reset "commit"
```
Retorna ao estado do commit passado, mas desfazendo todas as alterações e commits realizados após ele:
```
git reset --hard "commit"
```

Sincronize e salve as suas alterações

Baixa todo o histórico de um marcador de repositório:
```
git fetch "marcador"
```
Combina o marcador da ramificação passada na ramificação local:
```
git merge "marcador"/"branch"
```
Envia todos os commits da ramificação local para a sua versão remota:
```
git push "alias" "branch"
```
Baixa o histórico presente no repositório remoto e incorpora as mudanças no repositório local:
```
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, GitLab, 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, deixo abaixo algumas referências que você poderá utilizar para se aventurar.

Espero que tenha gostado desse Tabs e que ele tenha te ajudado de alguma forma a encontrar o que você procurava! 💙