1. Home
  2. GIT
  3. Referência rápida GIT

Referência rápida GIT

Índice

Esse é um guia de como instalar o GIT, configura-lo e como utilizar os comandos principais.

Sobre o GIT

TODO: Complementar…

Instalar o cliente do git no Windows

Iniciando com o github

O github é um serviço que utiliza o protocolo GIT, você pode utiliza-lo para guardar os seus projetos pessoais. Seus repositórios podem ficar visíveis para todos (público) ou somente para você (privado). É um bom exercício criar um repositório no github para praticar os comandos do git mesmo que você não vá utilizar o serviço do github futuramente.

1- Criar uma conta no github.com

Primeiramente, acesse o site do github e crie uma conta para você: https://github.com/

Então, você terá um espaço para você, o meu por exemplo é: https://github.com/educoutinho

2- Criar um repositório

Agora, você pode criar seu primeiro repositório.

Acesse a lista de repositórios e escolha a opção para criar um novo.

Informe um nome para o respositório, por exemplo: “meu-primeiro-repo”

Clique em confirmar e então o repositório será criado:

3- Gerar uma chave SSH no seu computador

Abra um prompt de comando do windows (iniciar / Command Prompt) e digite:

ssh-keygen -t rsa -C “seu-email@example.com”

NOTA: Substituir “seu-email@example.com” pelo seu e-mail.

Isso irá gerar uma chave no seu computador para identificar o seu usuário no github

Agora, abra um bloco de notas (iniciar / executar / notepad) e abra o seguinte arquivo:

%userprofile%.ssh\id_rsa.pub

Esse arquivo fica na pasta do seu usuário, no meu caso é: C:\Users\educoutinho\.ssh\id_rsa.pub

Copie todo o conteúdo desse arquivo.

4- Adicionar a chave SSH no seu github

Agora, volte ao github e acesse:

https://github.com/settings/keys

e escolha a opção para adicionar uma nova chave SSH:

Dê um nome para a chave e cole todo o conteúdo do arquivo copiado no passo anterior:

E clique no botão adicionar.

5- Clonar um repositório para o seu computador

Agora, você está pronto para clonar um repositório. Volte no repositório que você criou, clique no botão “Code” e então copie o caminho do SSH:

No caso do meu repositório, o caminho é:

git@github.com:educoutinho/meu-primeiro-repo.git

Você já deve ter instalado o cliente do Git, se não tiver fazer o download e a instalação

Agora, escolha uma pasta no seu computador para guardar os repositórios, no meu caso estou utilizando: c:\dev

Clique com o botão direito do mouse nessa pasta e escolha “Gith bash here”

E então utilize o comando “git clone” + o endereço que você copiou no passo anterior

git clone git@github.com:educoutinho/meu-primeiro-repo.git

Como é o primeiro repositório que você está clonando com a chave adicionada, será perguntado:

Are you sure you want to continue connecting (yes/no/[fingerprint])?

Digite “yes” e pressione enter

E então acesse a pasta do seu repo:

cd meu-primeiro-repo

Agora você pode executar comandos de GIT no repo, por exemplo:

git status

6- Abrir um prompt do git na pasta de um repositório clonado

Todos os arquivos do repositório vão estar disponíveis localmente

No meu caso, estão na pasta: C:\dev\meu-primeiro-repo

Para abrir um prompt de comando do git nessa pasta, basta novamente clicar com o botão direito na pasta e escolher a opção “Git bash here”

Utilizando múltiplas contas do github no mesmo computador

NOTA: Se você está iniciando com o GIT agora, pule esse tópico.

Abaixo o processo para poder utilizar mais de uma conta do github no computador, por exemplo, se você tiver uma conta pessoal e uma conta corporativa e utiliza as duas no seu computador.

Os passos estão descritos aqui: https://gist.github.com/rahularity/86da20fe3858e6b311de068201d279e3 e abaixo eu adaptei para o windows.

Abrir um prompt de comando do windows:

cd %userprofile%\.ssh

ssh-keygen -t rsa -C "emailpessoal@gmail.com" -f "github-pessoal"
ssh-keygen -t rsa -C "email@empresa.com.br" -f "github-corporativo"

NOTA: Substituir no comando acima, o e-mail

Adicionar as chaves no SSH CrossAxisAlignment

