Aprendendo Git

Bismarck Gomes Souza Júnior
Março de 2014

bismarckjunior@outlook.com
Sistema de Controle de Versão
• Controle de histórico
• Trabalho em equipe
• Marcação e resgate de versões estáveis
• Ramificação do Projeto

SVN
Sistema de Controle de Versão Centralizado
• Pouca autonomia
Ações necessitam de acesso ao servidor.
• Trabalho privado limitado
Versiona apenas arquivos no repositório.
• Risco de perda de dados
Tudo em um único repositório.

Git
Sistema de Controle de Versão Distribuído
• Autonomia
Ações básicas “off-line”.
• Rapidez
Processos são locais.
• Trabalho privado
Trabalho local não afeta os demais.
• Confiabilidade
Todo repositório é um backup, ou seja,
uma cópia completa do repositório, in-
cluindo versões anteriores e histórico.

Sistema de Controle Convencional
Δ1
Δ1 Δ2
Δ1
Δ2
Versão 2 Versão 3 Versão 4
A
B
C
Versão 1

Sistema de Controle do Git
A
B
C
A1
Versão 2 Versão 3 Versão 4
B1 B2
C1
A2
C
A1
C1
B2
Versão 1

Snapshots
Versão 1 Versão 2 Versão 3 Versão 4
Cada versão é uma “foto” do diretório de trabalho e será
representado por um círculo azul denominado commit.

Início
commit

Início Função 1 Função 2
commit

Início Função 1 Função 2
Função 2*
commit branch

commit branch merge
Início Função 1 Função 2 Função 2+
Função 2*
Funções OK

Início
Servidor
PC
clone
Início

Início
Servidor
PC
Início Função 1 Função 2 Funções Ok
clone

Servidor
PC
push
clone

Início Função 1 Função 2 Funções Ok Classes Ok
Servidor
PC
push
clone

Servidor
Início Função 1 Função 2 Funções Ok Classes Ok
PC
Classes Ok
push pull
clone

Servidores Para Hospedagem

Criando um Repositório
$ git init
Transforma a diretório atual em um repositório
git, criando o subdiretório “.git”.
.git
$ git init <dir>
Cria o diretório <dir> e transforma em um
repositório git.
.git

Clonando um Repositório
$ git clone <repo>
Clona o repositório <repo> para a máquina local.
$ git clone <repo> <dir>
Clona o repositório <repo> para o diretório <dir>.
$ git clone git@github.com:user/Project.git
$ git clone https://github.com/user/Project.git

Tipos de Estado de um Arquivo
untracked
unmodified
modifiedstaged
selecionado
inalterado
modificado
não rastreado

.gitignore
Arquivo que contém os arquivos que não serão visíveis pelo git.
Arquivo .gitignore (exemplo)
Thumbs.db #Arquivo específico
*.html #Arquivos que terminam com “.html”
!index.html #Exceção, esse arquivo será visível ao git
log/ #Diretório específico
**/tmp #Qualquer diretório nomeado de “tmp”
• Arquivos que já estavam sendo rastreados não são afetados.

Preparando Para Salvar Alterações
$ git add <arquivo|dir>
Adiciona as mudanças do arquivo <arquivo> ou
do diretório <dir> para o próximo commit. O
arquivo passa a ser rastreado.add
$ git rm --cached <arquivo>
Para de rastrear o arquivo <arquivo>.
$ git reset <arquivo>
Remove as mudanças do arquivo <arquivo>
para o próximo commit.
Stage Area
(Index)

Salvando Alterações
$ git commit
Realiza o commit e abre o editor para inserir
uma mensagem.add
commit
$ git commit –m “<msg>”
Realiza o commit, com a mensagem <msg>.
$ git commit –a
Adiciona as mudanças dos arquivos já rastreados
e realiza o commit. O editor será aberto.

Salvando Alterações
$ git commit –am <msg>
Adiciona as mudanças dos arquivos já rastreados
e realiza o commit com a mensagem <msg>.add
commit
$ git commit --amend –m <msg>
Substitui o último commit e altera a mensagem
para <msg>.

Commmit

Commmit
commit date
tree
parent
author
committer
message
1e439..
b2a30..
bismarck
bismarck
93c42..

Commmit
commit date
tree
parent
author
committer
message
1e439..
b2a30..
bismarck
bismarck
commit date
tree
parent
author
committer
message
dae84..
1602a..
bismarck
bismarck
b2a30.. 93c42..

