Git: Introdução à Ferramenta

Antonio Lisbôa — Fri, 03 Jul 2020 19:49:27 +0000

Git é um sistema de versionamento de código open-source muito utilizado em todo o mundo. Para saber mais sobre sua importância em todas as áreas do desenvolvimento e porque ele ficou tão popular, acesse meu outro artigo Git no mundo do desenvolvimento.

Começando com o Git

Antes de tudo é necessário instalar o git na sua máquina, acesse o link e siga os passos para seu ambiente. É possível realizar a instalação para os principais sistemas operacionais disponíveis no mercado, entre eles Windows, Linux e Mac OS X.

Após realizar a instalação abra o seu terminal padrão, seja ele CMD, Power Shell, Bash ou Terminal no Mac, e digite:

git --version

O terminal deve retornar algo semelhante a isso:

git version 2.25.1.windows.1

Não se preocupe se o retorno do seu terminal não for exatamente igual ao citado acima, o importante é que não aparece nenhum erro na sua tela.

Para você ir para a próxima parte de configurações, primeiro crie uma conta no Github, também pode ser usado uma conta do GitLab ou Bitbucket. GitHub basicamente é um site de repositórios online com uma ótima integração com o Git, para mais informações acesse Github About.

Configurando o Ambiente

Com o seu terminal padrão aberto digite os comando abaixo para as configurações iniciais.

1.git config --global user.name UsuarioDoGitHub

O comando acima configura o seu usuário padrão no git instalado na sua máquina.

2.git config --global user.email EmailDoGitHub

O comando acima configura o seu email padrão no git instalado na sua máquina.

3.git config --global core.editor vim

O comando acima configura o vim como editor padrão no git instalado na sua máquina.

4.git config --global merge.tool vimdiff

O comando acima configura o vimdiff como ferramenta de diff padrão do git instalado na sua máquina.

Para checar se todas as configurações foram realizadas com sucesso execute o comando:

git config --list

Esse comando retorna todas as configurações atuais do seu ambiente.

Workflow básico:

Durante a utilização do Git você irá encontrar o seguinte fluxo de trabalho:

Modificação dos arquivos;
Seleção dos arquivo;
Realizar o commit;
Realizar o push das modificações.

Entendendo esse funcionamento básico, será possível realizar as principais atividades que o Git disponibiliza.

Exemplo

Antes de tudo, entre no seu perfil do Github e crie um novo repositório para testes.

No meu caso o repositório se chama teste, mas você pode colocar qualquer nome. Após criar o repositório é necessário clonar o mesmo para sua máquina. Para clonar um repositório do Github você deve entrar na página do repositório e seguir os passos abaixo:

Depois abra seu terminal padrão e em uma pasta onde você deseja colocar os arquivos do repositório digite:

git clone LinkCopiadoNoPasso2DaImagemAcima

Em seguida seu terminal deve retornar algo parecido com isso:

Cloning into 'teste'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 628 bytes | 13.00 KiB/s, done.

Agora entre na pasta do repositório que você acabou de clonar e crie um arquivo de texto, no meu caso o nome será banana e esse será o seu conteúdo:

Adicionando o arquivo a pasta do nosso repositório ficará da seguinte forma:

Toda vez que um arquivo for adicionado ou modificado é necessário adicionar as modificações ao Git localmente para depois adicionar ao repositório hospedado no Github. Inicialmente é possível verificar quais foram as modificações no projeto executando o comando abaixo no terminal dentro da pasta do repositório:

git status

Ao executar o terminal retorna algo parecido com isso:

On branch master
Your branch is up to date with 'origin/master'.
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        banana.txt
nothing added to commit but untracked files present (use "git add" to track)

Isso indica que um arquivo(banana.txt) foi criado, mas ainda não está adiciona ao git local. Então para adicionar o arquivo:

git add banana.txt

Após isso se você executar ‘git status’ novamente seu termina devolve:

On branch master
Your branch is up to date with 'origin/master'.
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   banana.txt

Agora é necessário adicionar uma mensagem a essas modificações antes de enviar para o Github para que você possa identificar o que foi modificado. Essa ação é chamada de commit. Então digite no terminal dentro da pasta do repositório:

git commit -m “Está é uma mensage escolhida por mim”

Como resultado é possível olhar um retorno parecido com isso:

[master 8af0bdb] Está é uma mensage escolhida por mim
 1 file changed, 1 insertion(+)
 create mode 100644 banana.txt

Por fim podemos enviar as nossas alterações ao Github executando um push(empurrar em inglês):

git push

Obtendo um retorno mais ou menos assim:

Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 4 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 326 bytes | 46.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/Note45/teste.git
   325a84c..8af0bdb  master -> master

Após o push quando você entrar na página do repositório no Github será possível vê as modificações que foi comitado.

Da mesma forma se uma alteração for realizado no repositório hospedado no Github por outra pessoa e você desejar atualizar seus arquivos locais para essa nova versão é possível realizando a operação contrária ao push. Para isso é só digitar no terminal dentro da pasta do projeto “git pull”, onde pull no inglês significa puxar, atualizando assim seus arquivos para a última versão.