ssh-add github-pessoal
ssh-add github-corporativo

Se ocorrer erro nesse comando, provavelmente o serviço não está rodando. Abra um PowerShell como administrador e rode:

get-service ssh-agent
get-service ssh-agent | select startType
get-service -name ssh-agent | set-service -startupType Manual
start-service ssh-agent

Então, rode o comando “ssh-add” novamente.

Crie um arquivo “config” na pasta %userprofile%.ssh, com o seguinte conteúdo:

Host github.com-pessoal
	HostName github.com
	User git
	IdentityFile %userprofile%\.ssh\github-educoutinho

Host github.com-corporativo
	HostName github.com
	User git
	IdentityFile %userprofile%\.ssh\github-taskrow

Adicione as chaves criadas no github pessoal e corporativo. As chaves estão nos arquivos:

%userprofile%\.ssh\github-pessoal.pub
%userprofile%\.ssh\github-corporativo.pub

Ao clonar o repositório, utilize:

git remote add origin git@github-pessoal:username/repo.git

Se os e-mails corporativos e pessoais forem diferentes, a cada repositório clonado, é necessário executar:

git config user.email "email@empresa.com.br"
git config user.name "Eduardo Coutinho"

Utilizando o básico do GIT

No seu computador é armazenado uma cópia dos arquivos do repositório que estão no servidor, que pode ser por exemplo o github.com

Arquivos locais:

Arquivos no servidor:

Você vai trabalhar localmente (nos arquivos do seu computador) nas modificações e então vai enviar essas modificações para o servidor, para que outras pessoas possam acessa-las, por exemplo, os outros membros da sua equipe.

Podemos por exemplo criar um arquivo de texto: “teste.txt”:

Então vou preencher um texto qualquer no arquivo:

E salve o arquivo.

Para abrir um prompt de comando do git nessa pasta, basta novamente clicar com o botão direito na pasta e escolher a opção “Git bash here”

Arquivos modificados (git status)

Para verificar arquivos modificados execute:

git status

E podemos ver que temos marcado um arquivo modificado “teste.txt”

Comitar as modificações realizados (git commit)

Para enviar essas modificações para o servidor, primeiro previsamos executar:

git add .

Para informar que todos os arquivos modificados serão adicionados

E então executar:

git commit -m “Adicionado primeiro arquivo”

Enviar as modificações para o servidor (git push)

Os commits são todos gravados localmente no seu repositório, para enviar eles para o servidor utilize o comando:

git push

Se você acessar o github, irá localizar o arquivo adicionado:

Baixar modificações do servidor (git pull)

Para baixar para o seu repositório as modificações que estão no servidor, executar:

git pull

Configuração

(Se você é iniciante no GIT, pule esse tópico por enquanto)

configurações de usuário

$ git config --global --list
$ git config --global user.name "Eduardo Coutinho"
$ git config --global user.email email@gmail.com

listar configurações do usuário

$ git config --list
$ git config user.name

Configuração case sensitive

$ git config core.ignorecase
$ git config --global core.ignorecase true

Configuração ajustar automáticamente quebras de linha “crlf”

$ git config core.autocrlf
$ git config --global core.autocrlf true

Alterar o editor padrão do Git

O editor padrão do GIT é o VI

Alterar o editor para Notepad

$ git config core.editor notepad

Alterar o editor para Notepad++

$ git config --global core.editor "'C:\Program Files (x86)\Notepad++\notepad++.exe' -multiInst -notabbar -nosession -noPlugin"

Atenção: Antes de rodar esse comando, verifique se o Notepad++ está instalado na pasta: “C:\Program Files (x86)\Notepad++"

Iniciando um repositório local

(Se você é iniciante no GIT, pule esse tópico por enquanto e utilize o repositório criado no github no passo acima)

O git trabalha com repositórios locais (ficam em pastas do seu computador) e que podem ser sincronizados com o servidor, que pode ser o github.com por exemplo. Para iniciar você precisa criar um repositório local, para isso existem duas opções:

clonar um repositório existente

Abra um prompt de comando do Windows e vá até a pasta que você deseja colocar os seus projetos, por exemplo: “C:\Temp”, depois execute o comando git clone:

$ git clone https://github.com/TaskrowSharp/TaskrowSharp.git

