Aula de git e github

1. Git e Github

2. O que é controle de versão?
O controle de versão é um sistema que registra as mudanças feitas em um
conjunto de arquivos ao longo do tempo, permitindo que você acompanhe as
diferentes versões desses arquivos. Ele é fundamental para o desenvolvimento
de software e para o gerenciamento de projetos que envolvem colaboração de
várias pessoas. O controle de versão ajuda a resolver problemas comuns, como a
perda de trabalho devido a erros, o acompanhamento de quem fez uma alteração
específica e a coordenação eficaz de colaboradores em um projeto.

3. Por que usar o Git?
O Git é amplamente adotado na indústria de desenvolvimento de software por várias razões:
● Rastreamento de Alterações: O Git permite rastrear cada alteração feita em um arquivo ou
conjunto de arquivos ao longo do tempo, incluindo quem fez a alteração e quando ela foi feita.
● Colaboração Eficiente: O Git facilita a colaboração entre desenvolvedores em equipes
distribuídas. Várias pessoas podem trabalhar simultaneamente no mesmo projeto, mesclando suas
alterações de forma eficiente.
● Ramo de Desenvolvimento: O Git permite que você crie "ramos" independentes do código, o que
é útil para desenvolver recursos separadamente sem afetar o código principal.
● Reversão Segura: Se algo der errado, o Git facilita a reversão para uma versão anterior do projeto
sem perda de dados.
● Histórico Completo: Mantém um histórico completo e detalhado de todas as mudanças feitas no
projeto, o que é útil para auditoria e solução de problemas.
● Open Source e Popular: O Git é uma ferramenta de código aberto e é amplamente utilizado na
comunidade de desenvolvimento de software, tornando-a uma habilidade valiosa para os
desenvolvedores.

4. Conceito de repositório Git
Um repositório Git (ou simplesmente "repo") é um diretório onde todos os arquivos e histórico de um
projeto são armazenados. Ele atua como um banco de dados que registra todas as mudanças feitas nos
arquivos ao longo do tempo. Dentro de um repositório Git, você encontrará:
● Arquivos do Projeto: Os arquivos que compõem seu projeto, como código-fonte, documentos,
imagens, etc.
● Metadados do Git: O Git mantém informações sobre o histórico de commits, branches, tags e
muito mais. Esses metadados são armazenados em um diretório oculto chamado ".git" dentro do
repositório.
● Histórico de Commits: Cada alteração feita nos arquivos do projeto é registrada em um "commit".
Um commit é uma unidade fundamental no Git e inclui informações sobre as mudanças, quem fez a
mudança e quando ela ocorreu.
● Branches: Branches são "ramos" separados do código onde você pode trabalhar em recursos ou
correções de bugs sem afetar o código principal. Isso ajuda a organizar o desenvolvimento.

5. Instalação do Git
● Baixe o instalador do Git no site oficial: https://git-scm.com/downloads.
● Execute o instalador e siga as instruções na tela.
● Após a instalação, abra o Git Bash ou o Git GUI para começar a usar o Git.

6. Configuração Inicial do Git (Nome de Usuário e Email)
Depois de ter o Git instalado, é importante configurar seu nome de usuário e endereço de email.
Isso permite que o Git associe suas alterações aos commits corretos. Para configurar isso, siga
os passos abaixo:
Abra um terminal (Git Bash no Windows, Terminal no macOS ou Linux).
Configure seu nome de usuário usando o seguinte comando, substituindo "Seu Nome" pelo seu
nome real ou seu nome de usuário do github e “seu@email.com” pelo seu email:
git config --global user.name "Seu Nome"[enter]
git config --global user.email "seu@email.com"
[enter]
Obs: só use a flag --global em seu próprio computador, em computador compartilhado faça esse
processo em cada projeto que você contribuir, sem essa flag

7. Inicializando um Repositório Git
O comando git init é usado para criar um novo repositório Git localmente em
um diretório existente. Isso significa que você pode transformar uma pasta em um
repositório Git, permitindo que você rastreie as alterações feitas nos arquivos
dentro dessa pasta.
Obs: Se você fez clone corretamente de um projeto já existente em um repositório
remoto, ele já estará inicializado

8. Inicializando um Repositório Git
Aqui estão os passos para inicializar um novo repositório Git:
1. Abra um Terminal ou Prompt de Comando
2. Navegue até o Diretório do Projeto: Use o comando cd para ir para o diretório onde
deseja criar o repositório Git
cd /caminho/para/seu/projeto[enter]
3. Inicialize o Repositório Git
git init[enter]
4. Verifique o Status do Repositório
git status[enter]

