GIT e GitHub: Do Zero ao Hero no Controle de Versões

#GitHub
#Git

Introdução: Por que GIT e GitHub São o Combo Perfeito para Sua Jornada Tech?

Imagine você, começando a programar, com ideias brilhando na cabeça, mas se perdendo em pastas como projeto-v2-final ou teste-3-ok. Ou pior: trabalhando em equipe e sobrescrevendo o código do colega por acidente. Soa familiar? É aqui que GIT entra como um super-herói silencioso, trazendo organização, segurança e colaboração. E o GitHub? Ele é a plataforma que leva seu código para o mundo, conectando você a milhões de devs. Neste artigo, vamos guiá-lo do nível zero — sem saber nada — até o nível hero, dominando fluxos profissionais com exemplos práticos. Preparado para transformar caos em código organizado? Vamos mergulhar!

O que é GIT? Seu Primeiro Passo no Controle de Versão

GIT é um sistema de controle de versão distribuído, criado em 2005 por Linus Torvalds (o cara do Linux!). Ele rastreia mudanças no código, permitindo voltar no tempo, experimentar sem medo e colaborar sem conflitos. Pense nele como um caderno mágico que guarda todas as versões do seu projeto.

Por que GIT é essencial?

Segurança: Reverte erros com um comando.
Colaboração: Equipes trabalham juntas sem caos.
Histórico: Cada alteração é registrada.
Flexibilidade: Funciona offline e em qualquer projeto.

Primeiros passos com GIT

Instale o GIT: Baixe em git-scm.com e instale.
Configure seu perfil:

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

Verifique a instalação:

git --version

GitHub: O Lar do Seu Código na Nuvem

Se GIT é o motor, GitHub é a estrada. Criado em 2008, GitHub é uma plataforma que hospeda repositórios GIT, adicionando colaboração, revisão de código e automação. Com 56 milhões de usuários em 2024, segundo Kansara, é o lugar para mostrar seu trabalho ao mundo.

GIT vs GitHub: Qual a diferença?

GIT: Ferramenta local para versionamento.
GitHub: Plataforma online para armazenar e colaborar.
Exemplo prático: GIT gerencia suas alterações no PC; GitHub compartilha elas com sua equipe.

Crie sua conta no GitHub

Acesse github.com e clique em Sign up.
Preencha e-mail, senha e nome de usuário.
Confirme o e-mail e escolha o plano gratuito.

Iniciando com GIT: Seu Primeiro Repositório

Pronto para sujar as mãos? Vamos criar um repositório local e aprender os comandos básicos do GIT. É como montar a base do seu castelo de código.

Criando um repositório

Crie uma pasta:

mkdir meu-projeto
cd meu-projeto

Inicialize o GIT:

git init

Adicione um arquivo (ex.: index.html):

echo "<h1>Olá, GIT!</h1>" > index.html

Comandos essenciais

Verificar estado:

git status

Adicionar arquivos:

git add .

Fazer um commit:

git commit -m "Primeiro commit: adiciona index.html"

Conectando ao GitHub: Do Local ao Global

Agora que seu projeto está versionado localmente, é hora de publicá-lo no GitHub para colaboração ou portfólio.

Passo a passo para subir ao GitHub

Crie um repositório no GitHub:

Na página inicial, clique em New.
Nomeie (ex.: meu-projeto), marque Public e Add a README.

Conecte o repositório local:

git remote add origin https://github.com/seu-usuario/meu-projeto.git

Envie as alterações:

git push -u origin main

Dica de ouro

Sempre verifique com git status antes de push para evitar erros.

Branches: Trabalhando em Universos Paralelos

Branches são o superpoder do GIT. Elas criam linhas independentes de desenvolvimento, perfeitas para novas funcionalidades ou correções sem bagunçar o código principal.

Como criar e usar branches

Crie uma branch:

git checkout -b feature/nova-pagina

Faça alterações (ex.: edite index.html).
Commit as mudanças:

git add .
git commit -m "Adiciona nova página"

Volte à branch principal:

git checkout main

Por que usar branches?

Isolamento: Teste ideias sem riscos.
Colaboração: Cada dev trabalha em sua branch.
Organização: Separa tarefas por propósito.

Merge: Unindo Suas Ideias ao Código Principal

Depois de desenvolver em uma branch, é hora de mesclar suas mudanças na main. O merge combina os universos paralelos do GIT.

Fazendo um merge

Volte à branch principal:

git checkout main

Mescle a branch:

git merge feature/nova-pagina

Envie ao GitHub:

git push origin main

Resolvendo conflitos

Conflitos ocorrem quando o mesmo trecho é editado em ambas as branches.
O GIT marca conflitos no arquivo:

