Te ajudando com GIT e GITHUB - Guia básico

Oi pessoal, tudo bem?

Galera hoje vou dar algumas dicas de GIT aqui para vocês, alguns comandos básicos que podem ajudar a galera que está iniciando!

O que é o GIT ?

Git é um sistema de versionamento de arquivos, assim como tortoise SVN e outros. Criado em 2005, o GIT é utilizado por muitas empresas atualmente.

Saber GIT pode te ajudar a mexer com outros sistemas de versionamentos mais antigos, como o SVN por exemplo.

O que é GITHUB?

GitHub é uma plataforma de hospedagem de código-fonte e arquivos com controle de versão usando o Git. Ele permite que possamos guardar nossos projetos e contribuir com os projetos de outros desenvolvedores.

Dentro da Azure, Google clound e outros serviços de nuvem, existem sistemas similares ao GITHUB que as empresas utilizam para seus colaboradores.

Baixando o GIT

A primeira coisa que temos que fazer é baixar o GIT em nossa máquina e instalar ele. No site abaixo você poderá baixar o instalador do GIT:

https://git-scm.com/downloads

Aqui está um vídeo ensinando a instalar o GIT

https://www.youtube.com/watch?v=SOxafinthys

---------------------------------------------------------------------------

Uma vez instalado, vamos lá !

1) Iniciando o GIT - LOCAL

Vamos criar uma pasta chamada GIT ou qualquer nome que você quiser.

Dentro da pasta vamos mexer em uma coisa antes.

1º - Vamos clicar em exibir

2º - Vamos deixar marcada as opções Extensões de nomes de arquivos e Itens ocultos. Uma vez feito isso, essa configuração não precisa ser refeita.

Dentro da pasta , vamos clicar com o botão direito e escolher a opção "git bash here" :

Será aberto o terminal do git bash e vamos digitar nele "git init" e dar um enter

Perceba que uma pasta .git foi criada. Nós podemos vela por causa da configuração que fizemos. Essa pasta indica que o git está trackeando o repositório.

2) Criando uma branch

Atualmente, o GITHUB não utiliza mais a branch master como padrão. Hoje a branch utilizada como padrão é a main e para isso temos que criala.

Vamos usar o comando git checkout -b main, esse comando cria a branch e já muda o nosso diretório para a branch main

Veja que agora eu estou na main e não na master

3) - Adicionando um arquivo

vamos adicionar um documento na pasta com o visual studio code. Para abrir o vsCode basta dar um code . no terminal

No VsCode vamos criar um arquivo chamado index.html

Um macete:

Quando for escrever o código, coloque o sinal de exclamação e escolha a primeira opção da aba.

Ele vai gerar o corpo do HTML

Agora que temos um conteúdo no arquivo, vamos salvar ele :

No terminal do git bash, vamos dar o comando git status. Veja que ao dar o comando, o git diz que existe um arquivo modificado e que pode ser commitado.

Então vamos commitar o arquivo. Para isso vamos dar os seguintes comandos:

git add .

git status

Veja que agora ele está com o documento de cor ver, isso porque ele está rastreando a modificação e pronto para commitar. Se você ver, ele mostra a frase "Changes to be committed" que quer dizer, mudanças a serem commitadas.

git commit -m"salvando arquivo"

Se dermos o comando git log ou git log --oneline, podemos ver o nosso commit.

LEMBRANDO, o que estou fazendo aqui é local. As configurações remotas serão feitas mais para frente.

-------------------------------------------------------------------------------

Novas branchs

Ok, nos criamos a branch, criamos um arquivo e commitamos esse arquivo. Agora se a gente tivesse trabalhando todo mundo junto na mesma branch, isso seria bom? Na verdade não. Geralmente é entrado no consenso de qual parte do código cada um vai mexer para que não haja conflito. Isso, claro, se existir mais de um desenvolvedor em uma branch.

A branch main é a branch principal, geralmente ela é a branch de produção e não deve ser mexida diretamente. Claro que se você está fazendo um projeto seu, pequeno e próprio isso não tem problema, entretanto, nas empresas isso tem um impacto.

