## Configuração
O Git é um sistema de controle de versão distribuído usado para rastrear as alterações em arquivos ao longo do tempo. Antes de começar a usar o Git, é importante configurar algumas informações pessoais, como seu nome de usuário e endereço de e-mail, para que os commits que você fizer sejam atribuídos corretamente.
As configurações globais (definidas com a opção **- -global**) são aplicadas em todos os repositórios que você utilizar no seu computador. Se você quiser configurar opções específicas para um repositório, você pode executar os mesmos comandos dentro desse repositório, mas sem a opção **- -global**.
Essas informações não são de autenticação. Elas apenas identificam quem fez determinados commits no histórico do Git. Para autenticação, se você estiver trabalhando com repositórios remotos, você geralmente usará HTTPS ou SSH.
### Configurar Nome de Usuário:
```bash
git config --global user.name "Seu Nome"
```
### Configurar Email
```bash
git config --global user.email "seuemail@example.com"
```
## Inicialização
Iniciar um repositório é o primeiro passo para começar a rastrear as mudanças em seus arquivos usando o Git. Um repositório é basicamente um diretório onde todos os arquivos do seu projeto e suas respectivas versões serão armazenados.
### Abrir um repositorio
É mais prático criar e abrir o terminal no repositorio, porém o comando para abrir uma pasta é **cd**
```bash
cd /caminho/para/seu/projeto
```
### Iniciar o Repositório
Comando para iniciar um novo repositório Git na pasta do seu projeto
```bash
git init
```
## Clonagem e Repositorio Remotos
Clonar um repositório remoto permite que você obtenha uma cópia completa do projeto em algum servidor remoto em sua máquina local. Isso é especialmente útil quando você deseja colaborar ou contribuir para um projeto existente.
Com a url do repositorio do git (github, gitlab etc..)
### Comando de Clonagem:
```bash
git clone <URL>
```
## Adicionar e Confirmar mudanças
O processo de adicionar e confirmar mudanças no Git envolve algumas etapas para registrar e documentar as alterações que você fez nos seus arquivos.
### Git Status
O comando git status é usado para obter informações sobre o estado atual do seu repositório Git. Ele fornece uma visão geral das alterações que foram feitas, quais arquivos estão no staging area (área de preparação para commit), e se há alguma diferença entre o seu repositório local e o repositório remoto. O git status é uma ferramenta útil para entender quais etapas você precisa tomar antes de criar um novo commit ou sincronizar suas mudanças com o repositório remoto.
```bash
git status
```
**você verá informações sobre**:
**Branch Atual**: O nome do branch atual em que você está trabalhando.
**Changes to be committed**: Isso mostra as mudanças que foram adicionadas à área de staging (preparação para commit) e que estão prontas para serem incluídas no próximo commit.
**Changes not staged for commit**: Aqui estão as alterações feitas nos arquivos que ainda não foram adicionados ao staging area. Essas mudanças não farão parte do próximo commit a menos que você as adicione explicitamente.
**Untracked files**: Esses são os arquivos que estão presentes no diretório de trabalho, mas o Git ainda não está rastreando. Eles não foram adicionados à área de staging nem incluídos em commits anteriores.
### Adicionar Arquivos e Realizar Commits
Com o repositório criado, você pode começar a adicionar arquivos ao controle de versão, adicionando-os ao "**staging area**" e, em seguida, realizando commits.
**Staging area =>** Basicamente uma área de preparação intermediária. Quando um arquivo é alterado, devemos passa tudo que queremos salvar no commit para o staging area, em seguida confirmar/alterar e/ou apagar o que não queremos e por fim realizar o commit salvando no histórico do git.
- **Adicionar arquivos ao staging area**
Este comando adiciona todos os arquivos alterados ao staging area. Se você quiser adicionar um arquivo específico, substitua o . pelo nome do arquivo.
```bash
git add .
```
- **Remover arquivos da staging area**
No caso de precisar remover todos os arquivos ou um em especifico basta utilizar o comenado:
```bash
git restore --staged .
```
Ou
```bash
git restore --staged <nomeDoArquivo>
```
- **Realizar um commit das mudanças no staging area**
A "Mensagem do Commit" deve ser uma descrição breve e informativa das mudanças que você está incluindo neste commit. Essa mensagem ajuda a entender o propósito do commit no futuro.
```bash
git commit -m "Mensagem do Commit"
```
### Editar e Reorganizar Commits (Opcional)
Se você precisar ajustar ou corrigir um commit anterior, você pode usar comandos como git commit --amend para editar o último commit, ou ferramentas de rebase para reorganizar commits. No entanto, isso também pode ser arriscado, especialmente se você já compartilhou os commits com outros colaboradores então é bom avisar antes sobre.
* **Editar o Último Commit**:
Se você precisar fazer pequenas alterações no último commit, como corrigir uma mensagem de commit ou adicionar um arquivo que você esqueceu, pode usar o comando git commit --amend (após ter adicionado com o git add)
```bash
git commit --amend -m "Nome do commit"
```
## Branch
Um branch é uma linha independente de desenvolvimento no Git. Ele permite que você trabalhe em diferentes versões do código simultaneamente, sem interferir diretamente no branch principal (normalmente chamado de "main" ou "master"). Cada branch tem seu próprio histórico de commits, permitindo que você experimente novos recursos, corrija bugs ou trabalhe em diferentes partes do projeto de forma isolada.
### Criar um Novo Branch
```bash
git branch novo-branch
```
### Listar Branches
```bash
git branch
```
### Mudar para um Branch
```bash
git checkout novo-branch
```
### Criar e Mudar para um Novo Branch
```bash
git checkout -b novo-branch
```
### Excluir um Branch
```bash
git branch -d <nome da branch>
```
### Mesclar Branches
Para mesclar as alterações de um branch em outro, primeiro mude para o branch de destino
```bash
git checkout main
git merge branch-teste
```
- Pode acontecer conflitos de merge e será necessário resolver antes de juntar as branches
### Forçar a Exclusão de um Branch
Se você precisa excluir um branch mesmo que ele contenha alterações não mescladas, use o comando **-D**:
```bash
git branch -D branch-para-excluir
```
## Resolvendo Conflitos
É comum existir conflitos quando juntamos diferentes branches. Seja uma linha ou o código todo caso dois arquivos tenha sido modificados, não será possível fazer o merge até resolver o conflito.
- Inicialmente vamos puxar o código de um branch para a nossa atual.
```bash
git checkout main
git merge branch-teste
```
- No caso de conflito uma mensagem de erro vai aparecer, então para saber quais arquivos estão conflitando:
```bash
git status
```
Algo semelhante a essa mensagem vai aparecer.
- Nas opções a esquerda, em source control. Aperece também os arquivos em conflitos. Ao clicar no arquivo um botão no canto inferior direito `Resolve in Merge Editor` levar para o editor de Merge
- Após resolver as diferenças basta commitar todos os arquivos
## Atualizar e Mesclar
Quando você está trabalhando em um repositório Git que envolve colaboração com outros desenvolvedores ou quando há mudanças no repositório remoto, você precisará atualizar seu repositório local para incorporar essas mudanças. A atualização pode envolver puxar as mudanças do repositório remoto para o seu repositório local e mesclá-las com as suas próprias alterações.
### Puxar Mudanças do Repositório Remoto
```bash
git pull origin <nome_branch>
```
- Isso combina o git fetch (que busca as mudanças remotas) e o git merge (que mescla as mudanças trazidas pelo fetch) em um único comando.
### Enviar Mudanças para o Repositório Remoto
```bash
git push origin <nome_branch>
```
### Atualizar o Repositório Local com Fetch
O comando git fetch busca as mudanças do repositório remoto, mas não as mescla automaticamente no seu repositório local. Isso é útil para verificar as mudanças antes de mesclá-las:
```bash
git fetch origin
```
### Atualizar um Branch Específico
Para atualizar um branch específico sem trocar para ele, você pode usar git pull com a opção --rebase:
```bash
git pull --rebase origin <nome_branch>
```
### Visualizar Diferenças Antes de Mesclar
Antes de mesclar as mudanças, você pode ver as diferenças entre o seu branch e o branch remoto usando git diff:
```bash
git diff <seu_branch> origin/<seu_branch>
```
## Histórico
O histórico de commits é uma parte essencial do Git, pois permite rastrear todas as alterações feitas no projeto ao longo do tempo. Cada commit representa um conjunto de mudanças que foram adicionadas ao repositório, acompanhadas de mensagens descritivas que explicam o propósito das mudanças.
### Revisar o Histórico de Commits
Com os commits criados, você pode revisar o histórico de commits usando o comando git log. Isso exibirá informações sobre cada commit, incluindo o autor, data, mensagem e um identificador único.
```bash
git log
```
- Histórico Simplificado
```bash
git log --oneline
```
### Histórico em Formato de Gráfico
Para uma representação gráfica do histórico de commits. Isso mostra como os commits estão conectados, destacando os ramos e as junções
```bash
git log --graph
```
### Filtrar o Histórico
Você pode filtrar o histórico usando várias opções. Por exemplo, para ver os commits de um autor específico
```bash
git log --author="nome_do_autor"
```
- Ver por intervalo de datas
```bash
git log --since="yyyy-mm-dd" --until="yyyy-mm-dd"
```
### Mostrar Diferenças de Commits
Para ver as diferenças introduzidas por um commit específico, O comando é:
```bash
git show <commit>
```
### Visualizar Alterações Entre Commits
Isso mostra as diferenças nos arquivos entre os dois commits.
```bash
git diff <hash_commit_anterior> <hash_commit_posterior>
```
## Desfazer Mudanças
Às vezes, você pode cometer erros ou decidir que deseja descartar as alterações feitas em um arquivo ou até mesmo em um commit. O Git oferece várias maneiras de desfazer mudanças, desde remover alterações do staged area até reverter commits inteiros.
### Desfazer Alterações em Arquivos Não Preparados
Se você fez alterações em um arquivo, mas não adicionou essas mudanças à área de staging, pode usar o comando git checkout para restaurar o arquivo ao estado do último commit:
```bash
git checkout -- <nome_arquivo>
```
### Retirar Arquivos do Staging Area
Se você adicionou um arquivo ao staging area, mas deseja removê-lo sem descartar as alterações feitas, utilize git reset:
```bash
git reset <nome_arquivo>
```
### Descartar Todas as Mudanças Locais
Se você deseja descartar todas as mudanças locais e retornar ao último commit, use git reset com a opção --hard:
isso descartará todas as alterações no diretório de trabalho e na área de staging.
```bash
git reset --hard HEAD
```
### Desfazer o Último Commit (Mantendo Alterações)
Se você cometeu algo errado no último commit, mas deseja manter as alterações locais para fazer um novo commit, use git reset sem a opção --hard:
Isso desfaz o commit, mas mantém as mudanças locais no diretório de trabalho e na área de staging.
```bash
git reset HEAD~1
```
### Reverter um Commit
Se você deseja reverter completamente um commit específico (criando um novo commit que desfaz as alterações do commit original), use o comando git revert:
Isso cria um novo commit que desfaz as alterações introduzidas pelo commit original.
```bash
git revert <hash_do_commit>
```
## Tags
As tags são usadas no Git para marcar pontos específicos na história do projeto, como versões estáveis, lançamentos ou marcos importantes. Diferentemente das branches, as tags não se movem com novos commits e são usadas para criar pontos de referência fixos para certos momentos no histórico.
### Criar uma Tag Anotada
Para criar uma tag anotada (que inclui informações sobre o autor, data e mensagem), use o comando
```bash
git tag -a v1.0 -m "Primeiro lançamento estável"
```
### Criar uma Tag Leve
As tags leves são simples referências a um commit específico e não contêm informações adicionais. Use o comando git tag <nome_tag> para criar uma tag leve
```bash
git tag v1.0
```
### Listar Tags
Para listar as tags existentes no repositório
```bash
git tag
```
### Enviar Tags para o Repositório Remoto:
As tags criadas localmente não são enviadas para o repositório remoto por padrão.
```bash
git push origin --tags
```
### Mostrar Informações de uma Tag:
Para ver as informações associadas a uma tag específica, use git show com o nome da tag:
```bash
git show v1.0
```
### Deletar uma Tag:
Para deletar uma tag, use o comando git tag -d <nome_tag>:
```bash
git tag -d v1.0
```
- E para remover uma tag no repositório remoto, use git push com a opção --delete:
```bash
git push origin --delete <nome_tag>
```
## Outros Comandos Uteis
### Mostrar Diferenças Não Preparadas:
Para ver as diferenças entre o diretório de trabalho e a área de staging, use o comando git diff:
```bash
git diff
```
### Mostrar Diferenças Preparadas:
Para ver as diferenças entre o que está na área de staging e o último commit, use git diff --staged:
```bash
git diff --staged
```
### Verificar o Estado Remoto:
Para ver a diferença entre o seu repositório local e o repositório remoto, use o comando
```bash
git remote show origin
```
### Remover um Arquivo do Repositório (e manter localmente):
Se você quiser remover um arquivo do controle de versão, mas mantê-lo localmente, use:
```bash
git rm --cached <nome_arquivo>
```
### Visualizar as Alterações no Último Commit:
Para ver as alterações feitas no último commit, use o comando git show com a opção --stat:
```bash
git show --stat HEAD
```
# Passo a Passo
## Comandos Usados em sequência
- Configurar Nome do Usuario
- git config --global user.name "Seu Nome"
- Configuarar Email
- git config --global user.email "seuemail@example.com"
- Clonar Repositorio
- git clone "linkrepositorio"
- Verificar status de branch, arquivos alterados, arquivos na área de staging e arquivos ignorado para commit
- git status
- Puxar todos os commits do repositorio na nuvem (Em caso de repositorio de colaboração)
- git pull origin <nome_branch>
- Adiciona todos os arquivos para a staging area
- git add . (git add <nomeDoArquivo> -> adiciona individualmente)
- Commitar as mudanças feitas
- git commit -m "Nome do Commit"
- Apagar todas as mudanças locais e voltar exatamente a como estava o ultimo commit
- git reset --hard HEAD
- Desfazer o ultimo commit porém mantendo todas as alterações
- git reset HEAD~1 (Ao fazer um git log vai notar que o ultimo commit foi apagado, porém o código se manteve igual)
- Enviar os commit para o repositorio na nuvem
- git push origin main
### Branch
- Criar e vizualizar branch
- git branch <nomeDaBranch>
- git branch
- Trocar Branch
- git checkout <nomeDaBranch>
- Adicionar novo commit (Commit feito na branch nova)
- git add .
- git commit -m "Nome do commit"
- Trocar de branch (necessário que não tenha nenhuma mudança)
- git branch
- git checkout <nome-da-branch>
- Juntar as Branch (necessário estar na branch main ou na branch que deseja manter)
- git merge branch-teste
Sign in with Wallet
Connect another wallet