Continuando com o nosso exemplo, se você desejar remover um arquivo do projeto, após excluir o mesmo e executar no terminal ‘git status’ você receberá como retorno algo parecido com a mensagem abaixo:

On branch master
Your branch is up to date with 'origin/master'.
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        deleted:    banana.txt
no changes added to commit (use "git add" and/or "git commit -a")

No exemplo de retorno acima eu deletei da pasta do projeto o arquivo banana.txt, sendo assim em vez de usar ‘git add ...’ iremos usar ‘git rm banana.txt’ para remover da árvore local do Git, então em seu terminal dentro da página do repositório execute:

git rm banana.txt

Em seguida:

git commit -m ‘Mensagem que você deseja colocar’

Por fim, você pode fazer o push das alterações:

git push

Como resultado do último comando você terá excluído do repositório no Github o arquivo banana.txt.

Para se familiarizar com todos esses comando, eu recomendo que você refaça esse exemplo adicionando mais arquivos e pastas.

Recapitulando o Assunto:

Durante esse artigo você estudou vários conceitos e comandos novos, nesse tópico é possível vê um breve resumo sobre os mais importantes.

Git e Github são ferramentas indispensáveis em todo o mundo do desenvolvimento;
Configuração do Ambiente:

git config --global user.name UsuarioDoGitHub
git config --global user.email EmailDoGitHub
git config --global core.editor vim
git config --global merge.tool vimdiff
git config --list

Git workflow:

Modificação dos arquivos;
Seleção dos arquivo;
Realizar o commit;
Realizar o push das modificações.

Workflow em Comandos:

git status
git add ou git remove
git commit -m ‘mensagem do commit’
git push
git pull

Lembrando que ‘git pull’ é usando quando uma modificação no repositório, que está hospedado no Github, não está no seu repositório local. Esse comando é muito utilizado quando mais de um desenvolvedor está trabalhando no mesmo projeto.

Para mais informações e exemplos eu recomendo você da uma olhada na própria documentação do git, lá é possivel encontrar muitas outras funcionalidades que irão auxiliar o desenvolvimento do seu projeto.

Encontrou algum erro nesse artigo ou gostaria de me enviar um mensagem? Go ahead :-).

Até a próxima!

Git no mundo do desenvolvimento

Antonio Lisbôa — Sun, 19 Apr 2020 13:30:35 +0000

A utilização de um sistema de controle de versão(VCS, na sigla em inglês) no mundo do desenvolvimento se tornou um regra amplamente difundida. Seja na hora de criar um trabalho local ou em conjunto com um time de programadores, utilizar um VCS é a melhor maneira de evitar dores de cabeça na hora de cuidar das diferentes versões de código.

Atualmente Git é uma das ferramentas de controle de versão mais utilizadas em ambientes de desenvolvimento. A seguir está listado alguns dos motivos pelo qual essa ferramenta se tornou tão famosa.

O que é Git?

De acordo com sua própria documentação: ”O Git é um sistema de controle de versão distribuído de código aberto e gratuito, projetado para lidar com tudo, desde
projetos pequenos a grandes, com velocidade e eficiência.”

Em termos práticos, é uma ferramenta que auxilia o desenvolvedor em todo o processo de desenvolvimento de uma solução. Ele guarda em seu histórico toda alteração realizada nos arquivos do projeto, tornando assim fácil a visualização de alterações realizadas por parte dos membros do time.

Existem vários VCS disponíveis pelo mercado, como o Subversion e o Perforce, mas o git se diferencia destes sobretudo por ter uma arquitetura distribuída.

A forma que o Git trabalha com os arquivos é outro grande diferencial dessa tecnologia. Os outros sistemas de versionamento tratam seus dados como arquivos e suas mudanças, entretanto o git trabalho com snapshots, uma captura de algo em um determinado instante, como uma imagem.

Vantagens de usar o Git

Além de entender o seu papel no mundo do desenvolvimento, é importante saber suas vantagens a fim de fazer a escolha certa na hora de escolher o Git como seu sistema de versionamento.

Desempenho

A maioria das operações no Git só precisa de arquivos e recursos locais para operar - geralmente nenhuma informação é necessária de outro computador da rede. Isso torna suas tarefas mais rápidas, pois não será necessário depender da conexão de internet na maior parte do tempo.

Por se tratar de um sistema de versionamento distribuído, é possível realizar diferentes atividades ao mesmo tempo, o que acelera o ambiente de desenvolvimento, trazendo assim agilidade para a equipe de desenvolvedores.

Segurança

Tudo no Git passa por uma soma de verificação (checksum) antes de ser armazenado e é referenciado por esse checksum. Isto significa que é impossível mudar o conteúdo de qualquer arquivo ou pasta sem que Git saiba. Essa característica demonstra como o Git lida com a integridade de seus arquivos.

Flexibilidade

Por fim, uma ótima vantagem de se trabalhar com o Git é sua flexibilidade. Ele trabalha bem com diferentes fluxos de desenvolvimento. Seja em projetos grandes ou pequenos, é possível notar toda velocidade e segurança que esse VCS propicia.

Encontrou algum erro nesse artigo ou gostaria de me enviar uma mensagem? Go ahead :-).

Forem: Antonio Lisbôa