Analisando os Arquivos na Área Transitória
$ git status
Lista os arquivos que estão e que não estão na
área transitória, e os arquivos que não estão
sendo rastreados.
$ git status -s
Lista os arquivos de uma forma simplificada.

Tagging
$ git tag
Lista as tags existentes.
$ git tag –l <tag>
Procura pela tag <tag>.
$ git tag –l ‘v.0.*’

Tagging
$ git tag <tag> [<commit>]
Cria a tag <tag> para o último commit ou para o
commit <commit>.
$ git tag –a <tag>
Cria a tag <tag> completa para o último commit
e abre o editor para inserir uma mensagem.
$ git tag –a <tag> -m <msg>
Cria a tag <tag> completa para o último commit
com a mensagem <msg>.
v.0.1.0

Versionamento
v[major].[minor].[patch]
[patch]: correção de bugs.
[minor]: incrementos de funcionalidades compatíveis
com versões anteriores.
[major]: incrementos de funcionalidades incompatíveis
com versões anteriores.
Versões teste: alpha (a), beta (b)
v.0.1.0
Ex: v0.1.9 < v0.1.10 < v0.2.0a < v0.2.0b < v0.2.0

Referência a Commit
<sha1>
Hash SHA-1 referente ao commit. Pode-se usar os primeiros
caracteres.
Ex: b230 = b230e84a4c90d2f11ba85404e5fba93ce0a...
<tag>
Tag referente ao commit.
Ex: v0.1.2
<branch>
Último commit do branch <branch>.
Ex: master

<commit>~<n>
O n-ésimo percussor do commit <commit>.
v0.1.2a
v0.1.2a~1v0.1.2a~5

<commit>^1 ou <commit>^ ou <commit>~1
O primeiro percussor do commit <commit>.
v0.1.2a^v0.1.2a^^^^^
v0.1.2a

<commit>^2
O segundo percussor do commit <commit>. Utilizado em
commits resultantes de um merge.
v0.1.2a^^1
v0.1.2a^^2
v0.1.2a

Analisando Commits
$ git show
Exibe o último commit.
$ git show <commit>
Exibe o commit referenciado por <commit>.
$ git show <commit>:<arquivo>
Exibe o arquivo <arquivo> no commit <commit>.

Analisando um Arquivo
$ git blame <arquivo>
Exibe quem modificou cada linha do arquivo
<arquivo>, incluindo data e commit.
$ git blame -L <n>,<m> <arquivo>
Exibe quem modificou as linhas de <n> a <m> do
arquivo <arquivo>, incluindo data e commit.

Diferença Entre Commits
$ git diff <commit>
Exibe a diferença nos arquivos entre o commit
<commit> e o diretório de trabalho.
$ git diff --cached <commit>
Exibe a diferença nos arquivos entre o commit
<commit> e a área transitória.

Criando Ramificações
$ git branch [-a]
Exibe os branches existentes. Na forma completa,
exibe também os branches remotos.
$ git checkout –b <branch>
Cria o branch <branch> e altera para ele.
$ git branch <branch> [<base>]
Cria o branch <branch> a partir do commit <base>.

$ git add *
Adiciona os arquivos para o index (área transitória).

$ git commit
master
Realiza um commit.

$ git commit –a
master
Adiciona os arquivos para o index e realiza um commit.

$ git checkout -b ramo
ramo
master
Cria o branch ramo e altera para ele, ou seja, os próximos
commits serão no branch ramo.

$ git commit –a
ramo
master
Realiza um commit no branch ramo.

Alternando em Ramificações
$ git checkout <branch>
Altera para o branch <branch>.
$ git checkout -f <branch>
Altera para o branch <branch> “na força”, perdendo-se as
informações não “commitadas”.

master
HEAD
HEAD: aponta para o branch atual.

ramo
master
$ git branch ramo
HEAD
Cria o branch ramo.

ramo
master
$ git commit -a
HEAD
Realiza um commit no branch master.

ramo
master
HEAD
$ git checkout ramo
Alterna para o branch ramo.

ramo
master
HEAD
$ git commit -a

master
$ git commit -a
ramo
HEAD

Excluindo Ramificações
$ git branch -d <branch>
Exclui o branch <branch>. O branch já deve ter
sido mesclado.
$ git branch -D <branch>
Exclui o branch <branch> mesmo não tendo sido
mesclado.
ramo

Mesclando Commits
$ git merge <branch>
Mescla os commits do branch <branch> para o
branch atual.
$ git merge <branch> --no-ff
Mescla os commits do branch <branch> para o
branch atual sem fast-foward.

