git no dia-a-dia

As descrições de comandos foram colhidas no site: https://www.atlassian.com/br/git/tutorials
Para maiores detalhes, recomendo muito que acesse o site acima.

• Apenas um alfarrábio para manter os principais comandos do GIT que serão utilizados por mim:

Índice

1 - Primeiros passos
2 - Visualizando Branches
3 - Comandos do GIT
4 - Erros comuns

1 - Primeiros passos

Instalando o git:

• Acesse: https://git-scm.com/
• Efetue o download que melhor lhe atender;
• Faça a instalação "next - next";
• Se o prompt estiver aberto feche e abra novamente. Digite o comando "git". Deverão aparecer uma série de opções de comando demonstrando que o git foi instalado com sucesso.

OBS.: Linux:

sudo apt install git

Iniciando no GIT

• Entre na pasta que deseja que o git faça o monitoramento;
• Dê o comando: git init
• Para verificar se o git já está "enxergando" a pasta que você inicializou, dê o comando: git status;
• Para incluir todos os arquivos no monitoramento do git dê o comando: git add .;
• Se quiser apenas alguns arquivos do repositório dê o comando: git add ;
• Para efetivar a versão do arquivo que está sendo salvo dê o comando: git commit -m "<descrição da alteração feita>"
• Caso não esteja logado uma mensagem de erro aparacerá e será sugerido os comandos abaixo: git config --global user.email "seu-email" git config --global user.name "seu-nome"
• Para verificar o histórico de modificações: git log;
• Para ver o log de maneira simplificada: git log --oneline;
• Para ver um log mais completo git log -p
• Para mais opções de log: https://devhints.io/git-log
• Para o git ignorar o monitoramento de um ou mais arquivos:
  • na pasta do projeto, crie um arquivo chamado .gitignore;
  • inclua neste arquivo o nome dos arquivos que não queira que o git monitore.
  • inclua este arquivo, .gitignore, na monitoração do git: git add -gitignore - git commit -m "Incluindo gitignore"

ATENÇÃO

Não inicialize um repositório do git quando ele for criado com README.MD.

Criando servidor remoto

A vantagem de se criar um servidor remoto ou servidor remoto é que todos da equipe podem acessá-lo para compartilhar suas atualizações.

• Crie uma pasta e execute o comando: git init --bare
• Esse repositório não vai conter uma cópia fisica dos arquivos, só das suas alterações;
• Para adicionar um repositório remoto na pasta onde o git está monitorando, execute:git remote add <endereço do local do servidor>;
• Para verificar se o repositório remoto foi criado dê o comando:git remote --v;

Trazendo dados de repositório remoto

• Na pasta onde deseja baixar os dados do repositório remoto dê o comando:git clone <endereço do repositorio remoto> <nome da psata que será criada>

Enviando dados para o repositório remoto

• Para enviar os dados para o repositório remoto, comando: git push

Desfazendo alterações

• Quando você faz uma alteração em uma pasta monitorada pelo git, esta pode ser desfeita com o comando: git checkout --

• Quando essa alteração é feita e você preparou para o commit com o git add, o comando é: git reset HEAD

