Hélio Rodrigues

Git para
iniciantes

Guia completo
para começar a
usar o controle
de versão de
forma eficiente
 ÍNDICE
Conceitos
O que é controle de versão?
Por que utilizar um sistema de controle de versão?
Sistema de controle de versão centralizado x distribuído
O que é Git?
Git vs. GitHub
Primeiros passos com Git
Instalando o Git
Instalando o Git no Ubuntu
Instalando o Git no windows
Criando um repositório Git
Estrutura de um comando Git
Comandos Essenciais do Git
Adicionando arquivos e realizando commits
Entendendo o Git
Git workflow
Criando branches e realizando merges (Branching e Merging)
Como criar uma branch
Como efetuar merge da sua branch
Resolvendo conflitos
Desfazendo alterações
Desfazendo alterações utilizando hash de commits
Melhores práticas de Git
Trabalhando com GitHub
Quais os primeiros passos para utilizar o GitHub
Criar uma conta no GitHub
Criando um repositório remoto
Clonar um repositório remoto
Estou com o repositório em meu computador. E agora?
Técnicas Avançadas de Git
Os próximos passos para aperfeiçoar seu versionamento
Git rebase
cherry-picking
Git Hooks
Git aliases
Exercícios
Conclusão

1
 I

C O N C E I T O S

I 2
O que é
controle de versão?
Controle de versão é um sistema que
ajuda a gerenciar as mudanças em um
conjunto de arquivos ao longo do
tempo. Ele permite que várias pessoas
trabalhem nos mesmos arquivos
simultaneamente, sem se preocupar
em bloquear ou sobrescrever o trabalho
um do outro.

Os sistemas de controle de versão

acompanham todas as mudanças
feitas em um arquivo ou conjunto de
arquivos. Cada mudança é
armazenada como uma versão
separada e os usuários podem
visualizar, comparar e reverter para
qualquer versão anterior. Isso permite
que os desenvolvedores colaborem em
projetos com mais eficiência e reduz o
risco de perder trabalho.

3
O controle de versão é uma ferramenta
essencial para o desenvolvimento de
software, mas também pode ser usado
para outros tipos de arquivos, como
documentos e gráficos. É
particularmente útil para equipes que
trabalham em projetos grandes ou
para indivíduos que desejam
acompanhar o trabalho ao longo do
tempo.

Por que utilizar um sistema de

controle de versão?
O sistema de controle de versão de
arquivos traz diversos benefícios para
desenvolvedores, equipes de projetos e
até mesmo para indivíduos que
trabalham em seus próprios projetos.
Aqui estão algumas das principais
razões para usar o controle de versão:

4
Rastreamento de alterações: O
versionamento permite que você
acompanhe as mudanças feitas em um
arquivo ao longo do tempo e possa
recuperar versões anteriores, caso seja
necessário.

Colaboração em equipe: Permite que

várias pessoas trabalhem em um
mesmo conjunto de arquivos,
facilitando a colaboração e a
integração das alterações feitas por
cada membro da equipe.

Gerenciamento de conflitos: Quando

várias pessoas estão trabalhando em
um mesmo conjunto de arquivos, é
comum que ocorram conflitos nas
alterações feitas. O versionamento
ajuda a gerenciar esses conflitos e a
garantir que as mudanças sejam
integradas corretamente.

5
Backup e recuperação:
O versionamento também serve como
uma forma de backup de arquivos. Se
algo der errado com o arquivo atual,
você pode facilmente recuperar uma
versão anterior e retomar o trabalho a
partir daí.

Experimentação e desenvolvimento:
O versionamento permite que você crie
e experimente novos recursos e
funcionalidades, sem afetar o código
principal. Isso serve para testar novas
ideias e recursos sem arriscar a
estabilidade do projeto principal.

Sistema de controle de versão

centralizado x distribuído
Antes de partirmos para o git de fato,
vale a pena passarmos por mais um
quesito teórico importante. A diferença
entre um sistema de controle de versão
distribuído e um sistema de controle de
versão centralizado
6
A principal diferença entre um sistema
de controle de versão distribuído e um
sistema de controle de versão
centralizado é a maneira como eles
gerenciam e armazenam o código-
fonte. Entenderemos melhor o que isso
significa.

Em um sistema de controle de versão

centralizado, o código-fonte é
armazenado em um único servidor
centralizado. Cada desenvolvedor faz
check-in e check-out do código desse
servidor centralizado. Isso significa que,
se o servidor centralizado estiver fora
do ar ou indisponível, os
desenvolvedores não poderão acessar o
código ou trabalhar em seus projetos.

Já em um sistema de controle de versão

distribuído, cada desenvolvedor tem
uma cópia completa do repositório de
código em sua máquina local.

