O mínimo que você precisa saber sobre GIT

Posted by uselessdev on 03/12/2016

Sistema de Controle de Versão

VCS - Version Control System

Se você trabalha com desenvolvimento é bem provável que você saiba o que é controle de versão, se você não sabe, bem, deveria.

Usando um controle de versão você pode facilmente:

  • Ter um histórico detalhado de mudanças
  • Trabalhar em equipe é mais simples (e seguro)
  • Voltar um projeto pra uma versão estável ou específica
  • Ramificar o projeto

Se isso não te convenceu, você leu errado, leia de novo.

GIT

GIT é um sistema de controle de versão distribuido projetado inicialmente por Linus Torvalds para o desenvolvimento do Kernel Linux

A maior diferença entre GIT e outros VCS é a forma como ele trata as mudanças do seu projeto. VCS tratam a informação como um conjunto de arquivos e as mudanças feitas a cada arquivo ao longo do tempo

VCS

Já o GIT trata as mudanças como um snapshot de um mini-sistema. Cada vez que salva o estado do seu projeto é como se ele tirasse uma foto do seus arquivos naquele momento e armazena uma referência, porém se nenhum arquivo é alterado, ele não é armazenado novamente, apenas um link para o arquivo anterior.

GIT

Estados

O git trabalha normalmente com 3 estados vamos falar um pouco sobre eles:

Working Directory

Aqui ficam seus arquivos atuais, onde você vai trabalhar neles e fazer todas as suas mudanças necessárias para seu projeto.

Staging Area

É quando você termina seus alterações e adiciona eles a Área de statging podendo remove-los e assim ‘desfazer’ as alterações que forem feitas facilmente.

Git Directory (local repository)

Aqui é quando seus arquivos são adicionados de forma permanente a base do seu repositório local.

O workflow básico é bem simples

  1. Você modifica e/ou cria seus arquivos
  2. Adiciona ao statging onde esperam para ser adicionados ao repositório no próximo commit
  3. Você faz o commit pro seu repositório local

Instalando o GIT

Se você usa windows, você pode instalar facilmente, baixando o executavel no site do GIT, existe opção que permite que você utiliza o comando git do próprio ‘command’ durante a instalação se você estiver utilizando um debian-like um simples apt-get install git resolve, após isso você precisa configurar o git o mais simples possível é configurar suas credênciais:

1
2
$ git config --global user.name 'seu nome'
$ git congig --global user.email [email protected]

É claro que você pode realizar as mesmas configurações de forma local, assim essas configurações vão afetar apenas o projeto específico, basta apenas alterar o --global para --local.

Uma vez configurado, vamos criar um projeto pra entendermos melhor o GIT.

Criando o projeto

Vamos criar nosso projeto:

1
2
# Isso vai criar uma pasta chamada git-start, e navegar até ela
$ mkdir git-start; cd $_

Agora que temos nosso projeto, vamos iniciar o versionamento com GIT:

1
$ git init

Isso vai iniciar seu repositório local criando uma pasta .git nessa pasta ficam as configurações o seu repositório. Agora você já está apto a versionar seu projeto. Simples não?

Pra visualizar o status do nosso projeto basta rodar um comando

1
$ git status

Ele vai mostrar algumas informações pra você, no momento as informações são as seguintes:

  • No ramo master
  • Submissão inicial
  • Nada pra enviar

Bem ele nos informa que estamos atualmente no branch master e que não temos nada pra ser enviado ainda, então vamos criar alguns arquivos:

1
$ touch index.js;

agora se você rodar git status a mensagem será diferente, você vai ver algo como:

1
2
3
...
Arquivos não monitorados
index.js

Vamos agora adicionar esse arquivo ao staging, usando

1
$ git add index.js

Você pode usar . pra referênciar todos os arquivos: git add .

Agora vamos verificar de novo nosso status, uma mensagem parecida vai aparecer no seu terminal:

1
2
Mudanças a serem submetidas
new file: index.js

Aqui podemos ver que nosso arquivo index.js foi para a area de staging, podemos voltar ele para nosso estado de trabalho usando git rm --cached index.js logo em seguida git status, você vai ver que volta pra àrea de Não monitorado. Continuando adicione de novo o arquivo na area de staging e agora vamos mandar nosso arquivo para o repositório local:

