Aprendendo Git Branching - Módulo Acelerando
Tags: git
Published: 2023-06-08 15:33:08

---
title: Aprendendo Git Branching - Módulo Acelerando
published: true
description: Série de posts sobre o site/aplicativo Aprendendo Git Branching. Aqui vou postar os comandos que aprendi e o que entendi de cada um.
tags: git
series: Learning Git Branching
---
**WIP**: A descrição e explicação dos comandos está sendo postada [aqui](https://dev.to/epochchrono/aprendendo-git-branching-comandos-24d2) conforme o avanço.

## levels
### Main
#### Módulo: Acelerando
##### 1: Solte a sua cabeça
###### Dificuldade (pra mim!): fácil
- HEAD é um nome simbólico para o commit atualmente ativo (que sofreu checkout por último) -- é essencialmente o commit sobre o qual você está trabalhando no momento.
- O HEAD sempre aponta para o commit mais recentemente copiado sobre a árvore de trabalho (arquivos do projeto). 
- Normalmente o HEAD aponta para o nome de um branch (por exemplo, bugFix). Quando você commita, o status do bugFix é alterado e essa mudança ocorre também sobre o HEAD.
- Soltar o HEAD significa anexá-lo a um commit em vez de anexá-lo a um branch. Antes do estado solto ("detached"), é assim como se parece:

> `HEAD -> main -> C1`

- Depois do comando `git checkout C1`, fica:

> `HEAD -> C1`

##### 2: Referências relativas (`^`)
###### Dificuldade (pra mim!): fácil
- Mover-se pela árvore do Git especificando o hash do commit pode se tornar um pouco entediante. No mundo real, você não terá à sua disposição essa bonita visualização da árvore ao lado do seu terminal, então você terá de usar o comando `git log` para ver os hashes.
- Além disso, os hashes são geralmente muito maiores no mundo real. Por exemplo, o hash do commit que introduziu o nível de exercícios anterior é `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. Não é algo exatamente fácil de lembrar.
- O que salva é que o Git é inteligente com os hashes. Ele só exige que você especifique a quantidade de caracteres do hash suficiente para identificar unicamente o commit.
- Com referências relativas, você pode começar a partir de um ponto fácil de lembrar (como o branch `bugFix` ou o `HEAD`) e referenciar a partir dali.
- Commits relativos são poderosos, mas vamos introduzir apenas dois tipos simples aqui:
  - Mover para cima um commit por vez com `^`
  - Mover para cima um número de vezes com `~<num>`
- Vamos dar uma olhada no operador circunflexo (`^`) primeiro. Cada vez que você adicioná-lo a um nome de referência, você está dizendo ao Git para encontrar o pai do commit especificado.
- Então, dizer `main^` é equivalente a "o primeiro pai do main".
- `main^^` é o avô (ancestral de segunda geração) do main

##### 3: Referências relativas #2 (`~`)
###### Dificuldade (pra mim!): difícil
- Digamos que você queira se mover vários níveis para cima na árvore de commits. Pode ser entediante digitar `^` várias vezes, e por isso o Git possui também o operador til (`~`).
- Um número pode ser passado (opcionalmente) após o operador til, especificando o número de ancestrais que você deseja subir. 
- Uma das situações mais comuns na qual eu uso referências relativas é quando quero trocar branches de lugar. Você pode redefinir diretamente o commit para o qual um branch aponta com a opção `-f`. Desta forma, o seguinte comando:

> `git branch -f main HEAD~3`

- Move (à força) o branch main 3 ancestrais acima do HEAD.
 
##### 4: Referências relativas #3 (`~`)
###### Dificuldade (pra mim!): médio
- Existem várias maneiras de reverter mudanças no Git. E assim como o ato de commitar, reverter mudanças no Git também tem um componente de baixo nível (a preparação, ou staging, de arquivos ou trechos de arquivos individuais) e um componente de alto nível (como as mudanças são, de fato, revertidas). 
- Há duas maneiras principais de desfazer mudanças no Git -- uma delas é usando `git reset`, e a outra é usando `git revert`. Vamos olhar cada uma delas na próxima janela
- O comando `git reset` reverte mudanças movendo para trás no tempo (para um commit mais antigo) a referência do branch. Desta forma, você pode pensar nessa operação como uma "reescrita do histórico"; o `git reset` vai mover o branch para trás como se o commit nunca tivesse existido.
- Embora o  reset  funcione muito bem em branches locais no seu próprio computador, o método utilizado de "reescrever o histórico" não funciona com branches remotos que outras pessoas estejam usando.
- Para reverter mudanças e conseguir compartilhar essas mudanças com os outros, precisamos usar o `git revert`.
- Quando usamos o `revert` um novo commit é criado A FRENTE na árvore. Isso é porque o novo commit C2' introduz mudanças -- acontece que as mudanças que ele introduz revertem exatamente aquelas do commit C2.
- Com o `revert`, você pode fazer push das suas mudanças para compartilhá-las com os outros.