<<<<<<< HEAD
Texto da main
=======
Texto da feature
>>>>>>> feature/nova-pagina

Para resolver:

1. Abra o arquivo e identifique as alterações conflitantes.

2. Edite o arquivo para combinar as mudanças da melhor forma.

3. Remova os marcadores `<<<<<<<`, `=======` e `>>>>>>>`.

4. Salve, adicione e conclua o merge com um commit.

git add .
git commit

Colaboração com Pull Requests no GitHub

No GitHub, pull requests (PRs) são a ponte para colaboração. Eles permitem revisar e discutir mudanças antes do merge.

Criando um pull request

Envie sua branch ao GitHub:

git push origin feature/nova-pagina

No GitHub, clique em Compare & pull request.
Descreva as mudanças e clique em Create pull request.
Após revisão, clique em Merge pull request.

Boas práticas para PRs

Escreva descrições claras.
Divida grandes mudanças em PRs menores.
Inclua testes para validar o código.

Dicas Avançadas:

Cherry-pick, Stash e Rebase

Depois de dominar o básico, é hora de explorar comandos avançados.

O comando cherry-pick permite aplicar commits específicos de uma branch em outra.

git cherry-pick <commit-hash>

O stash salva temporariamente mudanças não commitadas, permitindo trocar de branch sem perder o trabalho.

git stash save "Trabalho em andamento"
git stash pop

Por fim, o rebase reescreve o histórico da branch, aplicando os commits sobre a branch principal.

git checkout minha-feature
git rebase main

Manipulação do Histórico e Rastreamento de Alterações

Git Reset

O comando `git reset` desfaz commits ou alterações no índice, permitindo reverter o estado do repositório para um ponto anterior.

git reset HEAD~1

Este comando desfaz o último commit, mantendo as alterações no diretório de trabalho.

Git Revert

O comando `git revert` cria um novo commit que desfaz as alterações de um commit específico, preservando o histórico.

git revert <commit-hash>

Ideal para desfazer mudanças em um repositório compartilhado.

Git Blame

O comando `git blame` mostra quem fez cada alteração em um arquivo, linha por linha.

git blame arquivo.txt

Útil para rastrear a origem de mudanças.

Git Shortlog

O comando `git shortlog` resume o histórico de commits, agrupando por autor.

git shortlog -s -n

Mostra o número de commits por autor, ordenados.

Boas Práticas com GIT: Do Iniciante ao Profissional

À medida que você evolui, adotar boas práticas faz seu trabalho brilhar. Elas garantem clareza, segurança e colaboração eficiente.

Dicas para commits

Seja descritivo:

git commit -m "feat: adiciona página de login com autenticação"

Commits pequenos: Agrupe alterações lógicas.
Use padrões: Adote Conventional Commits (ex.: feat, fix, docs, refactor, chore).
Dê preferencia a descrições usando o inglês como linguagem padrão

Exemplos:

feat: new feature
fix(scope): bug in scope
feat!: breaking change / feat(scope)!: rework API
chore(deps): update dependencies

Tipos de commits:

build: Alterações que afetam o sistema de build ou dependências externas (exemplos de escopos: gulp, broccoli, npm)
ci: Alterações em arquivos de configuração e scripts de CI (exemplos de escopos: Travis, Circle, BrowserStack, SauceLabs)
chore: Alterações que não alteram o código-fonte ou os testes, por exemplo, alterações no processo de build, ferramentas auxiliares, bibliotecas
docs: Alterações apenas na documentação
feat: Um novo recurso
fix: Uma correção de bug
perf: Uma alteração no código que melhora o desempenho
refactor: Uma alteração no código que não corrige um bug nem adiciona um recurso
revert: Reverte algo
style: Alterações que não afetam o significado do código (espaços em branco, formatação, ponto e vírgula ausentes, etc.)
test: Adicionar testes ausentes ou corrigidos testes existentes

Organize branches nomeando com o propósito:

feature/nome-da-feature
bugfix/nome-do-bug
hotfix/ajuste-crítico

git branch -d feature/nova-pagina

Exclua branches antigas:

git push origin --delete feature/nova-pagina

Use .gitignore

Evite versionar arquivos desnecessários:

node_modules/
.env
*.log

Além do README

CONTRIBUTING.md – Explica como contribuir, seguindo boas práticas.

CHANGELOG.md – Registra o histórico de versões e mudanças.

LICENSE – Define os direitos e permissões de uso.

CODE_OF_CONDUCT.md – Um código de conduta ajuda a manter um ambiente saudável em projetos colaborativos.

Nível Hero: Automação com GitHub Actions

