Comandos do GIT

GIT - comandos.md

GIT - Comandos

Comandos básicos/inciais

# Baixa o repositório/projeto na sua maquina. O projeto será criado em uma pasta de mesmo nome que o repositório.
$ git clone [uri_do_repositorio]

# Para que o projeto seja criado em uma pasta com outro nome basta no fim do comando especificar o nome desejado:
$ git clone [uri_do_repositorio] [nome_da_pasta]

# Obtem as atualizações do repositório e branch remotos:
$ git pull [alias_do_repositorio] [branche_do_repositorio]

# Exemplo:
$ git pull origin master

# Verificar todas as alterações realizadas no repositório referente ao alias:
$ git fetch [alias_do_repositorio]

# Exemplo
$ git fetch origin

# Envia os commits locais para o repositório e branche remotos especificados
$ git push [alias_do_repositorio] [branche_do_repositorio]

# Exemplo:
$ git push origin develop
# Caso a branch develop não exista remotamente ela será criada

# É possível trackear a branch local com a remota que será criada utilizar o parâmetro -u:
$ git push -u origin teste
# (Após trackear a branch quando fizer push e pull não é mais necessário informar o repositório e branch, bastando fazer o git push, por exemplo)

# Adiciona um repositório remoto. 
$ git remote add [alias_do_repositorio] [uri_do_repositorio]
# (O alias do repositório remoto por convenção deve-se chamar "origin")
# (A URI é aquela que é oferecida para cada repositório no servidor remoto (Github, Bitbucket, ...))

# Quando utilizamos um git clone não é necessário adicionar um repositório remoto pois o clone já faz isso e já utilizando o alias "origin".

Histórico de Alterações

# Exibe o histórico dos últimos commits.
$ git log

# com o parametro -p exibe o histórico dos últimos commits exibindo o que foi alterado em cada arquivo:
$ git log -p

# para exibir um resumo dos commits usar o parametro --stat:
$ git log --stat

# também é possível definir a quantidade de informações que serão exbibidas no log com o atributo --pretty passando como parâmetro um das opções: oneline, short, medium, full, fuller, email, raw. Para exibir um commit por linha por exemplo:
$ git log --pretty=oneline

# para exibir um grafico do andamento das branchs e commits é possível utilizar o parâmetro --graph, inclusive pode ser usado em conjunto com outros se preferir:
$ git log --pretty=medium --graph

# Exibe o histórico dos últimos commits mostrando quais arquivos foram alterados.
$ git whatchanged

# É possível incluir o parâmetro -p no final do comando para mostrar também o que foi alterado em cada arquivo:
$ git whatchanged -p

# Exibe quem foi o autor de cada linha do arquivo especificado.
$ git blame [arquivo]
# (Para sair do blame pressione Q)

# Exibe todas as alterações feitas no commit
$ git show [hash_do_commit]

# Exemplo
$ git show b657bcf4f28a8a5c8eea56a3b6eb26e72cc39e39

Customizando o git log

É possível customizar o atributo pretty, por exemplo:

$ git log --pretty='%an realizou commit em %ad: %s'

Onde:

• %an -> nome do autor
• %ad -> data e hora do commit
• %s -> mensagem do commit

Para outras opções utilizar o git log --help

Branchs

# Exibe todas as branchs locais. A branch com um * na frente do nome faz referência a qual branch você se encontra.
$ git branch

# Para ver as branchs remotas inclua o paramêtro -r:
$ git branch -r

# Para ver todas as branches, tanto remoto quanto local usar o parâmetro -a:
$ git branch -a

# Cria uma branch local com o nome especificado.
$ git branch [nome_da_branch]

# Deleta a branch especificada. Pode-se passar também várias branches separadas por espaço.
$ git branch -d [nome_da_branch]

# Criar uma nova branch local trackeada (-t) com uma remota já existente:
$ git branch -t [nome_da_branch] [alias_do_repositorio]/[branche_do_repositorio]

# Exemplo:
$ git branch -t novo origem/novo

# Troca a branch para a especifícada.
$ git checkout [nome_da_branch]

# Se utilizar o parametro -b com o nome de uma branch ele cria a branch e já faz checkout pulando um passo:
$ git checkout -b [nome_da_branch]

# É possível criar uma branch local com o mesmo nome que uma remota e já fazer o checkout para ela com o parâmetro -t e outros detalhes:
$ git checkout -t [alias_do_repositorio]/[branche_do_repositorio]

# Exemplo:
$ git checkout -t origin/tarefa_123

# Deleta uma branch remota:
$ git push [alias_do_repositorio] :[branch_do_repositorio]

#Exemplo:
$ git push origin :minhabranch

Merges

# Jogar todos os comits da [branch_de_referencia] na frente dos seus commits
### você deve estar na branch que receberá os commits da [branche_de_referencia]
### importante a [branch_de_referencia] estar atualizada (git pull) para ter efeitos redundantes
$ git rebase [branch_de_referencia]