9. Comandos Básicos do Git
● git add: O comando git add é usado para selecionar arquivos que você
deseja incluir em seu próximo commit. Ele move os arquivos do seu diretório
de trabalho para a área de preparação (staging area).
○ Sintaxe:
git add nome_do_arquivo[enter]
○ ou para adicionar todos os arquivos alterados:
git add .[enter]

10. Comandos Básicos do Git
● git commit: O comando git commit cria um snapshot (ou commit) de
todas as alterações que foram adicionadas à área de preparação (staging
area) com git add.
○ Sintaxe
git commit -m "Mensagem de commit descritiva"[enter]

11. Comandos Básicos do Git
● git status: O comando git status é usado para verificar o estado atual do
seu repositório Git. Ele mostra quais arquivos estão na área de preparação
(staging area) e quais estão pendentes de commit.
○ Sintaxe
git status[enter]

12. Comandos Básicos do Git
● git log: O comando git log exibe o histórico de commits do seu repositório
Git, listando todos os commits feitos até o momento, incluindo informações
como autor, data, hora e mensagem de commit.
○ Sintaxe
git log[enter]
● Para sair da visualização do log, pressione a tecla q.

13. Exemplo de fluxo de trabalho básico:
1. git add index.html: Adiciona index.html à área de preparação.
2. git status: Verifica o status do repositório para garantir que index.html
tenha sido adicionado corretamente.
3. git commit -m "Adicionando index.html": Cria um novo commit
com as alterações em index.html.
4. git log: Visualiza o histórico de commits para verificar o novo commit.

14. Entendendo Branches e Sua Importância
Branches (ramos) são uma característica essencial do Git e desempenham um
papel fundamental no gerenciamento de versões de código e no desenvolvimento
colaborativo. Eles permitem que você trabalhe em diferentes linhas de
desenvolvimento separadas do seu projeto, isolando as mudanças e evitando que
o desenvolvimento de uma funcionalidade afete diretamente o código principal
(geralmente chamado de "branch principal" ou "branch mestre").

15. Entendendo Branches e Sua Importância
A importância das branches no Git inclui:
● Isolamento de Funcionalidades: Cada branch pode ser usado para desenvolver
uma funcionalidade específica ou corrigir um bug. Isso impede que as alterações
em uma parte do código interfiram em outras partes.
● Experimentação Segura: Você pode criar branches para experimentar novas
ideias ou abordagens sem comprometer o código principal. Se a experimentação
não funcionar, você pode descartar o branch sem afetar o código estável.
● Trabalho em Equipe: Branches facilitam a colaboração entre desenvolvedores.
Diferentes membros da equipe podem trabalhar em suas próprias branches e,
quando estiverem prontos, mesclar suas alterações no código principal.

16. Listando e Criando Branches
O comando git branch é usado para listar as branches existentes em um
repositório Git. Você pode executar este comando sem argumentos para listar
todas as branches disponíveis no repositório
git branch[enter]
Isso exibirá uma lista de todas as branches, com um asterisco (*) ao lado da
branch atual (aquela em que você está trabalhando).

17. Listando e Criando Branches
Para criar uma nova branch, você utiliza o mesmo comando, seguido pelo nome
da nova branch que deseja criar
git branch minha-nova-branch[enter]
Isso criará uma nova branch chamada "minha-nova-branch". No entanto,
lembre-se de que a nova branch ainda não estará ativa; você continuará
trabalhando na branch atual.

18. Trocando Entre Branches
O comando git checkout é usado para alternar entre diferentes branches em
um repositório Git. Para mudar para uma branch específica, você usa o comando
git checkout seguido pelo nome da branch que deseja acessar
git checkout minha-nova-branch[enter]
Isso fará com que você comece a trabalhar na branch "minha-nova-branch". As
mudanças feitas agora serão registradas nessa branch.
É importante observar que quando você muda de uma branch para outra, o
estado do seu diretório de trabalho (arquivos) será atualizado para refletir o
estado da nova branch. Portanto, certifique-se de ter concluído qualquer
trabalho ou commit antes de trocar de branch.

19. O que é o GitHub?
O GitHub é uma plataforma de hospedagem de código-fonte baseada na web que
utiliza o sistema de controle de versão Git. Ele oferece uma ampla variedade de
recursos para gerenciar projetos de desenvolvimento de software, colaboração
em equipe e compartilhamento de código