7
Isso significa que os desenvolvedores
podem trabalhar offline e, quando
estiverem prontos para enviar suas
alterações, podem sincronizá-las com o
repositório central ou enviar para outro
desenvolvedor. Isso torna a
colaboração mais flexível e
descentralizada, pois não há
dependência de um servidor
centralizado.

Além disso, em um sistema distribuído,

os desenvolvedores podem criar
ramificações de código para
experimentar novas ideias ou recursos
sem afetar o código principal. As
ramificações podem ser mescladas e
gerenciadas facilmente, tornando o
processo de colaboração mais flexível e
ágil. Em um sistema centralizado, essa
flexibilidade é mais limitada, uma vez
que todas as alterações devem ser
realizadas no servidor central.

8
Em resumo, a principal diferença entre
um sistema de controle de versão
distribuído e um sistema de controle de
versão centralizado é que o primeiro
permite uma colaboração mais flexível
e descentralizada, enquanto o segundo
é mais rígido e depende de um servidor
centralizado para funcionar.

O que é Git?
Git é um sistema de controle de versão
distribuído de código aberto criado por
Linus Torvalds em 2005. Ele é
amplamente utilizado em projetos de
software para gerenciar o código-fonte
e colaboração entre desenvolvedores.

Git permite que várias pessoas

trabalhem em um mesmo conjunto de
arquivos, mantendo um registro
completo das alterações feitas em
cada arquivo ao longo do tempo.

9
Isso torna o controle de versão mais
rápido, mais confiável e mais eficiente
em relação a outros sistemas de
controle de versão centralizados.
Além disso, Git oferece recursos como
ramificação, mesclagem e tags, que
tornam a colaboração em equipe mais
fácil e flexível. Como Git é um sistema
de controle de versão distribuído
(explicado no tópico anterior), cada
desenvolvedor tem uma cópia
completa do repositório de código em
sua máquina local, tornando o processo
de colaboração e compartilhamento de
código mais fácil e seguro.

Git vs. GitHub

Pelo nome similar e por serem
ferramentas que andam juntas, Git e
GitHub são facilmente confundidos, ou
até mesmo, por vezes, podemos pensar
que são uma única ferramenta.
10
Porém, Git e GitHub são duas coisas
diferentes. Aqui está a diferença entre
eles:

Git é um sistema de controle de versão

distribuído que permite que os
desenvolvedores gerenciem o código-
fonte de seus projetos de software.

GitHub é uma plataforma de

hospedagem de código-fonte baseada
na web que utiliza o Git para gerenciar
os repositórios de código-fonte.

Em outras palavras, o Git é a

ferramenta de controle de versão em si,
enquanto o GitHub é uma plataforma
de hospedagem para projetos que
utilizam o Git. O GitHub oferece muitos
recursos adicionais além do controle de
versão, como rastreamento de
problemas, colaboração em equipe,
integração contínua, entre outros.

11
Os desenvolvedores podem usar o Git
sem o GitHub, mas o GitHub torna o
processo de colaboração em equipe e
compartilhamento de código mais fácil
e eficiente. O GitHub permite que os
desenvolvedores armazenem seus
repositórios de código em nuvem,
podendo, assim, ser acessados por
outros desenvolvedores em qualquer
lugar do mundo. Ele também facilita a
colaboração em equipe, permitindo que
várias pessoas trabalhem no mesmo
repositório de código-fonte, rastreiem
problemas e mesclagem de
ramificações de código.

Em resumo, Git é uma ferramenta de

controle de versão e GitHub é uma
plataforma de hospedagem de código-
fonte que utiliza o Git para gerenciar os
repositórios de código.

12
 II

P R I M E I R O S
P A S S O S C O M
G I T

II 13
Instalando o Git
Os passos para instalar o Git dependem
do Sistema Operacional utilizado. Neste
capítulo mostrarei como instalar nos
Sistemas Operacionais Ubuntu e
Windows. Caso você utilize outro, além
desses, fique a vontade para conferir as
instruções na documentação do git.
Você pode encontrar estas referências
no seguinte link: https://git-
scm.com/downloads

Instalando o Git no Ubuntu

Para instalar o Git no Ubuntu, você
pode seguir as seguintes etapas:
1.: Abra um terminal
2.: Execute o seguinte comando para
atualizar o índice de pacotes do
Ubuntu:

sudo apt-get update

14
3.: Em seguida, execute o comando
abaixo para instalar o Git:

sudo apt-get install git

4.: aguarde enquanto o Git é instalado.

Uma vez concluído, você pode verificar
a versão do Git com o seguinte
comando:

git --version

Se você já tiver o Git instalado e quiser

atualizá-lo para a versão mais recente,
execute os seguintes comandos:

sudo apt-get update

sudo apt-get upgrade git

15
Instalando o Git no windows
Acesse a página de download no site
oficial do Git:

https://git-scm.com/download/win

Faça o download e, após a conclusão,

execute o arquivo de instalação do Git
e siga as instruções do assistente de
instalação.

16
Criando um repositório Git

O primeiro passo para criar um

repositório no git é criar uma pasta em
que usaremos o versionamento. Para fins
de estudos criaremos uma pasta, em um
local qualquer, chamada
'primeiro_repo_git'.

Agora você deve, através do terminal ou

prompt de comando, navegar até a
pasta onde estamos trabalhando
utilizando o comando cd.

Exemplo: Estou utilizando um sistema

baseado em Linux, então digitei o
seguinte comando para navegar até
minha pasta:

cd ~/dev/git/primeiro_repo_git/

Você deve alterar o caminho para ficar

conforme o local do seu projeto.

17
Feito isso, devemos informar o git que a
partir de agora ele deve gerenciar este
diretório. Para isso devemos utilizar o
seguinte comando:

git init

Em outras palavras, ao rodar o

comando git init, acabamos de
transformar uma pasta normal em um
repositório Git.

Estrutura de um comando Git

Se você já teve algum contato com git,
ou leu algum comando em algum lugar,
deve ter percebido que a maioria dos
comandos inicia com a palavra git. Isso
ocorre porque o Git tem uma estrutura
composta por:

git [comando] [opções] [argumento]

18
Entenderemos o que cada trecho dessa
estrutura representa:

git: Este é o nome do comando Git.

<comando>: este é o nome do comando

específico que você deseja executar,
como init, clone, add, commit, status,
log, branch, checkout, merge, pull,
push, etc.

<opções>: as opções começam com um

hífen (-) e modificam o comportamento
do comando. As opções geralmente são
opcionais e podem ser usadas em
combinação com outros argumentos.
Por exemplo, o comando git add -p
adiciona arquivos ao índice Git
interativamente, permitindo que você
revise as alterações antes de confirmar
a adição.

19
<argumentos>: São informações
adicionais fornecidas ao comando.
Os argumentos geralmente são
opcionais e podem ser posicionais ou
nomeados.
Por exemplo, o comando git clone
git://github.com/user/repo.git clona um
repositório remoto em sua máquina
local.

Comandos Essenciais do Git

Aqui estão alguns comandos do Git que
podem ser úteis no seu dia a dia. Nesta
seção irei apenas listar e falar
brevemente sobre cada um deles. No
decorrer do livro entenderemos melhor
cada um:

git init: Inicializa um novo repositório Git

vazio na pasta atual.

git clone: Cria uma cópia local de um

repositório remoto existente.
20
git add: Adiciona arquivos ao índice Git
para serem rastreados. Você pode usar
'git add .' para adicionar todos os
arquivos na pasta atual.

git commit: Cria um commit com as

alterações. Você deve incluir uma
mensagem de commit significativa que
descreva as alterações feitas.

git status: Exibe o status atual do

repositório Git, incluindo arquivos
modificados, adicionados ou excluídos.

git log: Exibe o histórico de commits do

repositório Git.

git branch: Exibe uma lista de branches

locais e permite criar branches.

git checkout: Permite mudar de branch

ou realizar checkout de um commit
específico.

21
git merge: Mescla as alterações de um
branch em outro.

git pull: “Puxa” (download) as

alterações mais recentes de um
repositório remoto.

git push: “Empurra” (upload) as

alterações locais para um repositório
remoto.

Adicionando arquivos e
realizando commits

Entre os primeiros comandos que

alguém configurando, ou utilizando, um
projeto novo no git vai se deparar
podemos afirmar que git add e git
commit acabam sendo os mais
importantes. Pois seguirão sendo
utilizados no seu dia a dia durante
muito tempo (para sempre).

22
Como vimos anteriormente, utilizamos
git add para adicionar arquivos ao
índice do git para serem rastreador. Já
o git commit cria um commit com as
alterações. Aqui está um guia passo a
passo para adicionar arquivos e
“comittar” as alterações no Git:

Antes de tudo, certifique-se de estar no

diretório do projeto que deseja
controlar com o Git.

Use o comando git status para verificar

o status atual do seu repositório Git.

Use o comando git add para adicionar

os arquivos que você deseja rastrear.
Por exemplo, para adicionar todos os
arquivos no diretório atual, você pode
executar o comando 'git add .', se quiser
adicionar apenas um arquivo você pode
especificar com o comando 'git add
./arquivo_para_adicionar.ext'.

23
Use o comando git commit para
confirmar as alterações e criar um
commit. Por exemplo, para criar um
commit com uma mensagem, você
pode executar o comando:

git commit -m "Adicionando arquivos

ao repositório".

Após confirmar o commit, as alterações

serão salvas no histórico do repositório
Git.

24
 III

E N T E N D E N D O
O G I T

III 25
Git workflow
O fluxo de trabalho (workflow) do git
pode variar de equipe para equipe e de
projeto para projeto, mas aqui está
uma descrição geral do fluxo de
trabalho básico do Git:

Clone o repositório: Comece clonando

um repositório Git existente utilizando o
comando git clone. Isso criará uma
cópia local do projeto em sua máquina.
Se você já clonou o repositório não há
necessidade de realizar esse processo
novamente, apenas mantê-lo
atualizado.

Crie uma branch: Antes de começar a

fazer alterações no código, é uma boa
prática criar uma branch. Isso isola seu
trabalho de outras alterações que
possam estar sendo realizadas no
projeto.

26
 10

Faça alterações: Agora você pode fazer

alterações no código em sua branch.
Adicione novos arquivos, faça
alterações em arquivos existentes e
exclua arquivos que não são mais
necessários de acordo com sua
demanda de trabalho.

Teste as alterações: Após fazer as

alterações, teste o código para garantir
que tudo esteja funcionando
corretamente. Isso é especialmente
importante se você estiver trabalhando
em equipe, para garantir que as
alterações não interfiram no trabalho
de outros membros da equipe.

Confirme as alterações: Quando estiver

satisfeito com as alterações, use o
comando git add para preparar as
alterações para o commit. Em seguida,
use o comando git commit para criar
um commit.

27
Envie as alterações: Agora que você
tem um novo commit com suas
alterações, você pode enviar as
alterações para o repositório central
usando o comando git push.

Solicite uma revisão: Se você estiver

trabalhando em equipe, é uma boa
prática solicitar uma revisão de código
antes de mesclar as alterações em uma
branch principal ou de produção.

Faça merge: Depois que as alterações

forem revisadas e aprovadas, use o
comando git merge para mesclar a
branch com as alterações na branch
principal ou de produção.

Limpe: Depois que as alterações forem

mescladas, você pode excluir a branch
que criou. Isso ajuda a manter o
histórico do projeto limpo e organizado.

28
Este é um fluxo de trabalho básico do
Git, mas pode haver variações
dependendo do projeto e das equipes
envolvidas. Além disso, o Git oferece
recursos adicionais, como pull requests
e branching models mais complexos,
que podem ser úteis para projetos
maiores e equipes mais complexas.

Alguns comandos citados serão

abordados no decorrer do livro, como
git merge e git push. Também veremos
como criar uma branch.

Criando branches e realizando

merges (Branching e Merging)
Branching e merging são duas
funcionalidades fundamentais no
sistema de controle de versão Git.

29
O Git permite que os desenvolvedores
criem branches (ramificações) para
trabalhar em diferentes recursos ou
funcionalidades de um projeto
isoladamente, ou seja, sem interferir no
trabalho dos demais desenvolvedores
ou na versão principal do projeto.

Quando um desenvolvedor cria uma

branch, ele pode trabalhar nela sem
alterar o código na versão principal do
projeto. Após finalizar o trabalho, o
desenvolvedor deve realizar um merge
(mesclar) com a versão principal do
projeto para incorporar as alterações
que ele fez.

O Git oferece várias estratégias de

merge, como o merge tradicional,
rebase e squash, que ajudam a manter
o histórico de alterações e minimizar
conflitos entre as branches.

30
O uso correto de branching e merging
no Git pode ajudar a gerenciar
efetivamente projetos de software com
várias equipes trabalhando
simultaneamente, garantindo que as
alterações sejam integradas de
maneira suave e consistente.

Como criar uma branch

O primeiro passo para criar uma
branch, onde você irá desenvolver suas
alterações, é se certificar de que está
criando ela a partir da branch principal.
Consideramos que estamos querendo
criar uma branch a partir da Master
para o próximo exemplo.

Para criar uma branch a partir da

branch master no Git, siga os seguintes
passos:

31
Certifique-se de estar na branch
principal usando o comando

git checkout master

Certifique-se de que você possui a

versão mais recente da branch master
utilizando o comando:

git pull

Este comando irá "puxar" para o

ambiente local todas as alterações
adicionadas a master e que não estão
em sua branch local.

Execute o seguinte comando para criar

a branch:

git branch <nome-da-nova-branch>

Para criar uma branch chamada

"adicionar-campo", execute git branch
adicionar-campo
32
Agora que você criou a nova branch,
use o seguinte comando para mudar
para a nova branch.

git checkout <nome-da-nova-branch>