Mesclando Commits
master
ramo
HEAD

Mesclando Commits
master
ramo
$ git checkout master
HEAD
Alterna para o branch master.

Mesclando Commits
ramo
master
$ git merge ramo
HEAD
Realiza um merge no branch master a partir do branch
ramo.

Mesclando Commits com Fast-foward
master
ramo
HEAD

master
$ git checkout master
HEAD
ramo
Alterna para o branch master.

master
$ git merge ramo
HEAD
master
ramo
HEAD
Neste caso, não é necessário nenhum commit para realizar
a mesclagem. Ocorre apenas um avanço rápido (ff).

Mesclando Commits sem Fast-foward
master
HEAD
ramo

Mesclando Commits sem Fast-foward
master
$ git merge ramo --no-ff
HEAD
Realiza um merge com um commit obrigatoriamente.
Possibilita uma melhor visualização no histórico.
master
HEAD
ramo

Mesclando Commits
def fun(x):
print x
def fun(x):
print x
fun(3)
master
branch_1

Mesclando Commits
def fun(x):
print x
def fun(x):
print x
fun(3)
mastermaster
branch_1
def fun(x):
print x
fun(3)

Mesclando Commits
def fun(x):
print x+x
def fun(x):
print x
fun(3)
branch_2
branch_1

Mesclando Commits
def fun(x):
print x+x
def fun(x):
print x
fun(3)
branch_2branch_2
branch_1
def fun(x):
print x+x
fun(3)

Mesclando Commits
def fun(x):
print x+x
branch_2
branch_3
def fun(y):
print y+y

Mesclando Commits
def fun(x):
print x+x
branch_2branch_2
branch_3
<<<<<<< HEAD
def fun(x):
print x+x
=======
def fun(y):
print y+y
>>>>>>> branch_3
!
def fun(y):
print y+y

Resolvendo Conflitos
• Alterar o arquivo manualmente
• Utilizar uma interface gráfica
• kdiff3, tkdiff, meld, xxdiff, vimdiff, p4merge
Com o p4merge configurado*, basta fazer:
$ git mergetool
* Veja a seção Configurações

bismarckjunior@outlook.com$ git commit -a

Rebase
$ git rebase <base> [-i]
Replica os commits do branch <base> para o atual. Na forma
iterativa é possível escolher entre manter, omitir ou editar
um commit.

Rebase
$ git rebase <base> [-i]$ git rebase <base> [-i]
Replica os commits do branch <base> para o atual. Na forma
iterativa é possível escolher entre manter, omitir ou editar
um commit.

Rebase
Caso haja algum conflito:
$ git mergetool
$ git rebase --continue

Analisando o Log
$ git shortlog
Exibe a primeira linha dos commits que cada
autor enviou.
$ git shortlog -s
Exibe o número de commits que cada autor enviou.
$ git shortlog -n
Exibe, em ordem numérica, o número de commits
que cada autor enviou.

Analisando o Log
$ git log
Exibe o log de commits.
$ git log -<n>
Exibe os últimos <n> commits.
$ git log –-since==<date>
Exibe os commits desde a data <date>.
Ex: “3.weeks”, “yesterday”, “3.minutes”

Analisando o Log
$ git log --graph
Exibe o log em forma de gráfico.
$ git log --oneline
Exibe o log, um commit (abreviado) por linha.
$ git log –-all
Exibe o log de todas as tags, branches, ...

Analisando o Log
$ git log --decorate
Exibe o log destacando branch, tags, ...
$ gitk
Exibe o log em uma interface gráfica.
$ git log –-author=<autor>
Exibe os commits realizados pelo autor <autor>.

Analisando o Log
$ git log <arquivo>
Exibe o log de modificações do <arquivo>.
$ git log -- <arquivo>
Exibe o log de modificações do <arquivo>
mesmo se ele tiver sido excluído.
$ git log <intervalo_commits>
Exibe os commits no <intervalo_commits>.

Intervalo de Commits
<commit1>..<commit2>
Seleciona os commits que são alcançados pelo commit
<commit2>, mas não pelo commit <commit1>.
master
ramo

master
ramo
master..ramo

master
ramo
ramo..master

<commit1>...<commit2>
Seleciona os commits que são alcançados pelos commits
<commit1> ou <commit2>, mas não pelos dois ao mesmo
tempo.
master
ramo

