Introdução ao Git e GitHub - Conceitos e Comandos Básicos

Introdução ao Git e GitHub: Domine o Controle de Versões
Aprenda os conceitos básicos do Git e do GitHub para gerenciar seus projetos de forma eficiente e colaborativa.
Aula Prática: Introdução ao Git e GitHub
Objetivo

Ensinar aos alunos os conceitos básicos do Git e GitHub, incluindo a instalação, configuração e os primeiros comandos para controle de versão.

Materiais Necessários

Computador com acesso à internet

Terminal (Linux/Mac) ou Git Bash (Windows)

Conta no GitHub (crie aqui)

Passo 1: Instalação do Git

Windows

Baixe o Git em: https://git-scm.com/downloads.

Execute o instalador e mantenha as configurações padrão.

Após a instalação, abra o Git Bash e digite:git --version Se aparecer algo como git version 2.x.x, a instalação foi concluída.

Linux

Abra o terminal e execute:sudo apt update && sudo apt install git -y # Debian/Ubuntu sudo dnf install git # Fedora

Verifique a instalação:git --version

Mac

No terminal, execute:brew install git

Confirme a instalação:git --version

Passo 2: Configuração Inicial

Configure o Git com seu nome e e-mail (usar o mesmo e-mail do GitHub).

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


Para verificar as configurações:

git config --list


Passo 3: Criando um Repositório Local

Crie uma pasta para o projeto:mkdir meu-projeto && cd meu-projeto

Inicialize um repositório Git:git init O comando criará um diretório oculto .git.

Passo 4: Adicionando Arquivos e Criando um Commit

Crie um arquivo de teste: echo "Hello, Git!" > README.md

Verifique o status do repositório: git status O arquivo aparecerá como untracked (não rastreado).

Adicione o arquivo ao controle de versão: git add README.md

Faça o primeiro commit: git commit -m "Primeiro commit: adicionando README"

Passo 5: Criando um Repositório no GitHub

Acesse https://github.com e faça login.

Clique em New Repository.

Dê um nome ao repositório e escolha público ou privado.

Não adicione arquivos (como README ou .gitignore), pois já temos um local.

Clique em Create Repository.

Passo 6: Conectando o Repositório Local ao GitHub

No terminal, adicione o repositório remoto:git remote add origin https://github.com/seuusuario/meu-projeto.git

Verifique se o remoto foi adicionado corretamente:git remote -v

Envie os arquivos para o GitHub:git push -u origin main

Passo 7: Clonando um Repositório

Caso queira baixar um repositório existente:

git clone https://github.com/seuusuario/meu-projeto.git


Passo 8: Atualizando o Repositório (Pull e Push)

Caso tenha feito alterações no GitHub e precise atualizar o repositório local:git pull origin main

Caso tenha feito alterações localmente e queira enviá-las:git add . git commit -m "Atualização do projeto" git push origin main

Conclusão