Utilizando o nosso exemplo:

git branch adicionar-campo

Agora você pode trabalhar na nova

branch, fazer alterações e commits,
sem afetar a versão principal do
projeto. Quando você estiver pronto
para incorporar as alterações à versão
principal do projeto, faça um merge da
nova branch com a branch master
usando o comando git merge.

Como efetuar merge da sua

branch de desenvolvimento
com a branch Master

33
Para fazer um merge da sua branch
para a branch master no Git, siga os
seguintes passos:

Certifique-se de estar na branch

principal usando o comando

git checkout master

Execute o comando

git merge adicionar-campo

O nome da branch varia conforme o

nome definido ao criá-la. Ou seja, a
estrutura do comando é git merge
<nome-branch-desenvolvimento>

Isso fará com que as alterações

inseridas na sua branch sejam inseridas
na branch master.

34
O Git tentará fazer o merge
automaticamente, mas em alguns
casos pode ocorrer um conflito. Nesses
casos, o Git mostrará uma mensagem
de erro e você deverá resolver o conflito
manualmente antes de continuar o
merge.
Se o merge for bem-sucedido, os
commits da sua branch serão
adicionados à branch principal.

Resolvendo conflitos
Quando você faz um merge ou um
rebase no Git, podem ocorrer conflitos
entre as alterações realizadas em
diferentes branches. O Git não
consegue decidir automaticamente
qual é a versão correta a ser usada,
portanto, é necessário resolver os
conflitos manualmente. Para resolver
conflitos no Git, siga os seguintes
passos:

35
Abra o arquivo em questão — marcado
como arquivo em conflito pelo git — em
um editor de texto e procure as
marcações de conflito que o Git inseriu
no código. Essas marcações indicam as
alterações conflitantes e devem ser
resolvidas manualmente.
Edite o arquivo para resolver os
conflitos. Escolha a versão correta ou
faça as alterações necessárias para
mesclar as duas versões.
Após fazer as alterações, salve o
arquivo. Adicione o arquivo modificado
ao índice de versionamento do Git
usando o comando git add <arquivo-
modificado>

Quando os conflitos forem resolvidos,

execute o comando git merge --
continue ou git rebase --continue para
continuar o processo de merge ou
rebase.

36
É importante lembrar que, ao resolver
conflitos, você deve sempre escolher a
versão correta e fazer merge das
alterações cuidadosamente para
garantir que não haja perda de dados
ou quebras no código.
Além disso, é uma boa prática manter
as branches atualizadas e realizar o
merge das alterações com frequência
para minimizar a possibilidade de
conflitos.

Desfazendo alterações
Git oferece várias maneiras de desfazer
alterações em um repositório. Aqui
estão algumas:

Desfazendo alterações em um arquivo

não commitado
Se você modificou um arquivo, mas
ainda não o adicionou à stage area
(índice de versionamento), pode
desfazer as alterações usando o
comando
37
git checkout -- <nome-do-arquivo>

Esse comando substitui as alterações

no arquivo pelo último commit efetuado
no repositório.

Desfazendo alterações em um arquivo

já adicionado à stage area

Se você já adicionou um arquivo à stage

area, mas ainda não fez o commit, pode
desfazer as alterações usando o
comando

git reset HEAD <nome-do-arquivo>

para remover o arquivo da stage area e,

em seguida, usar o comando

git checkout -- <nome-do-arquivo>

Para substituir as alterações no arquivo

pelo último commit.

38
Desfazendo o último commit:

Se você acabou de fazer um commit,

mas percebeu que cometeu um erro,
pode desfazer o último commit usando
o comando:

git reset HEAD~

Isso desfaz o último commit e retorna

as alterações para a stage area,
permitindo que você faça as alterações
necessárias e faça um novo commit.

Desfazendo alterações
utilizando hash de commits
Para os próximos comandos
precisaremos do hash do commit que
desejamos reverter ou desfazer.
Para obter o hash do commit você pode
usar o comando git log. O hash é uma
sequência alfanumérica única que
identifica o commit.
39
Execute o comando git log. Isso
mostrará uma lista de todos os
commits no seu repositório.
Encontre o commit do qual você deseja
obter o hash e copie a sequência
alfanumérica ao lado de "commit". Algo
como:
"d23f80b4e4c233e6c8f1d3e1a914c9b69".

Agora que sabemos o que é o hash de

um commit, e como encontrar,
podemos seguir:

Desfazendo commits antigos:

Se você precisa desfazer um commit

antigo, pode usar o comando:

git revert <hash-do-commit>

Este comando irá criar um commit que

desfaz as alterações introduzidas pelo
commit especificado.

40
Revertendo para um commit anterior

Se você precisa reverter para um