Executando esse comando na pasta “C:\Temp” será cria uma pasta “C:\Temp\TaskrowSharp” e será baixado o conteúdo desse projeto.

iniciar um novo repositório na pasta

Para iniciar um repositório local, você deve executar o comando abaixo na pasta do projeto:

$ git init

Esse comando pode ser executado em uma pasta vazia, ou com arquivos. Por exemplo, você pode criar a pasta “C:\Temp\MyProject”, adicionar nessa pasta os arquivos do seu projeto, abrir um prompt de comando e executar “git init” e essa pasta com arquivos passará a ser um repositório git local.

Adicionar modificações no repositório local

lista a situação dos arquivos (arquivos alterados no repositório e se tem arquivos na área de trabalho para fazer commit)

$ git status

adiciona arquivos na área de trabalho para commit

$ git add teste.txt
$ git add --all

commit dos arquivos adicionados na área de trabalho

$ git commit -m "versionamento inicial"

enviar modificações do repositório local para o repositório externo

$ git push

Atualizar o último commit

$ git commit --amend -m "New commit message"

Ou para atualizar a mensagem e junto adicionar novos arquivos no commit:

$ git add . $ git commit –amend -m “New commit message”

Atualizar o repositório local

atualizar o repositório local com as mudanças do repositório externo

$ git pull

Branchs locais

Criar um branch

$ git checkout master
$ git pull
$ git checkout -b homolog

Isso irá criar um branch local chamado “homolog” a partir do branch master. Para criar a partir de outro branch, base executar o comando “checkout -b” no branch origem

criar uma branch a partir de um commit

Para criar um branch a partir de um commit utilize:

$ git branch 666 abababababa

Onde “666” é o nome do novo branch e “abababababa” é o commit

Para listar os branchs locais

$ git branch -v

Para listar os branchs locais e no servidor

$ git branch -ra

Para saber qual o branch atual, use:

$ git branch -v

Para ir para para outro branch:

$ git checkout [branch_name]
$ git checkout master
$ git checkout homolog

Para excluir (delete) um branch local:

$ git branch -d [branch_name]
$ git branch -d homolog

Branchs no servidor

Criar branch e adicionar no servidor

$ git checkout master
$ git pull
$ git checkout -b homolog
$ git push --set-upstream origin homolog

Isso irá criar um branch local chamado “homolog” a partir do branch master e irá enviar o branch para o servidor

Excluir (delete) um branch do servidor

$ git push origin --delete feature/001

Analisar mudanças

listar o histórico dos commits

$ git log
$ git log --stat
$ git log -p filename

comparar commits do histórico

$ git diff 34204d3ae29ead0abd611ccb7025d7d062176d97 71c17ff5236bdb17da8d808255907470663870c3

visualizar dados em commits anteriores

Para listar os commits anteriores, utilize:

$ git log

Para voltar arquivos para a versão desse commit, use:

$ git checkout 34204d3ae29ead0abd611ccb7025d7d062176d97

Será exibira a mensage: You are in ‘detached HEAD’ state

Se você utilizar:

$ git log

Será exibido *mostra commits somente até a versão atual

Para voltar para o master, use:

$ git checkout master

visualizar versão de uma data específica

$ git checkout 'master@{2018-12-31 00:00:00}'

listar os commits

$ git log --pretty=format:'"%h";"%aD";"%an";"%s"' > "c:\temp\commits.csv"

listar os commits na master sem incluir os merges

$ git log --first-parent --no-merges --pretty=oneline --abbrev-commit

Desfazer modificações

desfazer as alterações não comitadas de um arquivo

$ git checkout "file.txt"

desfazer alterações em todos os arquivos não comitados

$ git reset --hard origin/master

Depois, será necessário apagar os arquivos não rastreados (que foram adicionados agora):

O seguinte comando exibe os arquivos que serão apagados:

$ get clean -n

E o seguinte comando apaga os arquivos:

$ git clean -fd

O parâmetro “-f” apaga os arquivos O parâmetro “-d” apaga os diretórios

voltar commit

1- Volta um commmit:

$ git reset --hard HEAD~1

2- Volta para a posição da branch no servidor:

$ git reset --hard origin/branch1

3- Volta para um commit específico:

$ git reset --hard 179589dacf7

Para atualizar no servidor, será necessário permissão de push forçado

$ git push -f

apagar o último commit depois de push no servidor

