Uma introdução ao Git: o que é e como usá-lo

Git é um sistema de controle de versão distribuída de código aberto . Agora, são muitas palavras para definir o Git.

Deixe-me dividir e explicar o texto:

  • Sistema de controle: Basicamente, isso significa que o Git é um rastreador de conteúdo. Portanto, o Git pode ser usado para armazenar conteúdo - ele é usado principalmente para armazenar código devido aos outros recursos que oferece.
  • Sistema de controle de versão : O código armazenado no Git muda continuamente à medida que mais código é adicionado. Além disso, muitos desenvolvedores podem adicionar código em paralelo. Portanto, o Sistema de Controle de Versão ajuda a lidar com isso, mantendo um histórico das mudanças que aconteceram. Além disso, o Git fornece recursos como branches e merges, que abordarei mais tarde.
  • Sistema de Controle de Versão Distribuída : Git possui um repositório remoto que fica armazenado em um servidor e um repositório local que fica armazenado no computador de cada desenvolvedor. Isso significa que o código não é apenas armazenado em um servidor central, mas a cópia completa do código está presente em todos os computadores dos desenvolvedores. Git é um Sistema de Controle de Versão Distribuída, já que o código está presente no computador de cada desenvolvedor. Explicarei o conceito de repositórios remotos e locais posteriormente neste artigo.

Por que um sistema de controle de versão como o Git é necessário

Projetos da vida real geralmente têm vários desenvolvedores trabalhando em paralelo. Portanto, um sistema de controle de versão como o Git é necessário para garantir que não haja conflitos de código entre os desenvolvedores.

Além disso, os requisitos de tais projetos mudam frequentemente. Portanto, um sistema de controle de versão permite aos desenvolvedores reverter e voltar para uma versão mais antiga do código.

Finalmente, às vezes, vários projetos que estão sendo executados em paralelo envolvem a mesma base de código. Nesse caso, o conceito de ramificação no Git é muito importante.

Vamos começar a usar o Git agora

Em vez de mencionar todos os conceitos de uma vez, explicarei os conceitos do Git por meio de um exemplo para que seja mais fácil seguir.

Baixe o git

Este link contém detalhes sobre como instalar o Git em vários sistemas operacionais:

//git-scm.com/book/en/v2/Getting-Started-Installing-Git

Verifique se o Git está instalado usando o seguinte comando no prompt de comando:

git --version

Crie seu repositório Git local

No seu computador, crie uma pasta para o seu projeto. Vamos chamar a pasta do projeto simple-git-demo.

Vá para a pasta do projeto e adicione um repositório Git local ao projeto usando os seguintes comandos:

cd simple-git-demo git init

O git initcomando adiciona um repositório Git local ao projeto.

Vamos adicionar um pequeno código agora

Crie um arquivo chamado demo.txtna pasta do projeto e adicione o seguinte texto a ele:

Initial Content

Aqui estaremos fazendo uma demonstração apenas com texto simples em vez de código real, uma vez que o foco principal deste artigo está no Git e não em qualquer linguagem de programação específica.

Preparação e confirmação do código

Committing é o processo no qual o código é adicionado ao repositório local . Antes de confirmar o código, ele deve estar na área de teste . A área de teste existe para manter o controle de todos os arquivos que serão confirmados.

Qualquer arquivo que não seja adicionado à área de teste não será confirmado. Isso dá ao desenvolvedor controle sobre quais arquivos precisam ser confirmados.

Staging

Use o seguinte comando para preparar o arquivo:

git add demo.txt

Caso queira adicionar vários arquivos, você pode usar:

git add file1 file2 file3

Se você deseja adicionar todos os arquivos da pasta do projeto à área de preparação, use o seguinte comando:

git add .

Use isso com cuidado, pois ele adiciona todos os arquivos e pastas em seu projeto à área de teste.

Comprometendo

Use o seguinte comando para confirmar o arquivo:

git commit -m "Initial Commit"

“Initial Commit” é a mensagem de commit aqui. Insira uma mensagem de confirmação relevante para indicar quais mudanças de código foram feitas naquele commit específico.

Git Status e Git Log

Agora modifique o demo.txtarquivo e adicione o seguinte snippet:

Initial Content Adding more Content

Status

Use git statuspara descobrir informações sobre quais arquivos foram modificados e quais arquivos estão lá na área de teste - mostra outras informações também, que podemos ignorar por enquanto.

Use o seguinte comando para ver o status:

git status

O status mostra que demo.txtestá modificado e ainda não está na área de teste.

Agora vamos adicionar demo.txtà área de teste e confirmá-lo usando os seguintes comandos:

git add demo.txt git commit -m "demo.txt file is modified"

Registro

Use git logpara imprimir todos os commits que foram feitos até agora.

O comando usado para isso é:

git log

O log mostra o autor de cada confirmação, a data da confirmação e a mensagem de confirmação.

Ramos