1
$ git commit -m "Commit Inicial"

Por padrão o commit pede uma mensagem, é importante que seja bem específico nessa hora, você pode usar -q pra ignorar a mensagem

1
$ git commit -m -q

Se você ver o status agora, verá a mensagem:

nada a submeter, diretório de trabalho vazio

Vamos editar nosso arquivo index.js e verificar o status de novo

1
2
3
4
5
6
7
8
9
10
11
echo 'use strict' > index.js; git status
# Nossa saida
Changes not staged for commit:
(utilize "git add <arquivo>..." para atualizar o que será submetido)
(utilize "git checkout -- <arquivo>..." para descartar mudanças no diretório de trabalho)
modificado: index.js
nenhuma modificação adicionada à submissão (utilize "git add" e/ou "git commit -a")

Vamos entender melhor, na linha: Changes not staged for commit ele diz que basicamente nossas alterações não estão na area de staging pra realizar o commit. Depois nos da algumas opções:

  • git add <arquivo> Pra adicionarmos as modificações ao statging
  • git checkout -- <arquivo> Pra descartarmos nossas alterações

Na última linha tem mais uma opção: git commit -a se rodarmos isso:

1
$ git commit -am 'Use strict method added to index.js'

Nossas mensagem serão adicionadas ao statging e commitadas logo em seguida sem a necessidade de rodarmos git add <arquivo>

Agora se você precisar ver o log pra recuperar alguma informação o histórico de mudanças basta um commando:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ git log
# Saída
commit cd7f32ca8bf5c03a49f14d4d5801f532520c68a5
Author: uselessdev <[email protected]>
Date: Sat Dec 3 14:50:10 2016 -0200
Use strict method added to index.js
commit aa274643803b8811c78e931d8e19be99a875de07
Author: uselessdev <[email protected]>
Date: Sat Dec 3 14:35:59 2016 -0200
Commit inicial

Existem muitas opções para o log, mas não vou entrar em datelhes, com o que foi escrito aqui você já pode versionar seu projeto localmente, mas caso você esteja trabalhando em equipe, você vai precisar de um repositório remoto, é ai que entram algumas alternativas, sendo as mais conhcidas, o GitHub, Bitbucket e o GitLab, vamos usar o github.

Github

Primeiro é preciso criar uma conta, o GitHub nos permite criar repositórios públicos ilimitados, quando eu digo público eu quero dizer que são visiveis pra qualquer pessoa, olha e até mesmo, copiar seu código, mas isso não é uma coisa ruim, isso é muito bom, uma vez que a grande maioria dos projetos open source estão isponíveis no GitHub, como jQuery, Bootstrap, AngularJS, React, NodeJS, PHP e você pode até contribuir pra esses projetos, mas isso é assunto pra outra hora.

Feita sua conta vamos configurar nosso projeto pra trabalhar de forma remota, antes é claro, precisamos criar nosso repositório no Github.

Agora precisamos dizer ao GIT qual repositório remote ele deve usar:

1
$ git remote add origin https://github.com/coderwebschool/git-starter.git

origin é o nome do nosso repositório remoto e logo depois a url pra esse repositório, você pode ter mais de um repositório remoto mas isso também é assunto pra outra hora. Vamos adicionar mais conteúdo ao nosso index.js e mandar ele pro nosso repositório.

1
2
3
4
5
6
7
8
9
'use strict'
function sum (x, y) {
return x + y;
}
var result = sum(1, 5)
console.log(result)

Agora vamos enviar nossas alterações:

1
2
3
4
$ git status # Vamos ver o status do projeto
$ git add . # Adicionando todos os arquivos alterados
$ git commit -m "Adicionando função sum e fazendo log do resultado"
$ git push -u origin master

Se você adicionou o repositório remoto como fizemos aqui ele vai pedir o usuário e senha do github, antes de enviar as alterações.

O push empurra nossas alterações para o repositório remoto, a opção -u define como padrão qual repositório e qual branch vamos usar por padrão, no nosso caso o repositório origin e o branch master assim no próximo push podemos fazer apenas git push

Agora se outra pessoa for trabalhar no mesmo projeto, ele vai precisar clonar esse repositório:

1
$ git clone https://github.com/coderwebschool/git-starter.git