# Exemplo:
$ git rebase master

# Este comando joga commit por commit na sua branch, caso um destes commits de conflito (git status através da informação 'both modified' exibe quais arquivos deram conflito) após resolver o conflito (e adicionarmos com add) usar continue para dar continuidade no rebase:
$ git rebase --continue

## caso desista do rebase e queira voltar como sua branch estava antes use:
$ git rebase --abort

## caso queira descartar o SEU commit que está gerando o conflito usar:
$ git rebase --skip

# Funciona da mesma forma que o rebase tradicional com a diferença que pode ser feito de qualquer lugar não necessariamente da branch de destino.
$ git rebase [branch_de_referencia] [branch_destino]

## Exemplo
$ git rebase master minhabranch

# Faz um merge (trás os últimos commits) da branch_a_mergear para a branch atual
$ git merge [branch_a_mergear]
## normalmente este processo é feito com branches que sairam uma da outra, como mergear a branc X de volta na master pois a X está concluída mas foi criada baseada na master

# Exemplo
$ git merge minhabranch

Desfazer alterações

# Reverte as modificações de um arquivo que esteja em Working Directory
$ git checkout [nome_do_arquivo]

#Exemplo
$ git checkout MinhaClasse.java

## se por um acaso o arquivo possuir o mesmo nome que uma branch ao invés de reverter o arquivo este comando irá fazer um checkout para a branch, neste caso utilizar --:
$ git checkout -- arquivo

# Copiar um arquivo para que ele fique igual a como ele se encontra em outra branch [nome_branch]
$ git checkout [nome_branch] [nome_do_arquivo]

## Exemplo (deixa o arquivo Teste.java na minha branch igual a como está na master)
$ git checkout master Teste.java
## este comando copia o arquivo e já o deixa no Index pronto para ser commitado

# Remove um commit do Index (colocado após o add) retornando para Working Directory
$ git reset HEAD [nome_do_arquivo]

# Exemplo
$ git reset HEAD meuprojeto/src/com/testes/Classe.java

# Joga tudo o que está no Index e em Working Directory para o stash
$ git stash

# Lista todos os estados que estão no stash
$ git stash list

# Retorna para o código o último estado enviado ao stash e apaga este estado da lista do stash
$ git stash pop

## para retornar um estado especifico do stash e não o último é possível passar o nome do estado:
$ git stash pop stash@{3}

# Tem o mesmo efeito do pop para trazer o último estado ao código porém com a diferença que mantém no stash uma cópia
$ git stash apply

## Para apagar do stash então é necessário utilizar o git stash drop passando o nome do estado a ser removido:
$ git stash drop stash@{0}

## agora se a ideia é só apagar o último basta:
$ git stash drop

## para retornar um estado especifico do stash com o apply e não o último é possível passar o nome do estado:
$ git stash apply stash@{3}

## para 'zerar' o stash pode-se utilizar o comando:
$ git stash clear

# Retorna a base do projeto para o commit do hash informando e todos os commits após este são removidos (do Head) e jogados novamente no código como Working Directory
$ git reset [hash_do_commit]

# Exemplo
$ git reset 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2
# (para saber o hash do commit basta utilizar o git log)

# se desejar trazer diretamente para o index ao Invés de Working Directory utilizar o parâmetro --soft:
$ git reset --soft 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2

# se quiser simplesmente descartar os commits sem trazer o código do commit para o seu código atual usar --hard:
$ git reset --hard 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2

==============rever este comando pois não funcionou==============

# Remove as alterações feitas em um determinado commit abrindo um editor de texto para que possa definir a mensagem do commit de reversão.
$ git revert [hash_do_commit]
# (para saber o hash do commit basta utilizar o git log)

# Exemplo
$ git revert 658ed785d5e5c933d6ccead69b5d1801dd52e331
# (é possível utilizar o comando -n para que as alterações revertidas sejam adicionadas no Working Directory, assim podendo fazer outras alterações e commitar)

==============================================================

# Troca a mensagem do seu último commit. Após executar o comando será pedido a nova mensagem.
$ git commit --amend

Outros

# Exibe todas as tags do projeto.
$ git tag

# Faz com que o repositório vá para a versão da tag especificada.
$ git checkout [tag]

# Diferenciar duas vesões.
$ git diff [tag1] [tag2]
# (Para sair do diff pressione Q)

Apêndice

Estados do GIT

• Working Directory: arquivo foi alterado mas ainda não foi adicionado ou commitado
• Index: arquivo já foi adicionado mas não foi commitado
• Head: arquivo já foi commitado

Alias do GIT

• HEAD -> referencia o último commit
• HEAD~1 -> referencia o penúltimo commit
• HEAD~2 -> referencia o antipenúltimo commit
• HEAD~n -> e assim por diante

HEAD^ -> outra forma de referencia o penúltimo commit (igual a HEAD~1)