Vamos imaginar que o último commit que você enviou para o servidor estava errado:

$ git add --all
$ git commit -m "wrong chang"
$ git push

Para apagar o último commit você precisa voltar um commit e depois fazer o push forçado:

$ git reset --mixed HEAD~1
$ git push -f

No seu repositório local ficará as últimas alterações realizadas, se você não quiser mais elas, pode apagar:

$ git status
$ git checkout .
$ git clean -fd

commit desfazendo

Se não tiver permissão para commit forçado é possível fazer um commit novo desfazendo as modificações

Para reverter o último commit:

$ git revert HEAD~1..HEAD

baixar todas as modificações e deixar os arquivos em stage

Para voltar somente o último commit e deixar os arquivos em stage:

$ git reset --soft HEAD~1

Desfazer todos os arquivos modificados na branch e deixar os arquivos em stage

Atualizar a branch original, por exemplo, a master:

$ git checkout master
$ git pull

Entrar na branch original da tarefa:

$ git checkout 666

Desfazer todos os arquivos modificados e deixar eles em stage:

$ git reset --soft origin/master

É possível copiar esses arquivos para uma nova branch usando “git stash”:

$ git stash -m "Modificacoes na branch 666"
$ git checkout master
$ git checkout -b feature/666b
$ git stash apply

Ignorar arquivos

Criar um arquivo “.gitignore”, com o seguinte conteúdo para ignorar arquivos com a a extensão .java:

*.java

Só funciona para arquivos que ainda não estiverem rastreados

Para remover os arquivos incluidos agora no gitignore, mas que já estavam rastreados:

Primeiro, limpe o cache do rastreamento:

$ git rm -r --cached .

Depois, adicione os arquivos modificados:

$ git add --all

Para verificar como ficou, utilize o comando:

$ git status

Note que somente os arquivos que não estão no rastreamento apareceram com o status “deleted”, eles vão continuar na pasta local

Agora, faça o commit da remoção dos arquivos que não devem mais ser versionados:

$ git commid -m "comentário"

Resolução de conflito de merge

Conflito no “git pull”

Quando você executar o comando “git pull” se existir algum conflito, será exibida a seguinte mensagem:

“please enter a commit message to explain why this merge is necessary,especially if it merges an updated upstream into a topic branch.”

Adicionando o comentário do merge usando o editor VI

Se você não alterou o editor padrão do mergetool, será aberta uma tela preta do editor “VI” para você adicionar o comentário do merge, para utilizar o “VI” faça o seguinte:

Unmerged files problem

Nessa situação:

$ git pull
error: Pulling is not possible because you have unmerged files.
hint: Fix them up in the work tree, and then use 'git add/rm <file>'
hint: as appropriate to mark resolution and make a commit.
fatal: Exiting because of an unresolved conflict.

Faça o seguinte:

Listar os arquivos com problema:

$ git status

Os arquivos com problema estarão marcados com “both modified”. Faça o ajuste dos arquivos no editor de texto.

$ git commit -m "Comentário"
$ git push
$ git pull

reference: https://stackoverflow.com/questions/26376832/why-does-git-say-pull-is-not-possible-because-you-have-unmerged-files

local changes would be overwritten by merge

$ git pull
error: Your local changes to the following files would be overwritten by merge: [file name]
Please commit your changes or stash them before you merge.
Aborting

Para ignorar as modificações do arquivo local e baixar a versão do servidor:

$ git checkout filename
$ git pull

Rebase

Para fazer o rebase da branch 666 com as modificações do branch master:

Atualizar a master:

$ git checkout master
$ git pull

Executar o rebase na branch:

$ git checkout 666
$ git rebase master

Se tiver conflito, resolver no visual studio e rodar:

$ git rebase --continue

Finalizar:

$ git pull
$ git push

Para renomear um arquivo

$ git mv old_name new_name

Para renomear um arquivo alterando somente o “case” (maiúsculas/minuúsculas do arquivo)

Ex: Para alterar de “TEST.txt” para “test.txt”, como o windows não é Casesensitive primeiro é necessário alterar o nome do arquivo para um temporário e depois alterar para o nome correto:

$ git config --global core.ignorecase false
$ git mv Test.txt Test_temp.txt --force
$ git mv Test_temp.txt test.txt --force

Comentários