Vamos imaginar que no nosso arquivo HTML queremos mexer no head dele, para isso vamos criar uma nova branch a partir da main e trabalhar em cima do head. Desta forma as configurações da branch principal não serão afetadas.

Como vimos lá em cima, vamos criar uma branch a partir da main com o comando git checkout -b nome da branch, nesse caso feature1.

Se eu der o comando git branch, eu consigo ver qual branch eu estou

Se usarmos o comando git show-branch, podemos ver um pequeno exemplo de árvore de branch.

Aqui ele está falando que existe 2 branchs e que a main tem uma branch chamada feature criada a partir dela. Pode ver que ele criar uma escadinha.

Agora na feature1, vamos imaginar que foi feito um cabeçalho simples dentro das tags <header> com um H1 e umas listas com Home, Sobre e contato.

Eu posso commitar essas mudanças

Ao dar git status veja que ele me trás o nome da branch e o arquivo

vamos dar um git add . e um git commit -m"com uma mensagem"

Se dermos um git log --oneline, veremos 2 commits.

------------------------------------------------------------------------------

É possível mover entre os commits, mas uma vez um commit desfeito, não é possível retornar para ele.

Vamos usar o comando checkout com o id do commit anterior e ver o que acontece.

Se você perceber o seu arquiv HTML voltou para o estágio original de quando foi commitado:

Calma, suas mudanças não foram deletadas. Como o git armazena o estado do arquivo no momento do commit, tudo que ele fez foi mostar o estado que o arquivo estava no momento em que foi commitado.

para voltarmos, vamos dar um git checkout feature1

E nosso arquivo volta ao normal.

Entretanto, temos um problema. A branch main está com o arquivo diferente do nosso.

Esse é o arquivo da main. Como podemos fazer para ela receber as modificações da branch feature1 ?

Para isso, podemos fazer um merge na master

1º Temos que estar na branch main

git checkout main

2º Podemos dar o comando git merge feature1

Ao fazer isso, a master vai receber as modificações da feature1:

Veja que ele me diz que houve mudanças em 1 arquivo e foram 15 linhas. Veja também que já estamos na main

Se olharmos o arquivo da main novamente, veremos que ele recebeu as modificações da feature1

---------------------------------------------------------------------------------

Remoto

Hoje temos muitos repositórios web para código utilizando o GIT, como o GitHub, o GitLab, dentro do Azure entre outros.

O que vamos usar aqui é o GitHub

Para criar uma conta no git basta clicar em sign up e seguir os passos.

Configurando chave SSH

Galera, para subirmos coisas no GitHub, temos que configurar a chave SSH. Vou deixar um vídeo aqui em baixo ensinando a configurar :

https://www.youtube.com/watch?v=dWj3JEpM6nQ

Uma vez configurada a chave, vamos clicar em "New repository"

Vou dar o nome desse repositório de teste e vou adicionar o Readme.

Agora eu vou copiar o link do ssh do github:

no terminal do nosso projeto, vamos dar o seguinte comando:

git remote add origin link

Uma vez feito isso, o GIT está reconhecendo o nosso repositório remoto e agora podemos subir nossas modificações.

Lembra que ali em cima a gente marcou o README.MD ? Então, como a gente pediu para o GITHUB gerar ele automaticamente para nós, temos que baixar ele para o nosso repositório local antes de commitar para que não haja conflito.

Vamos da um git pull origin para baixar as modificações:

Caso de o conflito, você pode usar o git pull --rebase origin main

Veja que na nossa pasta, apareceu o arquivo README.MD

Agora podemos subir nossa modificação, mas antes vamos fazer uma alteração.

Vou adicionar uma tag main, apenas para o git pegar as modificações.

vamos usar os comandos:

git status

git add.

git status

git commit -m"adicionando modificações"

Vamos verificar o nosso commit com o comando git log --oneline ou git log

Veja que ele está indicando que houve um commite e que estamos nele

Agora podemos subir para o GitHub !

Vamos usar o git push origin main

Agora se olharmos para o nosso repositório remoto vamos ver o nosso arquivo!

Bom galera eu sei que é meio confuso, mas com calma da para ir pegando o jeito.

Fiquem com Deus e até a próxima!