Agora você já sabe os conceitos básicos de Git e GitHub. Pratique esses comandos e explore novos recursos do Git, como branches e pull requests.
O que é Git?
Um Sistema de Controle de Versões
O Git é um sistema de controle de versões (VCS) que ajuda desenvolvedores a rastrear e gerenciar alterações em seus projetos de código.
Rastreamento de Alterações
Ele registra cada mudança feita no código, permitindo que você volte para versões anteriores, compare alterações e colabore com outros desenvolvedores.
Controle de Versões Distribuído
O Git é distribuído, o que significa que cada desenvolvedor tem uma cópia completa do histórico do projeto, facilitando o trabalho offline e a colaboração.
Benefícios do uso do Git
Controle de Versões
O Git permite rastrear cada alteração feita no código, permitindo que você reverta para versões anteriores a qualquer momento, caso seja necessário. Isso é essencial para garantir a estabilidade e a integridade do seu projeto.
Colaborar com Facilidade
O Git facilita a colaboração entre várias pessoas em um mesmo projeto. Você pode trabalhar em diferentes partes do código simultaneamente, mesclando suas alterações posteriormente, evitando conflitos e garantindo que todos trabalhem na mesma base de código.
Segurança e Backups
O Git armazena um histórico completo das alterações em um repositório, atuando como um backup seguro do seu projeto. Mesmo que você perca dados em seu computador, você pode recuperá-los facilmente do repositório Git.
Instalando e Configurando o Git
1
Download
Baixe o Git para o seu sistema operacional (Windows, macOS, Linux) do site oficial. Siga as instruções de instalação padrão.
2
Verificação da Instalação
Abra um terminal ou prompt de comando e digite: git --version. Se a versão do Git for exibida, a instalação foi bem-sucedida.
3
Configuração Inicial
Defina seu nome e endereço de e-mail para associar seus commits: git config --global user.name "Seu Nome" e git config --global user.email "seu.email@example.com".
Configurando a Identidade do Usuário
Para que o Git possa rastrear seus commits, é necessário configurar sua identidade. Essa identidade consiste em um nome e email que serão associados a cada commit que você fizer.
Utilize os comandos abaixo para configurar seu nome e email:
git config --global user.name "Seu Nome"
git config --global user.email "seu_email@example.com"
Ao usar a flag --global, essas configurações serão aplicadas a todos os repositórios Git em sua máquina.
Obtendo ajuda com comandos Git
Como obter ajuda com os comandos Git?
Para visualizar a documentação completa do Git, use o comando `git help`. Para obter ajuda específica sobre um comando, use `git help `. Por exemplo, para obter ajuda sobre o comando `commit`, use `git help commit`. Você também pode usar `git --help` para obter informações resumidas sobre o comando.
Quais são outras formas de obter ajuda?
Procure em sites de documentação como a documentação oficial do Git.
Utilize sites de perguntas e respostas como Stack Overflow.
Participe de comunidades online como fóruns e grupos do Facebook.
Inicializando um repositório Git
1
Criando um novo repositório
Para começar a usar o Git, você precisa criar um novo repositório em sua pasta de projeto.
2
Navegando para o diretório
Abra o terminal e navegue para a pasta do projeto usando o comando `cd`.
3
Inicializando o repositório
Digite `git init` para inicializar o repositório Git. Isso cria uma pasta `.git` que contém todos os arquivos de configuração do repositório.
A partir desse momento, o Git está rastreando as alterações no seu projeto. Você pode usar os comandos Git para gerenciar o histórico de versões, colaborar com outros desenvolvedores e muito mais.
Verificando o status do repositório
git status
Exibe o status atual do repositório, mostrando quais arquivos foram modificados, adicionados ou removidos.
git diff
Mostra as diferenças entre a versão atual dos arquivos no repositório e a última versão commitada.
Adicionando arquivos ao "stage"
1
git add
Adiciona arquivos modificados ao "stage"
2
git commit
Cria um novo commit com as alterações "staged"
Antes de confirmar as alterações, você precisa adicioná-las ao "stage". O "stage" é uma área temporária que armazena as alterações que você deseja incluir no próximo commit.
O comando `git add` adiciona arquivos modificados ao "stage". Você pode adicionar todos os arquivos modificados de uma vez usando o comando `git add .`, ou adicionar arquivos específicos usando o comando `git add `.
Fazendo o primeiro commit
1
Criando um commit
Um commit é um snapshot do seu projeto em um determinado momento, como um ponto de salvamento.
2
Adicionando arquivos
Use o comando "git add" para adicionar arquivos ao 'stage' (área de preparo).
3
Criando a mensagem do commit
O comando "git commit" cria o commit com uma mensagem descritiva sobre as mudanças.
Verificando o histórico de commits
Para visualizar o histórico de commits em seu repositório Git, utilize o comando git log. Este comando mostrará a lista de commits em ordem cronológica inversa, com o commit mais recente no topo. Cada commit é identificado por um hash único e mostra informações como a mensagem do commit, o autor e a data.
Desfazendo alterações não salvas
1
O comando checkout
O comando checkout é o principal para desfazer alterações não salvas. Use git checkout -- para restaurar um arquivo para o estado do último commit. Use git checkout . para restaurar todos os arquivos no diretório de trabalho.
2
Revertendo para o último commit
Se você fez alterações em vários arquivos e deseja revertê-los todos, use git checkout HEAD para restaurar o diretório de trabalho para o estado do último commit. Isso reverterá todas as alterações não salvas.
Diferenciando o working directory e o repositório
O **working directory** é o local onde você trabalha nos arquivos do seu projeto. É onde você edita, cria e exclui arquivos.
O **repositório Git** é uma cópia local do seu projeto que é gerenciada pelo Git. Ele rastreia todas as alterações nos arquivos do seu projeto ao longo do tempo, permitindo que você recupere versões anteriores do seu trabalho.
Você pode pensar no repositório Git como um sistema de controle de versão para seu projeto.
Ao usar o Git, você pode adicionar, remover e atualizar arquivos no seu working directory, mas esses arquivos não serão adicionados ao repositório Git até que você os "stage" e "commit".
Ignorando arquivos com .gitignore
Crie um arquivo chamado .gitignore na raiz do seu repositório.
Adicione os nomes dos arquivos ou diretórios que você deseja ignorar, um por linha.
Use padrões de correspondência para especificar arquivos que você deseja ignorar, por exemplo: *.log, *.tmp.
Trabalhando com branches
1
Criando um novo branch
Crie um novo branch a partir do branch atual.
2
Mudando de branch
Mova-se para outro branch.
3
Listando branches
Visualize todos os branches existentes.
4
Excluindo um branch
Exclua um branch remotamente.
Branches no Git são como versões paralelas do seu código. Eles permitem que você trabalhe em novos recursos ou correções de bugs sem afetar o código principal. Você pode criar, trocar, listar e excluir branches para gerenciar seu fluxo de trabalho de desenvolvimento de forma eficiente.
Mesclando branches com merge
1
Merge
Combina alterações de um branch em outro
2
Conflitos
Ocorrem quando as mesmas linhas de código são modificadas em ambos os branches
3
Resolução
Manualmente editar o código para resolver os conflitos
Resolvendo conflitos de merge
Às vezes, quando você tenta mesclar branches com alterações conflitantes, o Git não consegue determinar automaticamente qual versão do código deve ser mantida. Nesse caso, você terá que resolver manualmente o conflito. O Git sinalizará os conflitos no código, geralmente com blocos de texto contendo as versões em conflito, delimitados por símbolos como `<<<<<<< HEAD` e `>>>>>>>`. Você precisa escolher qual versão manter ou criar uma solução que combine ambas.
Para resolver o conflito, abra o arquivo com o conflito e edite o código. Remova os marcadores de conflito e faça as alterações necessárias. Depois, adicione o arquivo modificado ao stage e faça um novo commit, com uma mensagem descrevendo a resolução do conflito.
Fazendo push de commits para o servidor
1
Passo 1: Confirmação
Antes de enviar seus commits, certifique-se de que suas alterações estão prontas para serem compartilhadas. Verifique o status do seu repositório para confirmar se todos os arquivos necessários foram adicionados e comprometidos.
2
Passo 2: Comando "push"
Use o comando `git push` para enviar seus commits para o servidor remoto. Este comando enviará os commits do seu branch atual para o branch correspondente no servidor.
3
Passo 3: Verificação
Após executar o comando "push", verifique se seus commits foram enviados com sucesso para o servidor. Você pode usar o comando `git log` para visualizar o histórico de commits no servidor remoto.
Fazendo pull de atualizações do servidor
1
Verifique as alterações
Use o comando git status para verificar se há alterações não confirmadas no seu repositório local.
2
Faça o pull
Execute o comando git pull para baixar e mesclar as alterações do repositório remoto para o seu repositório local.
3
Resolva conflitos (se necessário)
Se houver conflitos durante a mesclagem, você precisará resolvê-los manualmente e então fazer um novo commit com as alterações mescladas.
Clonando um repositório existente
1
Criar uma cópia local
Baixe o repositório para o seu computador.
2
Colaborar em projetos
Faça alterações no código e envie seus commits.
3
Trabalhar offline
Acesse o código, mesmo sem conexão à internet.
Inspecionando diferenças com diff
O comando `git diff` é uma ferramenta essencial para visualizar as diferenças entre arquivos. Ele exibe as alterações feitas no working directory em relação ao último commit ou entre dois commits específicos.
Para verificar as diferenças entre o working directory e o último commit, utilize:
git diff
Para comparar dois commits específicos, use os identificadores de commit:
git diff commit1 commit2
O comando `git diff` exibe um formato de saída que destaca as alterações, mostrando as linhas adicionadas e removidas.
Visualizando logs de commits
Para ver o histórico de commits em seu repositório, use o comando `git log`. Esse comando mostrará uma lista de todos os commits, com informações como a data, o autor e a mensagem de commit. Você pode usar o comando `git log --oneline` para ver uma lista concisa de commits.
O comando `git log` pode ser usado com diversas opções para filtrar os commits. Por exemplo, para ver apenas os commits feitos por um determinado autor, você pode usar `git log --author="nome_do_autor"`.
Atualizando a identidade do autor de commits
Em alguns casos, você pode precisar atualizar a identidade do autor dos seus commits. Isso pode ser necessário se você estiver trabalhando em um novo computador, se você alterou o seu nome de usuário ou endereço de e-mail, ou se você estiver fazendo commits em nome de outra pessoa. Para atualizar a identidade do autor dos commits, utilize os seguintes comandos:
Para definir o nome de usuário e endereço de e-mail globalmente para todos os repositórios, utilize o comando git config --global user.name "Seu Nome" e git config --global user.email "seu@email.com". Se você precisar definir a identidade apenas para um repositório específico, remova a flag --global.
Desfazendo commits com revert
1
Identificação do Commit
Use o comando git log para encontrar o hash do commit que você deseja reverter.
2
Reverter o Commit
Execute o comando git revert seguido do hash do commit que você deseja reverter. O Git criará um novo commit que reverte as alterações do commit original.
3
Confirmar Reversão
Verifique se o revert fez o que você esperava usando git log. Se estiver tudo correto, faça um git push para enviar a reversão para o servidor.
Reescrevendo o histórico de commits
1
Amend
Modifica o último commit.
2
Rebase
Rearranja o histórico de commits, aplicando commits a um branch de destino diferente.
3
Reset
Move o ponteiro do branch para um commit específico, descartando commits intermediários.
Renomeando e movendo arquivos
1
Renomeando
Para renomear um arquivo, use o comando `mv` seguido do nome do arquivo antigo e o novo nome:
2
Movendo
Para mover um arquivo para um novo diretório, use o comando `mv` seguido do nome do arquivo e o caminho completo do novo diretório:
3
Combinando
Você pode combinar a renomeação e a movimentação em um único comando, fornecendo o novo caminho completo:
O Git rastreia as alterações nos arquivos, incluindo renomeações e movimentações. Ao fazer um commit, o Git registra essas ações, permitindo que você visualize o histórico de alterações com precisão.
Removendo arquivos do repositório
1
Remover do stage
Para remover um arquivo do stage, use o comando git rm --cached .
2
Remover do repositório
Para remover um arquivo do repositório, use o comando git rm .
3
Confirmar remoção
Após remover o arquivo, faça um commit para registrar a remoção.
Para remover um arquivo do repositório Git, você precisa primeiro remover ele do stage, e então do repositório, fazendo um commit para registrar a remoção. Este processo garante que a remoção do arquivo seja registrada no histórico de commits.
Gerenciando Credenciais do Git
Autenticação com Nome de Usuário e Senha
O Git pode usar seu nome de usuário e senha para se conectar a servidores Git, como GitHub, GitLab e Bitbucket. Esta é a forma mais comum de autenticação, especialmente para repositórios públicos.
Chaves SSH
Uma chave SSH é um par de chaves criptográficas que permite uma conexão segura entre seu computador e um servidor Git. É um método mais seguro e recomendado para repositórios privados. Você cria uma chave SSH e a adiciona ao seu servidor Git para permitir conexões sem senha.
Autenticação por Token
Alguns serviços Git oferecem a opção de usar tokens de acesso, que são strings criptografadas que concedem acesso a um repositório específico. Esta é uma forma mais flexível de controlar o acesso, mas pode ser mais complexa para configurar.
Utilizando GitHub para hospedar repositórios
O GitHub é uma plataforma de hospedagem de repositórios Git, popular entre desenvolvedores e empresas. Ele fornece um local centralizado para armazenar, gerenciar e colaborar em seus projetos.
Ao hospedar seu repositório no GitHub, você obtém uma série de benefícios, como:
1
Controle de versão
O GitHub permite que você acompanhe as mudanças em seu código e reverta para versões anteriores se necessário.
2
Colaboração
Você pode colaborar em projetos com outros desenvolvedores, enviando alterações, abrindo problemas e fazendo solicitações de pull.
3
Integração com outras ferramentas
O GitHub se integra a uma variedade de ferramentas de desenvolvimento, como IDEs, ferramentas de CI/CD e plataformas de análise.
Configurando o GitHub
Crie uma conta
Acesse o site do GitHub (github.com) e crie uma conta gratuita.
Personalize o perfil
Adicione uma foto de perfil, um breve resumo e links para outras plataformas, como LinkedIn ou Twitter.
Explore recursos
Familiarize-se com as funcionalidades do GitHub, como repositórios, issues, pull requests e forks.