20. O que é o GitHub?
Algumas das principais características do GitHub incluem:
● Hospedagem de Repositórios: O GitHub permite que você hospede repositórios Git
remotamente na nuvem. Isso significa que você pode acessar, colaborar e compartilhar
código de qualquer lugar com acesso à Internet.
● Controle de Acesso: Você pode controlar quem pode visualizar, clonar, fazer push ou
contribuir para seus repositórios. Isso torna o GitHub adequado para projetos de código
aberto, equipes de desenvolvimento e projetos privados.
● Colaboração: O GitHub oferece recursos para colaboração em equipe, como problemas
(issues), pull requests, revisões de código e wikis. Isso facilita a comunicação e a revisão
de código entre os membros da equipe.
● Gerenciamento de Projetos: Você pode usar o GitHub para criar e gerenciar projetos de
desenvolvimento de software, acompanhando o progresso das tarefas, atribuindo
responsabilidades e definindo marcos.

21. Criando um Novo Repositório no GitHub
Depois de criar uma conta no GitHub, você pode criar novos repositórios para
hospedar seu código. Siga estas etapas para criar um novo repositório no GitHub:
● Faça login na sua conta do GitHub em https://github.com.
● Clique no ícone de "+" no canto superior direito da página e selecione "New
repository" (Novo repositório).
● Preencha o formulário para criar um novo repositório, fornecendo um nome
para o repositório, uma descrição opcional, escolhendo a visibilidade (público
ou privado), selecionando uma licença e escolhendo um arquivo README
inicial (opcional).
● Clique no botão "Create repository" (Criar repositório) para criar o novo
repositório.

22. Conectando o Repositório Local ao GitHub
Conectar seu repositório Git local ao GitHub é essencial para colaboração e para
manter um backup seguro de seu código. Isso envolve a configuração de um
repositório remoto no GitHub e o uso dos comandos git remote e git push
para enviar suas alterações ao GitHub.

23. Adicionando um Repositório Remoto
O comando git remote é usado para gerenciar repositórios remotos em seu projeto Git. Para
adicionar um repositório remoto do GitHub ao seu repositório Git local, siga estas etapas:
● Vá para o GitHub e acesse o repositório que você deseja conectar ao seu repositório local.
● No canto superior direito do repositório, clique no botão "Code" (ou "Código").
● Certifique-se de que a opção "HTTPS" esteja selecionada e copie o URL fornecido.
● Volte ao seu terminal e navegue até o diretório do seu repositório Git local.
● Use o comando git remote add para adicionar o repositório remoto. Substitua
<nome_do_repositório> pelo nome que você deseja dar ao repositório remoto
(geralmente, o nome "origin" é usado como padrão), e <URL_do_repositório> pelo
URL que você copiou do GitHub.
git remote add <nome_do_repositório> <URL_do_repositório>
[enter]

24. Enviando Alterações para o GitHub
Depois de adicionar um repositório remoto, você pode usar o comando git push para
enviar suas alterações para o GitHub. Isso atualizará o repositório remoto com as
alterações do seu repositório local. Aqui está a sintaxe básica:
git push <nome_do_repositório> <branch_local>:<branch_remoto>
● <nome_do_repositório> é o nome do repositório remoto que você configurou
com git remote add. Normalmente, é "origin" por padrão.
● <branch_local> é o nome da branch local que você deseja enviar para o GitHub.
● <branch_remoto> é o nome da branch no repositório remoto onde você deseja
enviar as alterações. Geralmente, é o mesmo nome da branch local, mas pode ser
diferente se você quiser fazer push para uma branch com um nome diferente no
repositório remoto.

25. Colaboração no GitHub
Colaborar com outros desenvolvedores no GitHub é uma parte fundamental do
desenvolvimento de projetos de código aberto e do trabalho em equipe em geral.
Duas das principais ferramentas para colaboração no GitHub são Forks e Pull
Requests.

26. Fork (Bifurcação)
Um "fork" é uma cópia de um repositório de outra pessoa em sua própria conta do
GitHub. Você faz um fork quando deseja contribuir para um projeto sem
permissão de escrita no repositório original.
Para criar um fork, vá até o repositório que deseja bifurcar e clique no botão
"Fork" no canto superior direito da página. Isso criará uma cópia do repositório em
sua conta.
Você agora tem uma cópia independente do repositório e pode fazer alterações
nela.

27. Pull Request (Solicitação de Puxada)
Um "Pull Request" (ou PR) é uma solicitação que você faz ao proprietário do repositório original
para incluir suas alterações em seu projeto. É uma maneira de colaborar e contribuir com o
projeto.
Após fazer as alterações em seu fork, vá até a página do repositório original e clique no botão
"New Pull Request" (Nova Solicitação de Puxada).
Selecione a branch do seu fork que contém as alterações que você deseja incluir na branch
principal do repositório original.
Forneça uma descrição detalhada das alterações feitas e clique em "Create Pull Request" (Criar
Solicitação de Puxada).
O proprietário do repositório original pode revisar suas alterações, fazer comentários, discutir e,
se estiver satisfeito, mesclar suas alterações no projeto original.