Até agora não criamos nenhum branch no Git. Por padrão, os commits do Git vão para o branch master .

O que é um ramo?

Um branch nada mais é que um ponteiro para o commit mais recente no repositório Git. Portanto, atualmente nosso branch master é um ponteiro para o segundo commit “demo.txt file is modified”.

Por que vários ramos são necessários?

São necessárias várias ramificações para dar suporte a vários desenvolvimentos paralelos. Consulte a imagem abaixo para ver como funcionam os ramos.

Inicialmente, o commit 1 e o commit 2 foram feitos no branch master. Após o commit 2, um novo Branch chamado “Teste” é criado, e o commit 3 e o commit 4 são adicionados ao branch de teste.

Ao mesmo tempo, um commit 3 e um commit 4 diferentes são adicionados ao branch master. Aqui podemos ver que após o Commit 2, dois desenvolvimentos paralelos estão sendo feitos em 2 ramos separados.

O ramo de teste e o ramo mestre divergiram aqui e têm códigos diferentes - o código do ramo de teste pode ser mesclado com o ramo mestre usando git merge. Isso será abordado mais tarde.

Criar uma nova filial no local

Crie um novo branch chamado test usando o seguinte comando:

git branch test

Este comando cria o testramo.

Ainda estamos no contexto do branch master. Para mudar para o test ramo. use o seguinte comando:

git checkout test

Agora estamos no testramo.

Você pode listar todos os branches no local usando o seguinte comando:

git branch

Faça alguns compromissos no novo ramo

Modifique demo.txtadicionando o seguinte snippet:

Initial Content Adding more Content Adding some Content from test Branch

Agora prepare e confirme usando os seguintes comandos:

git add demo.txt git commit -m "Test Branch Commit"

Este commit foi feito no Test Branch, e agora o Test Branch está à frente do Master Branch em 1 commit - já que o teste branch também inclui os 2 commits do master branch.

Você pode verificar o histórico de commits no Test Branch usando:

git log

Mesclando

Atualmente, Test Branch está à frente do Master em 1 commit. Digamos que agora desejamos que todo o código no ramo de teste seja trazido de volta ao ramo mestre. É aqui que git mergeé muito útil.

Para mesclar o código do branch de teste no branch master, siga estas etapas:

Primeiro volte para o branch master:

git checkout master

Em seguida, execute o mergecomando:

git merge test

Depois de executar esses 2 comandos, a fusão deve ser bem-sucedida. Neste exemplo, não há conflitos.

Mas em projetos reais, haverá conflitos quando uma mesclagem estiver sendo feita. Resolver o conflito é algo que vem com a experiência, portanto, à medida que você trabalha mais com o Git, você será capaz de pegar o jeito de resolver conflitos.

Corre git logagora e você notará que o master também tem 3 commits.

O Repositório Git Remoto

Até agora, trabalhamos apenas no repositório local. Cada desenvolvedor trabalhará em seu repositório local, mas, eventualmente, eles enviarão o código para um repositório remoto. Uma vez que o código está no repositório remoto, outros desenvolvedores podem ver e modificar esse código.

GitHub

Aqui, usaremos o GitHub para o repositório remoto.

Vá para //github.com/ e crie uma conta.

Depois de se registrar na página inicial do GitHub, clique em Start a Project para criar um novo repositório Git. Dê um nome ao repositório e clique em “Criar Repositório”

Dê o nome como git-blog-demo.

Isso criará um repositório remoto no GitHub e, quando você abrir o repositório, uma página como a imagem abaixo será aberta:

A URL do repositório é a parte destacada //github.com/aditya-sridhar/git-blog-demo.git

Para apontar seu repositório local para o repositório remoto, use o seguinte comando:

git remote add origin [repository url]

Git Push

Para enviar todo o código do repositório local para o repositório remoto, use o seguinte comando:

git push -u origin master

Isso envia o código do branch master no repositório local para o branch master no repositório remoto.

Comandos Adicionais

Git Pull

git pullé usado para extrair as alterações mais recentes do repositório remoto para o repositório local. O código do repositório remoto é atualizado continuamente por vários desenvolvedores, portanto, git pull é necessário:

git pull origin master

Clone Git

git cloneé usado para clonar um repositório remoto existente em seu computador. O comando para isso é:

git clone [repository url]

Parabéns

Agora que você sabe o básico de como usar o Git, vá em frente e explore mais!

Em breve estarei publicando mais um artigo sobre conceitos um pouco mais avançados do Git. Fique ligado!

Sobre o autor

Amo tecnologia e sigo os avanços da tecnologia. Também gosto de ajudar outras pessoas com qualquer conhecimento que possua na área de tecnologia.

Sinta-se à vontade para se conectar comigo em minha conta LinkdIn //www.linkedin.com/in/aditya1811/

Você também pode me seguir no twitter //twitter.com/adityasridhar18

Meu site: //adityasridhar.com/

Outras postagens minhas

Como usar o Git de maneira eficiente