Git: Um grande aliado
Tags: github, git
Published: 2019-09-27 12:32:41

---
title: Git: Um grande aliado
published: true
tags: gitlab,github,git
canonical_url: https://medium.com/alex-ribeiro/git-um-grande-aliado-71bbebba24e3
---

![](https://cdn-images-1.medium.com/max/1024/0*augkC9jV1gsn_kFQ)<figcaption>“A pendrive in the USB port of a laptop” by <a href="https://unsplash.com/@brina_blum?utm_source=medium&amp;utm_medium=referral">Brina Blum</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption>

Para quem já é da área de desenvolvimento ou já trabalhou com versionamento de algum projeto, certamente já ouviu falar de Git.

Se ainda não domina esta ferramenta, continue lendo esta postagem que poderá te ajudar em seus projetinhos atuais e futuros.

Antes de adentrarmos no conceito do que é Git, é importante compreender o que é Controle de Versão, pois o Git (assim como outros semelhantes) utiliza-se deste sistema para fazer o que faz de melhor.

Segundo a própria documentação que se encontra no site do Git:

> O controle de versão é um sistema que registra as mudanças feitas em um arquivo ou um conjunto de arquivos ao longo do tempo de forma que você possa recuperar versões específicas.

Outros controles que podemos ter com essas premissas de um controle de versão é a possibilidade de identificar quem é responsável por qualquer modificação, assim como mapear origem de bugs e até mesmo comparar o avanço das mudanças feitas no decorrer do tempo.

Isso é demais! Imagina quanta segurança e praticidade que isso proporciona sobre nossos projetos?! Alguns pontos importantes:

- Integridade: controle sobre qualquer alteração nos arquivos ou estrutura do projeto;
- Autenticidade: controle sobre as propriedades e origem dos arquivos de forma a comprovar quem é responsável ou quem alterou algo;
- Disponibilidade: dependendo de onde os arquivos estiverem armazenados, pode-se acessar os projetos de qualquer máquina pela internet ou rede local;
- Confidencialidade: dependendo de como e onde os arquivos estiverem armazenados, pode-se ter controle de autorização de acesso aos mesmos.

![](https://media.giphy.com/media/oYtVHSxngR3lC/giphy.gif)

> Incrível o quanto essa ferramenta pode fazer, néh?!

### Afinal, o que é Git?

Git é um sistema de controle de versão de arquivos de forma distribuída, permitindo até mesmo que mais de uma pessoa trabalhe no mesmo projeto.

Existem diversos sistemas de controle de versão, mas o diferencial do Git é seu foco em velocidade, colocando maior parte dos controle de forma local sem necessidade imediatada de alguma conexão com o repositório principal.

Outro ponto diferencial do Git é a forma como versiona e garante a integridade dos arquivos, pois ele utiliza-se da ideia de branchs (semelhante ao que seriam snapshots), que podem ser criadas a qualquer instante, ou seja, nos permite ter cópias do mesmo projeto e na mesma pasta.

Um exemplo simples e prático da utilização dessas vantagens do git: Estou com meu website na branch principal (master) e quero testar algo novo sem interferir no que está pronto e funcional. Crio uma nova branch, a partir dela já poderei alterar o que quiser do projeto. Assim que tudo estiver pronto e testado, pego essas alteração e faço uma união com a branch principal (esta união é chamada de merge). Caso ocorra algum problema na branch principal, posso reverter facilmente qualquer alteração feita para um estado anterior.

### Lista de comandos

Git possui uma variedade de ferramentas que podem ser utilizadas por comandos via terminal. Pode conferir estes comandos logo abaixo.

#### Criar

Clona um repositório existente:

```
$ git clone ssh://user@domain.com/repo.git
```

Cria um novo repositório local:

```
$ git init
```

#### Modificações locais

Arquivos modificados no diretório ativo:

```
$ git status
```

Modificações em arquivos versionados:

```
$ git diff
```

Add all current changes to the next commit:

```
$ git add .
```

Adiciona as mudanças do \<file\> no próximo commit:

```
$ git add -p \<file\>
```

Commita todas as modificações de arquivos versionados:

```
$ git commit -a
```

Commita modificações preparadas:

```
$ git commit
```

Modifica o último commit:

```
$ git commit --amend
```

#### Linha do tempo

Mostra todos os commits, começando pelo mais novo:

```
$ git log
```

Mostra as modificações para um arquivo específico:

```
$ git log -p \<file\>
```

Quem mudou o quê e quando em um arquivo:

```
$ git blame \<file\>
```

#### Branchs e tags

Lista todas as branches existentes:

```
$ git branch -av
```

Muda a branch atual:

```
$ git checkout \<branch\>
```

Cria uma branch a partir do HEAD atual:

```
$ git branch \<new-branch\>
```

Deleta uma branch local:

```
$ git checkout --track \<remote/branch\>
```

Delete a local branch:

```
$ git branch -d \<branch\>
```

Marca o commit atual com uma tag:

```
$ git tag \<tag-name\>
```

#### Atualizar e publicar

Lista todos os remotes configurados atualmente

```
$ git remote -v
```

Mostra informações sobre um remote:

```
$ git remote show \<remote\>
```

Adiciona um novo repositório remoto, nomeado \<remote\>:

```
$ git remote add \<shortname\> \<url\>
```

Baixa todas as modificações do \<remote\>, mas não integra ao HEAD:

```
$ git fetch \<remote\>
```

Baixa as modificação e automaticamente faz o merge:

```
$ git pull \<remote\> \<branch\>
```

Publica as modificações locais em um remote:

```
$ git push \<remote\> \<branch\>
```

Deleta uma branch no remote:

```
$ git branch -dr \<remote/branch\>
```

Publica suas tags:

```
$ git push — tags
```

#### Merge e rebase

Fazer merge da \<branch\> no HEAD atual:

```
$ git merge \<branch\>
```

Fazer rebase do seu HEAD na \<branch\>:

```
$ git rebase \<branch\>
```

Abortar um rebase:

```
$ git rebase --abort
```

Continuar um rebase depois de resolver conflitos:

```
$ git rebase --continue
```

Usar a sua ferramente de merge configurada para resolver conflitos:

```
$ git mergetool
```

Use seu editor para resolver conflitos manualmente e marcar o arquivo como resolvido:

```
$ git add \<resolved-file\>

$ git rm \<resolved-file\>
```

#### Desfazer

Descarta todas as mudanças locais no diretório atual:

```
$ git reset --hard HEAD
```

Descarta mudanças locais em um arquivo específico:

```
$ git checkout HEAD \<file\>
```

Reverte um commit (criando um novo com as modifições ao contrário):

```
$ git revert \<commit\>
```

Reseta o ponteiro do HEAD para um commit anterior

…e descarta as modificações desde então:

```
$ git reset --hard \<commit\>
```

…e preserva todas as modificações como modificações não preparadas:

```
$ git reset \<commit\>
```

…e preserva modificações locais não commitadas:

```
$ git reset --keep \<commit
```

> Eu sei, é muita coisa.

![](https://media.giphy.com/media/ijGS9TME6iN7W/source.gif)

### Workflow básico

O fluxo de trabalho com o Git geralmente é uma sequencia bem simples:

1. Você modifica o arquivo ou grupo de arquivos no seu diretório de trabalho;
2. Você seleciona os arquivos, adicionando snapshots deles para sua área de preparação;
3. Você faz um commit, que leva os arquivos como eles estão na sua área de preparação e os armazena permanentemente no seu diretório Git.

### Dica

Se você quiser ou precisar praticar os principais fluxos de trabalho com o Git, recomendo esse site: [http://aprenda.vidageek.net/aprenda/git](http://aprenda.vidageek.net/aprenda/git).

Por ele poderá praticar de forma simplificada e objetiva os diversos comandos do Git.

### Referências

- [https://git-scm.com/book/pt-br/v1](https://git-scm.com/book/pt-br/v1/Primeiros-passos-No%C3%A7%C3%B5es-B%C3%A1sicas-de-Git)
- [https://www.oficinadanet.com.br/post/16111-o-que-e-e-como-funciona-o-git-e-github](https://www.oficinadanet.com.br/post/16111-o-que-e-e-como-funciona-o-git-e-github)
- [https://pt.wikipedia.org/wiki/Git](https://pt.wikipedia.org/wiki/Git)
- [https://www.git-tower.com/blog/git-cheat-sheet](https://www.git-tower.com/blog/git-cheat-sheet)

#### Obrigado e até mais!

Se gostou do meu texto, me acompanhe que em breve estarei trazendo novidades.

Quer saber mais sobre o assunto ou tem alguma dúvida? Deixe um comentário. Ah, estou aberto a críticas também.

Abraço!

* * *