28. Resolvendo Conflitos no Git
Conflitos de merge ocorrem quando o Git não pode automaticamente combinar
duas branches durante um processo de merge (fusão). Isso acontece quando
as duas branches em questão têm alterações conflitantes na mesma parte do
código. Para resolver conflitos de merge, você precisa intervir manualmente e
escolher como as alterações conflitantes devem ser combinadas.

29. Resolvendo Conflitos no Git
Os conflitos de merge ocorrem nas seguintes situações:
● Quando duas branches têm alterações conflitantes na mesma linha de um
arquivo. Por exemplo, se uma branch A alterou a linha 10 de um arquivo e,
ao mesmo tempo, uma branch B também fez uma alteração na linha 10, o Git
não pode determinar qual alteração deve prevalecer automaticamente.
● Quando uma branch deletou um arquivo ou uma linha de código e a outra
branch modificou o mesmo arquivo ou linha. O Git não sabe se o arquivo ou
a linha deve ser mantido ou removido.

30. Resolvendo Conflitos no Git
Para resolver conflitos de merge manualmente, siga estas etapas:
● Inicie o Processo de Merge: Inicie o processo de merge da sua branch atual
com a branch que deseja mesclar. Isso geralmente é feito com o comando git
merge.
git checkout branch-que-sera-atualizada
git merge branch-que-tem-as-atualizacoes

31. Resolvendo Conflitos no Git
● Conflitos Detectados: O Git identificará os conflitos e informará quais arquivos têm conflitos
não resolvidos. Você verá mensagens indicando "CONFLICT" (conflito) no terminal.
● Abra o Arquivo em Conflito: Abra o arquivo em conflito em um editor de texto/codigo. Você
verá marcações que indicam onde estão as alterações conflitantes. Geralmente, elas se
parecem com isso:
<<<<<<< HEAD (ou nome da branch atual)
Código da sua branch atual
=======
Código da outra branch
>>>>>>> outra-branch

32. Resolvendo Conflitos no Git
Você precisará escolher como combinar essas alterações.
● Resolva o Conflito: Edite o arquivo para escolher quais partes do código
manter. Você pode optar por manter uma das versões, ambas ou fazer uma
nova edição que combine as alterações de forma significativa.
● Remova as Marcações de Conflito: Após resolver o conflito, remova as
marcações de conflito (as linhas que começam com <<<<<<<, =======, e
>>>>>>>).
● Salve o Arquivo: Salve as alterações no arquivo.
● Adicione e Faça Commit: Após resolver todos os conflitos nos arquivos
afetados, adicione os arquivos usando git add e faça um commit para
finalizar o processo de merge.

33. Resolvendo Conflitos no Git
git add arquivo-em-conflito
git commit -m "Resolvido conflito de merge"
● Conclua o Merge: Agora, o merge deve ser bem-sucedido, e as alterações
conflitantes estarão combinadas no repositório.
● Teste e Valide: Verifique se o código resultante é funcional e atende aos
requisitos.

34. Dicas e Boas Práticas no Git
Trabalhar de maneira eficiente e seguir boas práticas no Git é essencial para
manter um histórico de código limpo e facilitar a colaboração com outros
desenvolvedores. Aqui estão algumas dicas e boas práticas importantes:

35. Dicas e Boas Práticas no Git
Uso de .gitignore:
● O arquivo .gitignore é usado para listar padrões de arquivos e diretórios que
o Git deve ignorar ao rastrear alterações. Isso é útil para evitar que arquivos
temporários, arquivos de compilação e outros arquivos não essenciais sejam
incluídos nos commits.
● Certifique-se de criar e manter um arquivo .gitignore relevante para o seu
projeto. Você pode encontrar modelos de .gitignore para várias linguagens e
frameworks no GitHub/gitignore.

36. Dicas e Boas Práticas no Git
Mensagens de Commit Significativas:
● Escreva mensagens de commit descritivas e significativas. Uma boa
mensagem de commit explica o motivo das alterações e o que foi feito. Ela
ajuda a entender rapidamente o propósito de um commit quando você
revisita o histórico mais tarde.
● Siga uma convenção de mensagem de commit, como Conventional Commits,
para padronizar suas mensagens e facilitar a automação de tarefas, como
geração de notas de lançamento.