Uma vez feito as alterações dele, ele vai enviar as alterações seguindo o mesmo fluxo:

  • git add <arquivo>
  • git commit -m 'mensagem'
  • git push origin master

Agora o seu repositório remoto está mais atualizado que o seu, pra receber as atualizações feitas lá você pode simlesmente rodar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ git pull origin master
# Saída
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
From https://github.com/coderwebschool/git-starter
* branch master -> FETCH_HEAD
67a27f2..7715a42 master -> origin/master
Updating 67a27f2..7715a42
Fast-forward
index.js | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)

Aqui você pode ver informações de arquivos alterados, adicionados e removidos e você ainda pode ver mais detalhes usando git log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
$ git log
# Saída
commit 7715a423e5aae737970efcf3d8a4a82740eed188
Author: Lucas Pires <[email protected]>
Date: Sat Dec 3 15:36:43 2016 -0200
Adicionado funcão de multiplicão
commit 67a27f28f2368eaed31eb914916e730697e231c0
Author: uselessdev <[email protected]>
Date: Sat Dec 3 15:27:24 2016 -0200
Adicionando função sum e fazendo log do resultado
commit cd7f32ca8bf5c03a49f14d4d5801f532520c68a5
Author: uselessdev <[email protected]>
Date: Sat Dec 3 14:50:10 2016 -0200
teste
commit aa274643803b8811c78e931d8e19be99a875de07
Author: uselessdev <[email protected]>
Date: Sat Dec 3 14:35:59 2016 -0200
Commit inicial

Se você precisa voltar pra um estado específico do seu projeto você pode usar git checkout <commit>, vamos voltar pro nosso estado inicial

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ git checkout aa274 # Estamos usando apenas os 5 primeiros caracteres do commit
# Saída
Note: checking out 'aa274'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.
If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:
git checkout -b new_branch_name
HEAD is now at aa27464... Commit inicial

Aqui diz que estamos no nosso commit aa274 nós podemos fazer alterações, mudanças e realizar commits e descartar commits sem afetar nenhum branch, ou seja nossas alterações aqui não irão afetar nosso estado atual, se quisermos mantermos nossas alterações teremos que criar outro branch, ou seja, uma ramificação do nosso projeto. Vamos lá:

1
2
3
4
5
6
7
8
$ git checkout -b feature/greet # Cria um branch novo e muda pra ele
$ git branch # lista os branch locais, destacando o branch atual
# Depois de fazer nossas alterações, mandamos pro repositório remoto.
$ git add .
$ git commit -m "Nova funcionalidade greet"
$ git push origin feature/greet # É um branch diferente do master
# Agora podemos voltar pro nosso estado atual
$ git checkout 7715a

Se você ver seu arquivo, vai perceber que as alterações feitas no branch feature/greet não estão, então nós podemos mesclar isso ao branch master

1
2
3
4
5
$ git merge feature/greet
Mesclagem automática de index.js
CONFLITO (conteúdo): conflito de mesclagem em index.js
Automatic merge failed; fix conflicts and then commit the result.

Aqui recebemos um conflito, isso porque as alterações feitas no arquivo index.js de branch feature/greet estão sobreescrevendo as alterações do master:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<<<<<<< HEAD
'use strict'
function sum (x, y) {
return x + y
}
function multiply (x, y) {
return x * y
}
var result = sum(1, 5)
console.log(result, multiply(2, 3))
=======
'use trict'
function greet (name) {
return 'Hello ' + name
}
console.log(greet('Wallace'))
>>>>>>> feature/greet

Pra corrigir basta você decidir o que fazer, você pode apagar, editar, tudo que está dentro de <<<<<< HEAD é do seu estado atual, vamos mesclar e mandar pro repositório remoto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'use strict'
function sum (x, y) {
return x + y
}
function multiply (x, y) {
return x * y
}
function greet (name) {
return 'Hello ' + name
}
var result = sum(1, 5)
console.log(result, multiply(2, 3), greet('Wallace'))

Mandando as alterações:

1
2
3
$ git add .
$ git commit -m "Nova funcionalidade Greet"
$ git push

E pronto, por enquanto é só isso pessoal, vocês podem olhar esse repositório no nosso github. Qualquer dúvida, não tenham medo de perguntar.

Referências

não existe referência melhor que a documentação

Coisas bacanas ;)


Comentários: