GUIA COMPLETO DE VERSIONAMENTO DE CÓDIGO COM GIT

INTRODUÇÃO

O versionamento de código é essencial no desenvolvimento de software, sendo comparado a contar a história das mudanças feitas em um projeto, é como ter um registro desde pequenas correções até grandes atualizações, mantendo tudo organizado e evitando problemas quando várias pessoas trabalham juntas em um mesmo projeto.

Imagine que você e seu amigo decidiram construir um jogo juntos. Cada um fica responsável por uma parte do jogo, no final, precisam juntar tudo. Sem um sistema de versionamento, essa junção pode ser complicada, como tentar encaixar peças de quebra-cabeça sem ter a certeza se elas se encaixam.

Com o versionamento de código, a junção fica mais fácil, pois é possível ver todas as mudanças feitas por cada um e combinar de forma organizada.

O Git e o GitHub são como os melhores amigos do versionamento de código. O Git ajuda a controlar e rastrear as mudanças, enquanto o Github funciona como uma rede social para o seu código, permitindo compartilhar, colaborar e mostrar seu trabalho para o mundo.

Este guia tem como objetivo fornecer a você todos os conhecimentos necessários para começar a utilizar o Git e o GitHub em seus projetos. Desde os conceitos básicos até dicas avançadas, você aprenderá a configurar um repositório, gerenciar alterações, colaborar com outros desenvolvedores e muito mais.

Vamos começar!

O QUE É GIT?

Git é um sistema de controle de versão distribuído amplamente utilizado para rastrear as mudanças no código-fonte durante o desenvolvimento de software. Ele permite que você mantenha um histórico completo de todas as alterações feitas no seu projeto e coordene o trabalho entre várias pessoas de forma eficiente.

Imagine Git como um super-herói do mundo do desenvolvimento de software. Ele é como um guardião vigilante que registra cada alteração no seu código, seja uma correção de bug, uma nova funcionalidade ou até mesmo uma simples alteração no design. Com o Git, você pode voltar no tempo e ver exatamente como seu projeto evoluiu, além de poder trabalhar em diferentes partes do código simultaneamente sem medo de conflitos.

Uma das principais vantagens do Git é a sua capacidade de trabalhar offline. Você pode fazer alteração no seu código, criar novos branches e fazer commits localmente, sem precisar de uma conexão com a internet. Depois, quando estiver pronto, você pode sincronizar suas mudanças com repositório remoto, como o GitHub, para compartilhar seu trabalho com outras pessoas.

Em resumo, Git é uma ferramenta poderosa que ajuda a manter seu projeto organizado, colaborativo e seguro. É essencial para qualquer desenvolvedor que queira controlar e gerenciar seu código de forma eficaz.

INSTALAÇÃO E CONFIGURAÇÃO

Antes de nos aprofundarmos no uso do git e do Github, é importante garantir que você tenha tudo configurado corretamente em maquina. Neste capítulo, vamos abordar os passos iniciais para instalar o Git e configurar suas informações.

Instalação do Git

Acesse o site oficial do Git em git-scm.com Clique em “Download” e escolha o instalador adequado para o seu sistema operacional.

Execute o instalador baixado e siga as instruções na tela, Após a instalação, abra o terminal do seu sistema e digite o comando ‘git --version’ para verificar se o Git foi instalado corretamente.

git --version

Configuração do Git

Para Configurar o Git no terminal do Git Bash precisamos de trës informações o “user.name”, “user.email” e “user.default Branch”

Vamos começar a configuração, todos os comandos no git se inicia com ‘git’ por exemplo, se a gente digitar git help, Quando você digita git help no terminal, o Git exibe a página de ajuda, que contém uma lista dos comandos mais comuns do Git e uma breve descrição de cada um. Você pode rolar a página para cima e para baixo para ver todos os comandos listados e pressionar a tecla q para sair da página de ajuda e voltar ao prompt de comando.

$ git help
usage: git [-v | --version] [-h | --help] [-C <path>] [-c <name>=<value>]
         [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
         [-p | --paginate | -P | --no-pager] [--no-replace-objects] [--bare]
         [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
         [--config-env=<name>=<envvar>] <command> [<args>]

These are common Git commands used in various situations:

start a working area (see also: git help tutorial)
 clone     Clone a repository into a new directory
 init      Create an empty Git repository or reinitialize an existing one

work on the current change (see also: git help everyday)
 add       Add file contents to the index
 mv        Move or rename a file, a directory, or a symlink
 restore   Restore working tree files
 rm        Remove files from the working tree and from the index

examine the history and state (see also: git help revisions)
 bisect    Use binary search to find the commit that introduced a bug
 diff      Show changes between commits, commit and working tree, etc
 grep      Print lines matching a pattern
 log       Show commit logs
 show      Show various types of objects
 status    Show the working tree status

grow, mark and tweak your common history
 branch    List, create, or delete branches
 commit    Record changes to the repository
 merge     Join two or more development histories together
 rebase    Reapply commits on top of another base tip
 reset     Reset current HEAD to the specified state
 switch    Switch branches
 tag       Create, list, delete or verify a tag object signed with GPG

collaborate (see also: git help workflows)
 fetch     Download objects and refs from another repository
 pull      Fetch from and integrate with another repository or a local branch
 push      Update remote refs along with associated objects

'git help -a' and 'git help -g' list available subcommands and some
concept guides. See 'git help <command>' or 'git help <concept>'
to read about a specific subcommand or concept.
See 'git help git' for an overview of the system.

Para mais informações acesse a documentação do git https://git-scm.com/docs/git

⭐ Dica para limpar o terminal digite clear, ou apertando ctrl + l!

Ótimo! Vamos começar com a configuração do Git. Como mencionado, todos os comandos no Git começam com git. Para começar, você pode configurar seu nome de usuário no Git usando o comando:

git config --global user.name "Seu Nome"

E depois configure seu endereço de e-mail com o comando:

git config --global user.email "seu-email@example.com"

Isso irá configurar seu nome de usuário e endereço de e-mail globalmente no Git, para que eles sejam usados em todos os seus projetos.

Agora configurando a nossa Branch digite o comando:

git config --global init.defaultBranch main

Aqui você está indicando ao Git que sempre que um novo repositório for criado, o branch principal deve ser chamado de “main”. Isso pode ser útil para padronizar o nome do branch principal em todos os seus projetos e seguir as práticas recomendadas da comunidade em relação aos nomes de branches.

PRIMEIROS PASSOS COM GIT

Neste capítulo, você aprenderá os conceitos básicos e as principais operações para começar a trabalhar com Git. Veremos como inicializar um repositório, adicionar arquivos, fazer commits, criar branch, entre outras configurações.

1 - Inicializando um Repositório Git

Para começar a usar o Git em um projeto existente, você precisa inicializar um repositório. Isso pode ser feito com o comando git init no terminal dentro do diretório do seu projeto. Se você deseja trabalhar com um repositório Git existente, pode cloná-lo usando git clone.

Passo 1 - Abra o terminal bash (ou o terminal de sua preferencia) no caminho do seu projeto:

D:\\projetos\\Ola_mundo>

Passo 2 - Inicialize o repositório Git com o comando git init :

git init

Isso cria um diretório oculto chamado .git no diretório do seu projeto, que é onde o Git armazena metadados e informações sobre o repositório.

2 - Adicionando e Configurando Mudanças

Para adicionar arquivos ao índice do Git, você pode usar o comando git add nome_do_arquivo para adicionar um arquivo especifico. O git add . ou git add — allpara adicionar todos os arquivos modificados. Em seguida, você pode confirmar as mudanças com git commit -m "Mensagem do commit

Passo 1 - Agora Vamos criar um arquivo em nosso projeto chamado index.html :

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

Passo 2 - Adicionando o arquivo index.html ao índice do Git:

git add index.html

Aqui você está preparando o Git para incluir as alteraçoes feitas no arquivo no próximo commit. O índice do Git, também conhecido como "área de preparação" ou "staging area", é onde você seleciona quais alterações deseja incluir no próximo commit.

Adicionar um arquivo ao índice do Git é um passo importante antes de fazer um commit, pois permite que você selecione quais alterações serão incluídas no próximo snapshot do seu projeto.

Passo 3 - Confirme as mudanças com o comando git commit

git commit -m "Adicionando meu primeiro arquivo no meu Repositorio"

Isso criará um novo commit com suas alterações no repositório. A opção -m é usada para adicionar uma mensagem ao commit, descrevendo as mudanças feitas.

Para visualizar o historico de commits e as mudanças feitas, voce pode usar o comando git log

$ git log
commit 47d55ab3f5a9c6742a38c09f2b3d2499d7b88f8d
Author: Seu Nome <seu@email.com>
Date:   Thu May 9 10:13:34 2024 -0300

  Adicionando meu primeiro arquivo no meu Repositorio

Para visualizar o Historico de commits no Git, você pode usar o comando git log . Isso mostrará uma lista de commits, com as informaçoes do commit como o autor, a data e a mensagem de commit.

Voce tambem pode usar opçoes adiconais com o git log para personalizar saida. Por exemplo, git log —oneline mostra o histórico em uma única linha por commit e git log —graph mostra o histórico em forma de gráfico, mostrando como os diferentes branches se ramificam e se fundem ao longo do tempo.

3 - Manipular arquivos no Git

Manipular arquivos no Git envolve diversas operações para adicionar, remover, mover e restaurar arquivos no seu repositório. Vamos ver algumas das operações mais comuns:

1 - Remove arquivos do índice e do diretório de trabalho, para remover um arquivo específico

git rm arquivo.txt

2 - Move ou renomeia arquivos no seu projeto Git, atualizando automaticamente o índice, para renomear ou mover um arquivo.

git mv antigo.txt novo.txt

3- Desfaz as alterações em arquivos no diretório de trabalho ou no índice, para desfazer as alterações em um arquivo específico.

git restore arquivo.txt

4 - Mostra as diferenças entre o diretório de trabalho, o índice e o último commit

Uso: git diff para mostrar as diferenças entre o diretório de trabalho e o índice, ou git diff --staged para mostrar as diferenças entre o índice e o último commit.

git dif

5 - Desfaz commits, movendo o HEAD e o branch atual para um commit anterior, mantendo as alterações no diretório de trabalho.

Uso: git reset HEAD~1 para desfazer o último commit.

git reset HEAD~1

Essas são as operações básicas para manipular arquivos no Git. Elas são essenciais para o controle eficiente de versão e colaboração em projetos de software.

OS TRÊS ESTADOS PRINCIPAIS DO GIT

Preste bastante atenção agora, vamos apresentar a principal coisa para se lembrar sobre o git. O git tem três estados principais nos quais seus arquivos podem residir: modificado, preparado e confirmado:

Modificado(modified):Significado: Um arquivo modificado foi alterado desde o último commit, mas ainda não foi preparado para um novo commit.
Como ocorre: Quando você edita um arquivo existente no seu projeto, ele se torna modificado.
Estado no Git: O Git rastreia os arquivos modificados, mas eles ainda não estão no índice para o próximo commit.
Preparado (Staged):Significado: Um arquivo preparado foi marcado no estado atual para ser incluído no próximo commit.
Como ocorre: Você usa o comando git add para adicionar um arquivo modificado ao índice (staging area).
Estado no Git: Os arquivos preparados estão prontos para serem confirmados no próximo commit.
Confirmado (Committed):Significado: Um arquivo confirmado está armazenado com segurança no banco de dados do Git, em seu último estado preparado.
Como ocorre: Você usa o comando git commit para confirmar as alterações preparadas no índice.
Estado no Git: Os arquivos confirmados fazem parte do histórico do seu projeto e não estão mais marcados como preparados.

Esses três estados refletem as áreas principais de um projeto Git:

Árvore de trabalho (Working Directory): É onde os arquivos modificados estão. É a versão atual do seu projeto no seu sistema de arquivos.
Área de preparação (Staging Area ou Index): É onde os arquivos preparados estão. É uma área temporária onde você pode formatar as alterações antes de confirmá-las.
Diretório Git (Git Directory): É onde o Git armazena os metadados e o banco de dados do seu projeto. É onde o Git mantém o histórico do seu projeto e os snapshots dos arquivos preparados.

O COMANDO GIT STATUS

O comando git status é uma ferramenta fundamental no Git que fornece informações sobre o estado atual do seu repositório. Ele mostra quais arquivos foram modificados, quais estão no índice (preparados para commit) e quais não estão sendo rastreados pelo Git.

Ao executar git status, você verá algo como:

$ git status
On branch master
Your branch is up to date with 'origin/master'.

Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
  modified:   arquivo_modificado.txt

no changes added to commit (use "git add" and/or "git commit -a")

Este é um exemplo comum do resultado do git status, mostrando que há um arquivo modificado (arquivo_modificado.txt) que não foi adicionado ao índice. Ele também fornece algumas sugestões úteis sobre como lidar com as alterações não preparadas.

Alguns pontos-chave sobre git status:

Branch: Mostra em qual branch você está trabalhando.
Modifications not staged for commit: Lista os arquivos modificados que ainda não foram adicionados ao índice.
Changes to be committed: Lista os arquivos preparados (staged) que serão incluídos no próximo commit.
Untracked files: Lista os arquivos no diretório de trabalho que não estão sendo rastreados pelo Git.

O git status é uma ferramenta valiosa para verificar o estado do seu repositório, garantindo que você esteja ciente de todas as alterações antes de confirmá-las. É uma boa prática executar git status regularmente para manter o controle das alterações no seu projeto.

ALIASES DO GIT: SIMPLIFICANDO COMANDOS

Os aliases do Git são uma forma poderosa de simplificar comandos frequentemente utilizados. Eles permitem criar atalhos para sequências de comandos mais longas ou complexas, tornando seu fluxo de trabalho com o Git mais eficiente e produtivo. Neste capítulo, exploraremos como usar e configurar aliases do Git.

Você pode criar aliases no Git usando o comando git config --global alias.<alias> <comando>. Por exemplo, para criar um alias chamado lo para log —oneline, você usaria:

git config --global alias.lo log --oneline

Após criar um alias, você pode usar o novo comando simplificado. Por exemplo, em vez de git log --oneline , você pode simplesmente digitar git lo.

Você também pode criar aliases para sequências de comandos mais longas. Por exemplo, se você quiser adicionar e confirmar arquivos com uma única abreviação, você pode criar um alias chamado ac:

git config --global alias.ac '!git add -A && git commit'

• O ! no início do comando indica que é uma sequência de comandos a ser executada pelo shell.

Para listar todos os aliases configurados, você pode usar o comando git config --get-regexp alias.

Para editar um alias existente, você pode abrir o arquivo .gitconfig no seu editor de texto preferido e editar manualmente os aliases sob a seção [alias].

Alguns exemplos comuns de aliases úteis incluem st para status, br para branch, lg para um log formatado e df para diff.

Aqui está um exemplo de como você pode configurar esses aliases:

bashCopy code
git config --global alias.st status
git config --global alias.br branch
git config --global alias.lg "log --oneline --decorate --all --graph"
git config --global alias.df diff

Com esses aliases, você pode usar comandos como git st, git br, git lg e git df em vez dos comandos completos.

Os aliases do Git podem ser uma ferramenta poderosa para simplificar seu fluxo de trabalho e economizar tempo ao usar o Git. Experimente criar seus próprios aliases para os comandos que você usa com frequência e veja como eles podem melhorar sua produtividade com o Git.

BRACH

Quase todos os sistemas de controle de versionamento têm algum tipo de suporte a ramificação (branches). Ramificar significa divergir da linha principal de desenvolvimento e continuar trabalhando sem alterar essa linha principal. Em muitas ferramentas de versionamento, esse processo é difícil, geralmente exigindo a criação de uma nova cópia do diretório do código-fonte, o que pode ser demorado em projetos maiores.

O Git diferencia-se nesse aspecto. Ele cria branches de forma extremamente leve, tornando as operações de ramificação quase instantâneas, com alternância entre os branches também sendo rápida. Ao contrário de muitos outros sistemas, o Git incentiva fluxos de trabalho que se ramificam e se fundem com frequência, até várias vezes ao dia. Compreender e dominar esse recurso oferece uma ferramenta poderosa e única que pode mudar totalmente a maneira como você desenvolve.

Para entender como o Git trabalha com branches, é importante examinar como ele armazena seus dados. Em vez de armazenar dados como uma série de mudanças ou diferenças, o Git os armazena como uma série de snapshots (instantâneos de um momento).

Quando você faz um commit, o Git armazena um objeto de commit que contém um ponteiro para o snapshot do conteúdo que você confirmou, junto com metadados como autor, mensagem e ponteiros para commits anteriores (pais).

Cada arquivo em seu diretório de trabalho pode estar em um de dois estados: rastreado ou não rastreado. Arquivos rastreados são aqueles que estavam no último snapshot, além dos arquivos que você preparou para o próximo commit. Arquivos não rastreados são os restantes, ou seja, aqueles que não estavam no último snapshot e não estão na área de preparação.

Criando um Novo Branch

Ao criar um novo branch, o Git cria um novo ponteiro móvel para você usar. Por exemplo, ao criar um branch chamado testing, você executa o comando:

git branch testing

Isso cria um novo ponteiro para o mesmo commit em que você está atualmente. O Git também mantém um ponteiro especial chamado HEAD, que aponta para o branch atual em que você está.

Branches no Git: Ramificação Simplificada

Branches em Poucas Palavras

Criando um Novo Branch

Ao criar um novo branch, o Git cria um novo ponteiro móvel para você usar. Por exemplo, ao criar um branch chamado testing, você executa o comando:

bashCopy code
git branch testing

Isso cria um novo ponteiro para o mesmo commit em que você está atualmente. O Git também mantém um ponteiro especial chamado HEAD, que aponta para o branch atual em que você está.

Alternando entre Branches

Para mudar para um branch existente, você usa o comando git checkout. Por exemplo, para mudar para o branch testing, você executa:

bashCopy code
git checkout testing

Isso move o ponteiro HEAD para o branch testing, mudando também os arquivos em seu diretório de trabalho para refletir o estado desse branch.

Fazendo Alterações e Confirmando

Você pode fazer alterações nos arquivos em seu diretório de trabalho e, em seguida, prepará-las e confirmá-las em um branch específico. As mudanças que você faz em um branch não afetam outros branches até que você os mescle (merge) explicitamente.