commit anterior e desfazer todas as
alterações feitas após aquele commit,
pode usar o comando:

git reset --hard <hash-do-commit>

Isso descarta todos os commits feitos

após o commit especificado, portanto,
tenha cuidado ao usá-lo.
É importante lembrar que algumas
dessas ações podem alterar
permanentemente o histórico de
commits do repositório. Por isso, é
sempre importante tomar cuidado ao
desfazer alterações no Git e ter certeza
de que você está desfazendo as
alterações corretas.

41
Melhores práticas de Git
Commits pequenos e frequentes:
Isto ajuda a manter um histórico de
mudanças limpo e organizado,
permitindo que você reverta facilmente
a alteração se houver um problema.

Escreva mensagens de commit

significativas:
Escrever mensagens de commit
significativas ajuda a entender o que foi
alterado e por quê. Use um estilo de
escrita claro e conciso e inclua detalhes
relevantes.

Use branches:
Use branches para manter o código
organizado e trabalhar em diferentes
recursos e correções de bugs sem
afetar o código principal. Certifique-se
de nomear suas branches de forma
clara e significativa.

42
Faça pull regularmente:
Certifique-se de fazer pull regularmente
para manter seu repositório local
atualizado com o repositório remoto.
Isso evita conflitos desnecessários e
problemas de merge no futuro.

Faça push regularmente:

Faça push regularmente para o
repositório remoto para garantir que
suas alterações sejam salvas em um
local seguro. Isso também ajuda a
evitar conflitos com outros
desenvolvedores que estão trabalhando
no mesmo projeto.

Use o .gitignore:
O arquivo .gitignore é usado para
ignorar arquivos desnecessários que
não devem ser incluídos no repositório.
Como arquivos gerados pelo build, por
exemplo. Criar o .gitignore ajuda a
evitar problemas com arquivos
desnecessários no repositório.
43
Revisão de código:
A revisão de código é uma prática
importante para garantir a qualidade
do código e evitar problemas de
segurança. Certifique-se de envolver
outros colaboradores em revisões de
código e usar ferramentas para
simplificar o processo.

Mantenha um histórico limpo:

Mantenha um histórico limpo e
organizado, removendo branches
antigas e commits desnecessários. Isso
ajuda a manter o repositório
organizado e fácil de entender.

44
 IV

Trabalhando com GitHub

IV 45
Quais os primeiros passos para
utilizar o GitHub
Criar e utilizar um repositório remoto no
GitHub pode soar como algo complexo
para quem nunca realizou essa tarefa,
mas para iniciar basta que realizemos
3 passos.

Criar uma conta no GitHub (caso não

possua)

Criar um repositório

Clonar o repositório

Após realizar estes 3 passos você pode

começar a desenvolver localmente.

Descobriremos como fazer cada uma

dessas tarefas nos tópicos a seguir:

46
Criar uma conta no GitHub
No início deste livro entendemos a
diferença entre Git e GitHub e também
entendemos qual a função do GitHub
em relação ao git. Agora criaremos
nossa conta para podermos trabalhar
com as duas ferramentas.

1. Acesse https://github.com/.
2. Clique em "Sign up" no canto
superior direito da página.
3. Preencha as informações
solicitadas na página de registro,
incluindo nome de usuário, endereço
de e-mail e senha.
4. Clique em "Create account" para
concluir o processo de registro.
5. Após criar sua conta, você pode
personalizar seu perfil, criar
repositórios para seus projetos e
colaborar com outros usuários do
Github.

47
Criando um repositório remoto
Para criar um repositório remoto no
Github, siga os passos abaixo:

1. Acesse https://github.com/.
2. Faça login na sua conta.
3. No canto superior direito da página,
clique no botão "+", e em seguida
em "New repository".
4. Insira o nome do repositório na
caixa de texto "Repository name".
5. Se achar necessário, adicione uma
descrição ao repositório na caixa de
texto "Description".
6. Escolha se o repositório será público
ou privado, marcando a opção
correspondente.
7. Selecione se deseja criar um
repositório com um arquivo
README.md, com um arquivo de
.gitignore ou com uma licença.
8. Clique em "Create repository" para
criar o repositório.
48
Clonar um repositório remoto
Para clonar um repositório do GitHub
para o seu computador, siga os passos
abaixo:

1. Navegue até o repositório que

deseja clonar.
2. Clique no botão "Code" (ou "Clone"
em alguns casos) na página do
repositório.
3. Copie o link que aparece na caixa
de texto.
4. Abra o terminal no seu computador
e navegue até o diretório onde
deseja clonar o repositório.
5. Use o comando git clone seguido do
link que você copiou, como no
exemplo:
a. git clone <github_repo_url>
6. Pronto! Agora você tem uma cópia
do repositório do GitHub no seu
computador e pode começar a
trabalhar nele localmente.
49
Vale lembrar que ao rodar o comando
git clone, o repositório será clonado no
diretório onde você está em seu
terminal, por isso, antes de clonar
certifique-se de que está no local
desejado.