<commit1>...<commit2>
Seleciona os commits que são alcançados pelos commits
<commit1> ou <commit2>, mas não pelos dois ao mesmo
tempo.
master
ramo
ramo...master
master...ramo

Recuperando Arquivos
$ git checkout [--] <arquivo>
Recupera o arquivo <arquivo> do último commit.
$ git checkout <commit> <arq>
Recupera o arquivo <arq> do commit <commit>.
$ git checkout <commit>
Recupera os arquivos do commit <commit>.

Revertendo Commits
$ git revert <commit>
Cria um novo commit no branch atual que desfaz o que foi
introduzido no commit <commit>.
• Consertar um bug introduzido por um commit.
• Não remove o commit <commit>

Revertendo Commits
def fun(x):
print x
def fun2(x):
print x+1
def fun3(x):
print x+x
def fun(x):
print x
def fun(x):
print x
def fun2(x):
print x+1
v.0.1 v.0.2 v.0.3

Revertendo Commits
v.0.1 v.0.2 v.0.3
$ git revert v.0.2
$ git mergetool
Conflitos aparecem!
!

Blame

Revertendo Commits
v.0.1 v.0.2
$ git commit –am “Fixed bug in fun2”
v.0.3

“Excluindo” Commits
$ git reset --soft <commit>
Altera apenas o HEAD para o commit <commit>. Não altera a
área transitória nem o diretório de trabalho.
branchbranch

Substitui os commits por um único commit. O diretório
de trabalho não é alterado.
branch
$ git reset --soft <commit>
$ git commit

$ git reset --hard <commit>
Altera a área transitória e o diretório de trabalho para o
commit <commit>.
branchbranch
O comando git reset é uma das poucas formas de se
perder informação utilizando o git, pois os commits
deixam de aparecer no git log.!

$ git reset [--mixed] <commit>
Altera apenas a área transitória para o commit <commit>.
Não altera o diretório de trabalho.
É necessário um git add para selecionar os arquivos do
diretório que irão para o próximo commit, caso contrário
irá o arquivo da área transitória.
branchbranch

branch

branch
$ git reset <commit>

Mantém os arquivos da área transitória, ou seja, do
commit <commit>.
$ git commit
branch

Mantém os arquivos <arquivos> do diretório.
branch
$ git add <arquivos>
$ git commit

Resumo da Operação Reset
Reset HEAD Index Diretório
--soft Alterado - -
--mixed Alterado Alterado* -
--hard Alterado Alterado Alterado
* É possível modificar o index utilizando “git add”.
branch

Recuperando Commits
$ git reflog
Exibe o histórico de hashes do repositório local.
$ git reflog
$ git merge <commit>
Adiciona o commit <commit> ao branch atual.

Limpando o Diretório
$ git clean [-f]
Exclui os arquivos que não estão sendo rastreados.
É possível forçar a exclusão.
$ git clean -n
Exibe os arquivos não rastreados que serão
excluídos.

Trabalhando com Repositórios Remotos
$ git remote -v
Lista os repositórios remotos e suas URLs. O repositório
clonado é nomeado de origin.
$ git remote add <nome> <url>
Usa <nome> ao invés da url <url> para se referir ao
repositório remoto.
$ git remote add pendrive “E:/GitRepo”

Atualizando o Repositório Local
$ git fetch [<repo>]
Baixa todos os dados do repositório <repo>.
$ git fetch [<repo>] [<branch>]
Baixa todos os dados do branch <branch> do
repositório <repo>.
$ git pull [<repo>]
Atualiza todos os dados do repositório <repo>, ou
seja, realiza um fetch seguido de um merge.

Usando fetch
Servidor
PC
master
develop
master

Usando fetch
Servidor
PC
origin/develop
master
develop
origin/master
master
$ git fetch #Baixa os dados do servidor
fetch

Usando pull
Servidor
PC
master
develop
master

Usando pull
Servidor
PC
origin/develop
master
develop
origin/master
master
$ git pull #Atualiza o repositório local
pull

Excluindo no Repositório Remoto
$ git push <repo> :<branch>
Exclui o branch <branch> do repositório <repo>.
$ git push <repo> :<tag>
Exclui a tag <tag> do repositório <repo>.

Enviando Para o Repositório
$ git push [<repo>] [<branch>]
Envia o branch <branch> para o repositório <repo>.
Por padrão <repo> é origin e <branch> é o branch
atual, mas pode ser configurado*.
* Veja a seção Configurações
$ git push [<repo>] --all
Envia o todos os branches para o repositório <repo>.