• Quando essa alteração é feita e você já deu um commit, a sequencia é: git log (aqui vc deve pegar o hash do commit que foi dado; git revert

• Recuperando um commit

  • Efetue o comando git log para localizar o hash do commit que quer recuperar;
  • Execute git checkout <6 primeiros digitos do hash>;
  • Crie uma nova branch para salvar a recuperação feita antes;

Fazendo alterações temporárias

• Comando git stash (salva alteração temporária)
• Comando git stash list (lista as alterações temporárias)
• Comando git stash drop 0 (retira da lista do stash na posição 0)
• Comando git stash pop (faz um merge da alteração temporária com a atual e retira da lista do stash)

Boa prática

• Sempre que tiver um código pronto, envie-o para o repositório principal(master):
  • git push local master

Vendo diferenças

• git diff (hash commit inicial)..(hash commit final)
• Será apresentado da seguinte forma:
  +linha adicionada
  -linha removida
  -linha modificada (versão antiga)
  +linha modificada (nova versão)

Gerando versões no git

- Gerando uma versão no git, você estará indicando que aquela versão tem uma certa estabilidade e que toda alteração depois dela deve ser considerada uma nova versão.
- Comando para isso é: git tag -a (nomenclatura que escolher) -m "texto que escolher" - Para enviar a versão que criou para a branch local: git push local (nome da versao)

2 - Visualizando Branches

• Ferramenta para visualização do comportamento de branches: https://git-school.github.io/visualizing-git/

3 - Comandos do GIT

git status:

O comando git status exibe as condições do diretório de trabalho e da área de staging. Ele permite que você veja quais alterações foram despreparadas, quais não foram e quais arquivos não estão sendo monitorados pelo Git.

git push:

O comando git push é usado para enviar conteúdo do repositório local para um repositório remoto. "Push" é como os commits do repositório local são enviados a um repositório remoto.

git pull:

O comando git pull é usado para buscar e baixar conteúdo de um repositório remoto e atualizar na hora o repositório local para que tenha o mesmo conteúdo. Fazer merge de alterações remotas de upstream em seu repositório local é uma tarefa comum em fluxos de trabalho de colaboração baseados em Git. O comando git pull é, na verdade, uma combinação de dois outros comandos git fetch seguido por git merge. Na primeira etapa da operação, git pull vai executar um git fetch do escopo para o ramo local ao qual HEAD está apontado. Depois que o conteúdo for baixado, git pull vai entrar em um fluxo de trabalho de merge. Um novo commit de merge vai ser criado e HEAD vai ser atualizado para apontar para o novo commit.

git add:

O comando git add adiciona uma alteração no diretório ativo à área de staging. Ele diz ao Git que você quer incluir atualizações a um arquivo particular na próxima confirmação. No entanto, git add não afeta realmente o repositório de nenhuma forma significativa—as alterações não são realmente gravadas até você executar git commit.
Exemplo: git add .

git commit:

O comando git commit captura um instantâneo das mudanças preparadas do projeto no momento. Os instantâneos com commit podem ser considerados versões "seguras" de um projeto, o Git nunca os altera, a menos que você peça a ele. Antes da execução de git commit, o comando git add é usado para promover ou "preparar" mudanças no projeto que são armazenadas em um commit. Estes dois comandos git commit e git add estão entre os mais usados.
Exemplo: git commit -m "comentário"

• Explicando o exemplo: -m é um comando de atalho que cria de imediato um commit com uma mensagem de commit transmitida. Por padrão, git commit abre o editor de texto configurado no local e solicita que uma mensagem de commit seja escrita. Transmitir a opção -m vai pular a solicitação do editor de texto em favor de uma mensagem integrada.

ATENÇÃO

1 - Só dê o comando de commit em códigos FUNCIONAIS. Se ainda não estiver OK, não use este comando.

2 - Os comandos git add e git commit compõem o fluxo de trabalho fundamental do Git. Esses são os dois comandos que cada usuário do Git precisa entender, independentemente do modelo de colaboração da equipe. Eles são os meios para gravar versões de um projeto no histórico do repositório. Além de git add e git commit, um terceiro comando git push é essencial para um fluxo de trabalho colaborativo completo do Git.

git fetch:

O comando git fetch baixa commits, arquivos e referências de um repositório remoto para seu repositório local. Busca (fetching) é o que você faz quando quer ver em que todos estão trabalhando. É semelhante ao svn update, que permite que você veja como a história central tem progredido, mas não obriga a de fato fazer o merge das mudanças em seu repositório. O Git isola o conteúdo buscado de um conteúdo local existente e não tem efeito algum no trabalho local de desenvolvimento. O conteúdo buscado tem de ser explicitamente verificado, usando o comando git checkout . Isso faz com que a busca seja uma forma segura de analisar commits antes de serem integrados ao repositório local.

git checkout:

• Em termos Git, um “checkout” é o ato de alternar entre versões diferentes de uma entidade de destino. O comando git checkout opera em três entidades distintas: arquivos, commits e branches. Além da definição de “checkout”, o termo “verificação” costuma ser usado para implicar o ato de executar o comando git checkout.

Exemplo1: git checkout -b <new-branch>

• O exemplo acima cria e verifica o <new branch> ao mesmo tempo. A opção -b é uma sinalização de conveniência que diz ao Git para rodar o git branch <new-branch> antes de rodar o git checkout <new-branch>.

Exemplo2: git checkout -b <new-branch> <existing-branch>

• Por padrão, o git checkout -b vai usar como base para o new-branch o HEAD atual. Outro parâmetro de branch opcional pode ser transmitido para o git checkout. No exemplo acima, <existing-branch> é transmitido e, então, o new-branch toma o existing-branch como base em vez do HEAD atual.

git branch:

• O comando git branch permite criar, listar, renomear e excluir ramificações. Ele não permite que você alterne entre as ramificações ou reúna uma história bifurcada novamente. Por esse motivo, o comando git branch é firmemente integrado com os comandos git checkout e git merge.

Exemplo1: git branch

• Listar todas as ramificações no seu repositório. Isso é sinônimo de git branch --list.

Exemplo2: git branch <branch>

• Criar uma nova ramificação chamada <branch>. Isso não verifica a nova ramificação.

Exemplo3: git branch -d <branch>

• Excluir a ramificação especificada. Esta é uma operação “segura” em que o Git impede que você exclua a ramificação se tiver mudanças não mescladas.

git rebase:

Rebase é um dos dois utilitários do Git que se especializam em integrar alterações da ramificação para outra. O outro utilitário de integração de alterações é o git merge. o rebase tem recursos poderosos para reescrever o histórico. Rebasing é o processo de mover ou combinar uma sequência de confirmações para uma nova confirmação base.

4 - Erros comuns

• error: failed to push some refs to...

Solução:
git pull --rebase
git push