Estou com o repositório em

meu computador. E agora?

A partir de agora você pode, e deve,

começar a trabalhar em suas
alterações. De preferência, seguindo as
melhores práticas, como a criação de
branches e commits pequenos e
frequentes.
Quando decidir que está na hora de
fazer o upload de seu código para o
GitHub você deve realizar o push.

Realizar push das alterações para o

GitHub

50
Para fazer o "push" das suas alterações
para o GitHub, siga os passos abaixo:

Abra o terminal no seu computador e

navegue até o diretório do seu
repositório local.

Use o comando git status para verificar

se há arquivos modificados que
precisam ser "commitados". Se houver,
use o comando git add para adicioná-
los ao "stage":

git add <arquivo-modificado>

Use o comando git commit para

confirmar as alterações adicionadas ao
"stage" e criar um "commit",:

git commit -m "mensagem de commit"

Use o comando git push para enviar as

suas alterações para o Github:

51
No momento de realizar o push (git
push), se você seguiu as melhores
práticas e criou uma branch nova para
o desenvolvimento da sua nova feature,
será necessário forçar com que o git
crie a versão remota da sua branch ao
realizar o primeiro push. Para isso você
deve rodar o seguinte comando.

git push --set-upstream origin <your-

branch>

Este comando é usado para informar

que sua branch terá uma versão
remota (no GitHub). Ou seja, enquanto
você não rodar esse comando, a sua
branch existe apenas localmente.

Nas próximas vezes que for necessário

realizar um push nesta mesma branch,
ela já estará configurada e basta rodar
o comando git push

52
Após rodar o comando de push será
necessário inserir suas credenciais do
GitHub quando solicitado (usuário e
senha ou token de acesso).

Existem outras possibilidades para lidar

com as suas credenciais. Porém, como
este livro foca apenas em questões
iniciais do git e GitHub, vou apenas
deixar aqui listado para que você, que
deseja entender melhor, possa
pesquisar:

Utilizar git config:

Definir o username nas configurações
do git, assim você não precisa informar
todas às vezes que realizar um push.

Utilizar chave SSH:

Com isso você cria uma chave que será
validada pelo servidor do GitHub para
validar as credenciais.

53
Efetuando pull de alterações

Muitas vezes é necessário atualizar sua

branch local. Principalmente a master,
pois podem ter ocorrido alterações de
outros desenvolvedores que realizaram
o merge antes de você. Para isso você
deve realizar um "pull" para a sua
branch local:

Use o comando git branch para

verificar em qual branch você está
atualmente. Se você não estiver na
branch que deseja atualizar, use o
comando git checkout para mudar de
branch:

git checkout <minha-branch>

Use o comando git pull para buscar as

alterações mais recentes da branch
remota para a sua branch local:

git pull
54
Pronto! Agora a sua branch local está
atualizada com as alterações mais
recentes da branch remota do GitHub.

55
 V

Técnicas Avançadas de Git

V 56
Técnicas avançadas:
Os próximos passos para
aperfeiçoar seu versionamento
Durante o aprendizado, você já deve ter
se familiarizado com os conceitos
básicos de controle de versão, como
commits, branches e merges. No
entanto, existem técnicas avançadas
em Git que podem levar o seu fluxo de
trabalho a um nível totalmente novo.
Neste capítulo, vamos dar uma breve
olhada em algumas dessas técnicas
avançadas para motivá-lo a explorar
mais a fundo o que Git tem a oferecer.
Embora possa parecer um pouco
intimidante no início, com a prática e a
compreensão adequadas, essas
técnicas podem transformar a maneira
como você trabalha.

57
Git rebase

O git rebase é um processo no Git que

envolve mover uma branch para um
novo commit base. É uma forma de
incorporar mudanças de uma branch
em outra, mantendo um histórico de
commits linear. O principal benefício do
rebase é que ele permite manter um
histórico de commits mais limpo e
organizado. No entanto, é importante
ser cuidadoso, especialmente se você
está trabalhando em equipe. Como
você está reescrevendo o histórico, é
possível sobrescrever o trabalho de
outra pessoa ou introduzir conflitos que
não existiam antes.

cherry-picking

O cherry-picking é uma funcionalidade