Integração Contínua e Deploy Automatizado

Com a popularidade dos repositórios remotos, a integração contínua (CI) se tornou essencial. Ferramentas como GitHub Actions permitem:

Automatizar testes a cada push ou PR.
Efetuar builds do projeto automaticamente.
Realizar deploys em ambientes de produção de forma segura.

A CI ajuda a identificar erros precocemente e a manter a qualidade do código. Estabeleça pipelines simples para integrar e testar seu projeto continuamente.

Chegou a hora de brilhar como um hero! GitHub Actions automatiza tarefas como testes e deploys, economizando tempo e reduzindo erros.

Criando um workflow básico

Crie a pasta .github/workflows/ no repositório.
Adicione um arquivo ci.yml:

name: CI Pipeline
on: [push]
jobs:
build:
  runs-on: ubuntu-latest
  steps:
  - uses: actions/checkout@v3
  - name: Instalar dependências
    run: npm install
  - name: Rodar testes
    run: npm test

Faça um push e veja a ação rodar no GitHub (Actions).

Benefícios

Testes automáticos: Valida código antes do merge.
Deploy contínuo: Publica apps com um push.
Escalabilidade: Adapta-se a projetos complexos.

Sugestão de imagem: Tela de GitHub Actions mostrando um workflow executado.

Segurança com GIT e GitHub: Proteja Seu Código

No nível hero, segurança é prioridade. GIT e GitHub oferecem ferramentas para proteger seu projeto.

Práticas de segurança

Nunca commite senhas:
Use .env e .gitignore.
Configure branch protection:
No GitHub, vá em Settings → Branches → Add rule.
Exija revisões antes de merge.
Use Dependabot:
Ative em Security para atualizações automáticas de dependências.

Fluxos de Trabalho Populares com GIT

Existem diversos fluxos de trabalho para otimizar a colaboração. Conheça alguns:

GitFlow: Organiza o desenvolvimento com branches para features, lançamentos e hotfixes.

main - Código de produção
develop - Código de desenvolvimento
feature/nome-da-feature - Novas funcionalidades
release/nome-do-release - Preparação para lançamentos
hotfix/nome-da-correção - Correções urgentes para produção

GitHub Flow: Simples e ágil, utiliza branches de feature e pull requests para integração.

main - Sempre estável e pronta para deploy
Branches de feature para qualquer novo trabalho
Pull Requests para revisar e mesclar mudanças

Trunk-Based Development: Foca na integração contínua dentro de uma única branch principal.

Cada fluxo possui vantagens específicas e se adapta a diferentes tamanhos de equipe. Escolha o que melhor se encaixa no seu projeto e metodologia.

Foco em manter a branch principal ("trunk") sempre estável
Branches de curta duração para trabalhos pequenos
Integração frequente à branch principal

Ferramentas avançadas

Code Scanning: Detecta vulnerabilidades com CodeQL.
Secrets: Armazene chaves em Settings → Secrets.

Ferramentas Visuais para Gerenciar o GIT e GitHub

Embora o terminal seja poderoso, as ferramentas visuais agilizam o entendimento do histórico. Algumas ferramentas populares são:

GitKraken: Visual intuitivo para gerenciar branches e commits.
Sourcetree: Interface gráfica que facilita a navegação no repositório.
VS Code com GitLens: Extensão que aprimora o uso do GIT diretamente no editor.
GitHub Desktop: Simplifica o fluxo de trabalho com repositórios remotos.

Essas ferramentas ajudam a visualizar a estrutura do projeto e identificar conflitos facilmente. Explore cada uma para encontrar a que melhor se adapta ao seu estilo de trabalho.

Conclusão: Sua Jornada de Zero a Hero com GIT e GitHub

De criar seu primeiro repositório a automatizar fluxos com GitHub Actions, você agora tem um mapa para dominar GIT e GitHub. Comece pequeno: faça commits claros, use branches, colabore via pull requests. Conforme cresce, adote automações e segurança. O que está esperando? Crie um projeto, publique no GitHub e mostre seu potencial ao mundo!

Fontes e Referências:

Site oficial do Git: https://git-scm.com/
Documentação do GitHub: https://docs.github.com/
Conventional Commits: https://www.conventionalcommits.org/
Git Flow: https://nvie.com/posts/a-successful-git-branching-model/
Documentação GitHub Actions: https://docs.github.com/en/actions
Commitizen: https://commitizen-tools.github.io/commitizen/
Commitlint: https://commitlint.js.org/
Husky: https://typicode.github.io/husky/

Contatos do Autor

Linkedin: https://www.linkedin.com/in/williamlimasilva/
Github: https://github.com/williamlimasilva