Enviando Para o Repositório
$ git push [<repo>] --tags
Envia todas as tags para o repositório <repo>.
$ git push <repo> <tag>
Envia a tag <tag> para o repositório <repo>.

Exemplo de Aplicação
Servidor
PC
pull
origin/master
master
master

Servidor
PC
origin/master
master
master
#Modifica o repositório remoto

Servidor
PC
origin/master
master
master
$ git commit –a #Altera o repositório local

Servidor
PC
master
$ git push #Tenta atualizar o servidor
master
origin/master
push
!
Repositório local
está desatualizado

Solução 1: fetch + rebase + push
Servidor
PC
master
master
origin/master

Servidor
PC
$ git fetch #Baixa os dados do servidor
master
origin/master
fetch
master

Servidor
PC
$ git rebase origin/master #Realiza o rebase
master
origin/master
master

Servidor
PC
$ git push #Envia para o servidor
push origin/master
master
master

Solução 2: pull + push
Servidor
PC
master
master
origin/master

Servidor
PC
master
master
origin/master
pull

Servidor
PC
master
$ git push #Envia para o servidor
master
origin/master
push

Conflitos de Referência
Caso exista um branch, uma tag e/ou um repositório remoto
com o mesmo nome <nome>, para evitar conflitos utilize a
tabela abaixo.
Tipo Referência
Branch refs/heads/<nome>
Tag refs/tags/<nome>
Repositório refs/remotes/<nome>
$ git push origin refs/tags/issue13

Configuração Inicial do Git
$ git config –-global user.name <nome>
Atribui <nome> ao nome do usuário.
$ git config –-global user.email <email>
Atribui <email> ao e-mail do usuário.
$ git config –-global core.editor <editor>
Atribui <editor> como editor padrão. Ex.: notepad, emacs ...

Configurando o p4merge
$ git config --global merge.tool p4merge
Atribui p4merge como ferramenta de mesclagem.
$ git config --global mergetool.p4merge.cmd
“p4merge.exe $BASE $LOCAL $REMOTE $MERGED”
Atribui o caminho e a forma de como executar o programa.
• Analogamente para diff e difftool.

Configuração do Push
$ git config --global push.default simple
Basicamente, envia apenas o branch atual, quando o branch
não é especificado.
$ git config --global push.default nothing
Não envia nada, quando o branch não é especificado.
Outra opções: current, upstream, matching

Configuração do Merge
$ git config --global merge.ff false
Desativa o fast-foward, ou seja, cria sempre cria um commit na
mesclagem.
*Cuidado: Quando o fast-foward está desativado, o comando
push (fetch +merge) também irá sempre criar um commit ao
atualizar um repositório.

Desconfigurando
$ git config --global --unset <key>
Desativa a chave <key>.
$ git config --global --unset merge.ff
$ git config --global --unset core.editor

Alias
$ git config --global alias.<abr> <cmd>
Substitui o comando <cmd> por <abr>.
$ git config --global alias.lol "log --graph
--decorate --oneline"
$ git lol --all

Fim de Linhas em Arquivos
$ git config --global core.autocrlf true
$ git config --global core.autocrlf input
Converte CRLF para LF durante um checkout. Configuração para
Linux e Mac.
Converte CRLF para LF e de LF para CRLF automaticamente.
Configuração para Windows.
Windows: CRLF (carriage-return and linefeed)
Linux: LF (linefeed)

Fluxo de Trabalho
master

Fluxo de Trabalho
develop
master

Fluxo de Trabalho
develop
feature
master

Fluxo de Trabalho
hotfix
develop
feature
master

Fluxo de Trabalho
hotfix
develop
feature
master
v.0.0.1

Fluxo de Trabalho
hotfix
realese
develop
feature
master
v.0.0.1
v.0.1.0a

Fluxo de Trabalho
hotfix
realese
develop
feature
master
v.0.0.1 v.0.1.0
v.0.1.0a

Fluxo de Trabalho
hotfix
realese
develop
feature
master Versões estáveis.
Correção de bugs da versão estável.
Teste e correções de versões.
Desenvolvimento.
Implementação de funcionalidades.

Referências
• Pro Git (2009), Scott Chacon
• Git Tutorials, Atlassian.com
• Git Tutorial, Lars Vogel, vogella.com
• A successful Git branch model, nvie.com

Cursos
• http://try.github.io/
• http://gitreal.codeschool.com/
Dúvidas e Sugestões

Aprendendo Git

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Aprendendo Git (20)

Último (20)

Aprendendo Git