Git — Setup

Esse card cobre o que você precisa fazer uma vez antes de começar a usar o git: instalar o programa, dizer pro git quem você é (identidade que vai assinar todos os commits), e transformar uma pasta em repositório git. No fim, sua máquina está pronta pra o próximo card, onde a gente faz o primeiro commit de verdade.

Instalando o git

O git é um programa de linha de comando. Não tem interface gráfica nativa — você abre o terminal, digita comandos. Existem clients gráficos (GitHub Desktop, Sourcetree, GitKraken) construídos por cima do git, mas eles só facilitam a vida; por baixo é o git de linha de comando que faz o trabalho.

• Windows: baixar o instalador do git-scm.com/download/win. Junto vem o Git Bash — um terminal estilo Linux que vai ser onde você vai rodar os comandos. Aceita os defaults na instalação.
• Mac: já vem instalado em versão antiga. Pra atualizar, instalar o Homebrew e rodar brew install git.
• Linux: sudo apt install git (Debian/Ubuntu) ou sudo dnf install git (Fedora).

Pra confirmar que instalou, abre o terminal (Git Bash no Windows) e digita:

git --version

Se aparecer algo como git version 2.43.0, está tudo certo. Se aparecer "comando não encontrado", a instalação não foi pro PATH — reinstala marcando a opção que adiciona ao PATH.

Configurando sua identidade

Todo commit é assinado com nome e e-mail. Quando alguém olha o histórico, vê quem fez cada commit. Essa identidade é configurada uma vez na máquina, depois o git usa em todos os repositórios automaticamente.

git config --global user.name "Flávio Passos"
git config --global user.email "flaviovmix@gmail.com"

Detalhes:

• Nome pode ter espaços (precisa estar entre aspas).
• E-mail deve ser o mesmo que você usa no GitHub — quando você fizer push, o GitHub usa esse e-mail pra associar o commit ao seu perfil. Se for diferente, o commit aparece "anônimo" lá.
• Esses comandos não dão output. Pra confirmar, lê com git config --global user.name (sem o valor depois — só leitura).

Configuração global vs local

O git tem três níveis de configuração, do mais geral pro mais específico:

• --system — vale pra todos os usuários da máquina. Raramente usado.
• --global — vale pra todos os repositórios do seu usuário. É o que você usa pra identidade. Vive em ~/.gitconfig.
• --local — vale só pro repositório onde você está. Vive em .git/config do repo. Útil quando você precisa usar identidade diferente em algum projeto específico (ex: e-mail corporativo num repo da empresa).

Sem flag, o git assume --local por padrão se você está dentro de um repo. Por isso a importância de usar --global explícito quando configura identidade — você quer que valha em todos os repos, não só no atual.

Transformando uma pasta em repositório

O comando git init transforma uma pasta qualquer em repositório git. Ele cria a subpasta oculta .git dentro dela — onde o git vai guardar todo o histórico daquele momento em diante.

cd /caminho/da/pasta
git init

O git responde com algo como Initialized empty Git repository in /caminho/da/pasta/.git/. Pronto, a pasta agora é um repositório.

Detalhes importantes:

• O git init não toca nos seus arquivos. Eles continuam exatamente onde estavam. Só nasce a .git.
• O comando é idempotente — rodar duas vezes não causa problema. Se a pasta já é um repo, ele só "reinicializa" sem perder nada.
• Pra desfazer, basta apagar a pasta .git. Os arquivos do projeto ficam, o histórico some. A pasta vira pasta normal.
• O git por padrão cria a primeira branch chamada main (versões antigas usavam master). Você só vai ver isso depois do primeiro commit, mas a branch já está reservada.

A pasta .git por dentro

Não precisa decorar, mas é bom desmistificar. Abrindo a .git, você vê:

• HEAD — arquivo apontando pra branch atual.
• config — configurações locais desse repo.
• objects/ — onde os snapshots ficam. Cada arquivo aqui é um objeto identificado por hash.
• refs/ — referências (branches, tags) apontando pros commits.
• logs/ — histórico de movimentações (a chamada reflog).

Tudo isso é manipulado pelos comandos do git. Não precisa abrir esses arquivos manualmente — e na verdade é desaconselhável fazer isso, porque uma edição errada pode corromper o repositório.

Bônus: editor padrão pra mensagens

Em alguns comandos do git (commit sem -m, rebase interativo, merge com mensagem grande), o git abre um editor de texto pra você digitar a mensagem. Por padrão no Windows é o Vim — que é poderoso mas tem curva de aprendizado.

Se preferir usar o VS Code ou Notepad++:

git config --global core.editor "code --wait"
git config --global core.editor "'C:/Program Files/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin"

O --wait no caso do VS Code faz o git esperar até você fechar o arquivo antes de continuar — sem isso, o git acharia que você não digitou nada e seguiria com mensagem vazia.

Se você sempre commitar com a flag -m "mensagem" (próximo card), nunca precisa do editor. Configurar isso é opcional.

Checklist do setup

Antes de partir pro próximo card, sua máquina deve estar com:

1. git --version respondendo com a versão.
2. git config --global user.name e git config --global user.email respondendo com seus dados.
3. Uma pasta de teste com .git dentro (depois do git init) — pode ser ~/git-teste ou qualquer lugar.

Se os 3 itens estão OK, você está pronto pra fazer o primeiro commit.