do Git que permite a aplicação de um
commit específico de uma branch em
outra.
58
Essa funcionalidade é útil quando você
deseja incorporar uma alteração
específica, sem a necessidade de
mesclar todas as alterações da branch
de origem.
Fica mais claro o entendimento quando
se traduz o nome do comando de inglês
para português. "Cherry-picking" seria
algo como "apanhar cerejas". Ou seja,
estou pegando apenas os commits que
são interessantes para minha branch.
O cherry-picking é uma funcionalidade
poderosa, mas é importante usá-la com
cuidado. Se você aplicar um commit
que introduz conflitos com outros
commits na branch de destino, pode ser
necessário resolver esses conflitos
manualmente. Além disso, aplicar
commits de uma branch que já foi
mesclada em outra branch pode
resultar em commits duplicados ou
conflitos de merge.

59
Git Hooks

Git hooks são scripts personalizados

que o Git pode executar em
determinados eventos. Esses scripts são
acionados em resposta a eventos
específicos, como commits, pushs,
merge, entre outros.
Eles permitem automatizar tarefas,
como verificação de estilo de código ou
execução de testes, e também podem
ser usados para impor políticas de
segurança no repositório.
Um bom exemplo é a criação de um git
hook que executa seus testes a cada
novo commit ou push, com isso nos
certificamos de que as alterações não
causaram problemas em
funcionalidades existentes.

Git aliases

Git aliases são atalhos personalizados

para comandos do Git. Eles permitem
60
que você crie atalhos para comandos
que você usa com frequência,
facilitando e agilizando a execução. Por
exemplo, se você utiliza o comando "git
status" com frequência, pode criar um
"alias" (apelido) para ele. Definir que
sempre que você digitar "st", por baixo
dos panos o git vai rodar o comando
"git status". É uma funcionalidade
interessante que nos deixa mais
produtivos.
Outro ponto que os torna importantes é
o fato de eles também ajudarem a
padronizar o fluxo de trabalho de uma
equipe ou projeto, permitindo que todos
usem os mesmos "aliases" para
executar comandos específicos.
Um cuidado importante de se ter ao
criar "aliases" é que eles podem
substituir nomes de comandos do Git e
também dificultar a colaboração com
outras pessoas que não estão
familiarizadas com seus "aliases"
personalizados.
6139
VI

Exercícios

VI 62
Para este primeiro exercício
trabalharemos apenas com git, logo
mais faremos algumas tarefas com Git
e GitHub.

Realize este passo a passo seguindo o

que você aprendeu até agora:

Em sua máquina, crie um repositório

Git vazio.
Adicione um arquivo README.md
com alguma informação.
Realize o primeiro commit com uma
mensagem descritiva.
Adicione um novo arquivo no
diretório.
Verifique o status do repositório
para conferir as mudanças.
Adicione o novo arquivo ao staging
area.
Faça o commit das mudanças com
uma mensagem descritiva.
Crie uma branch e alterne para ela.

63
Adicione uma nova linha no arquivo
README.md.
Faça o commit da alteração na
nova branch.
Alterne de volta para a branch
principal e verifique que a nova linha
não está presente.
Mescle a nova branch na branch
principal.
Exclua a nova branch.

64
Agora, sim, faremos algumas tarefas
utilizando GitHub

Crie um repositório no GitHub.

Clone o repositório para o seu
computador.
Adicione um arquivo README.md
com alguma informação.
Realize o primeiro commit com uma
mensagem descritiva.
Adicione um novo arquivo no
diretório.
Verifique o status do repositório
para conferir as mudanças.
Adicione o novo arquivo ao staging
area.
Faça o commit das mudanças com
uma mensagem descritiva.
Faça o push das mudanças para o
repositório remoto no GitHub.
Crie uma branch e alterne para ela.
Adicione uma nova linha no arquivo
README.md.

65
Faça o commit da nova linha na
nova branch.
Faça o push da nova branch para o
repositório remoto no GitHub.
Crie um pull request para mesclar a
nova branch na branch principal.
Mescle a nova branch na branch
principal.
Exclua a nova branch no repositório
remoto.

66
VII

Conclusão

VII 67
Este projeto é um guia prático útil para
iniciantes que desejam aprender Git e
GitHub. Ele apresenta informações
importantes com exemplos para ajudar
os leitores a entender conceitos-chave,
como commits, branches e merges.
Em suma, este livro é uma introdução
completa e bem estruturada ao Git e ao
GitHub que oferece aos iniciantes uma
compreensão sólida do fluxo de
trabalho de desenvolvimento de
software. Ele não apenas apresenta
conceitos fundamentais, mas também
explora técnicas avançadas, sendo
assim uma fonte valiosa de
informações para qualquer pessoa que
deseje aprimorar suas habilidades em
controle de versão. Este livro é uma
ferramenta útil para quem deseja
aprender Git e GitHub de maneira
rápida e eficaz.

68