37. Dicas e Boas Práticas no Git
Evitar Commits Grandes Demais:
● Evite criar commits enormes que incluam muitas alterações não
relacionadas. Commits menores e focados são mais fáceis de revisar,
entender e desfazer, se necessário.
● Divida seu trabalho em tarefas e crie commits para cada tarefa concluída.
Isso ajuda a manter um histórico de desenvolvimento mais claro.

38. Dicas e Boas Práticas no Git
Atualização Frequente do Repositório Remoto:
● Mantenha o repositório remoto (como o GitHub) atualizado regularmente com
seus commits locais. Isso ajuda a evitar conflitos de merge significativos e
facilita a colaboração com outros desenvolvedores.

39. Dicas e Boas Práticas no Git
Revisão de Código (Code Review):
● Sempre que possível, peça a outros membros da equipe que revisem seu
código antes de fazer um commit ou uma solicitação de puxada (Pull
Request). As revisões de código ajudam a identificar erros, melhorar a
qualidade do código e disseminar conhecimento entre a equipe.

40. Dicas e Boas Práticas no Git
Documentação Adequada:
● Mantenha a documentação atualizada, incluindo READMEs, comentários de
código e documentação de API, conforme necessário. Uma boa
documentação torna o código mais acessível e ajuda outros desenvolvedores
a entender e usar seu projeto.

41. Dicas e Boas Práticas no Git
Mantenha a História do Git Limpa:
● Evite reverter commits antigos ou fazer alterações diretas na história do Git
após terem sido compartilhadas com outros colaboradores. Isso pode causar
problemas para outros desenvolvedores que estão trabalhando no mesmo
projeto.

42. Dicas e Boas Práticas no Git
Use Branches Adequadamente:
● Use branches para desenvolver funcionalidades ou corrigir bugs
separadamente. Isso ajuda a manter o código principal (normalmente a
branch "main" ou "master") estável e permite que você trabalhe de forma
isolada em novos recursos.

43. Extra - Git com VS Code
O VS Code nos ajuda muito também com a parte de git. Busque pelo ícone
abaixo e lá terão todas as funcionalidades relacionadas a versionamento de
código (git e github)

44. Extra - Git com VS Code
Depois de inicializar o git começa a marcar os
arquivos que foram modificados mas ainda não
foram adicionados à área de preparação
(todos os arquivos do seu repositório)
Você pode adicionar de 1 por 1 clicando no +
que aparece ao lado do nome do arquivo, ou,
clicar com o botão direito em Alterações e
selecionar “Preparar todas as
alterações” ou simplesmente escrever uma
mensagem no campo de cima e clicar em
Confirmação (isso vai add todos os arquivos
e também efetuar um commit)

45. Extra - Git com VS Code
Depois de dar o commit (no repositório local) o botão vai modificar e sugerir para
a publicação das alterações também no repositório remoto. Além disso a lista de
arquivos já não estará lá pois as modificações foram salvas.

46. Extra - Git com VS Code
Ao clicar para publicar o código o VSC vai reconhecer (se você estiver logado) e
sugerir a criação de um novo repositório remoto (já que esse foi inicializado direto
na suas pastas). Coloque um nome no seu novo repositório e selecione se ele
será público ou privado. Depois só aguardar (depende da conexão) os arquivos
serem enviados

47. Extra - Git com VS Code
Se tudo correr bem a mensagem a seguir aparecerá no canto inferior direito e o
botão de confirmação ficará desabilitado

48. Extra - Git com VS Code
Agora voltando ao explorador do VSC qualquer modificação fará o arquivo ser
marcado como modificado M. Qualquer inserção de arquivos/pastas será
marcada como não acompanhado U (ou seja o git não está vendo se há
alterações, então é necessário executar o git add ou usar o icone + la no controle
de código para esse arquivo novo)

49. Extra - Git com VS Code
De volta ao controlador de versões de código temos as indicações de arquivo
modificado M, arquivo nao acompanhado U e arquivo deletado D.
Podemos novamente escrever uma mensagem -> confirmar -> publicar
(para fazer um commit local e depois subir as novidades para o repositório
remoto)

50. Extra - Git com VS Code
No canto inferior esquerdo podemos ver o icone abaixo com o nome da branch
atual, ao clicar no nome teremos várias opções relacionadas às branches

51. Extra - Git com VS Code
Podemos criar novas branches ou troca de banch pois ele exibe uma lista de
todas as branchs reconhecidas bastando clicar no nome da branch que você
deseja ir. Obs você não pode ter modificações pendentes para poder trocar a
branch, você deve ou dar commit ou descartá-las