{"id":4596,"date":"2017-05-12T18:22:54","date_gmt":"2017-05-12T21:22:54","guid":{"rendered":"https:\/\/blog.hostinger.io\/tutoriais\/?p=4596"},"modified":"2024-06-17T19:22:11","modified_gmt":"2024-06-17T22:22:11","slug":"tutorial-do-git-basics-introducao","status":"publish","type":"post","link":"\/br\/tutoriais\/tutorial-do-git-basics-introducao","title":{"rendered":"Como usar Git: tutorial completo para iniciantes"},"content":{"rendered":"

Você conhece o Git? O objetivo desse tutorial é apresentar tudo o que você precisa para começar a usá-lo.<\/p>

Primeiro de tudo, é importante saber que o Git é um sistema de controle de versão (VCS). Os VCS são uma ótima forma de otimizar o trabalho ao analisar as alterações feitas em um código de projeto compartilhado, além de ser um componente fundamental do sistema de gerenciamento de configuração de software que cuida das mudanças que precisam ser feitas em um projeto.<\/p>

As alterações\/revisões\/ atualizações feitas são identificáveis ​​através de códigos de letra ou números. Informações como data e a identidade do autor da alteração também são mantidas.<\/p>

Neste tutorial, vamos focar no Git, um dos sistemas de controle de versão mais usados no mundo.<\/p>

\"\"<\/a><\/figure>

\n\n\n\n\n\n\n<\/p>

O Que é Git?<\/strong><\/h2>

Em 2005, Linus Torvalds (o homem conhecido por criar o núcleo, ou kernel, do SO Linux) desenvolveu o GIT, que desde então tem sido ativamente mantido por Junio ​​Hamano, um engenheiro de software japonês.<\/p>

Atualmente, o Git é um dos mais famosos sistemas de controle de versão de código aberto e milhões de projetos no mundo inteiro o utilizam para seu controle de versão (incluindo projetos comerciais e de código aberto).<\/p>

O Git é totalmente grátis e pode ser instalado em Mac, Linux, Windows e Solaris diretamente do site oficial<\/strong><\/a>. Algumas das características essenciais do Git são:<\/p>

    \n
  1. Um sistema de controle de versão distribuído, o Git segue uma abordagem peer to peer,<\/strong> contrário de outros como o Subversion (SVN) que segue um modelo baseado em cliente-servidor<\/strong>.<\/li>\n\n\n\n
  2. GIT permite aos desenvolvedores ter uma infinidade de ramos de código completamente independente. Criação, exclusão e fusão desses ramos é simples e não leva tempo.<\/li>\n\n\n\n
  3. No GIT, todas as operações são atômicas. Isso significa que uma ação pode ter sucesso ou falhar (sem fazer nenhuma alteração). Isso é importante porque em alguns sistemas de controle de versão (como o CVS) onde as operações não são atômicas, se uma operação de repositório é suspensa, ela pode deixar o repositório em um estado instável.<\/li>\n\n\n\n
  4. No GIT, tudo é armazenado dentro da pasta .git. Isso não é o mesmo em outros VCS como SVN e CVS onde os metadadados de arquivos são armazenados em pastas ocultas (por exemplo, .cvs, .svn, etc.)<\/li>\n\n\n\n
  5. GIT usa um modelo de dados que ajuda a garantir a integridade criptográfica de qualquer coisa presente dentro de um repositório. Cada vez que um arquivo é adicionado ou um commit<\/em> é feito, suas somas de verificação são geradas. Da mesma forma, eles são recuperados através de suas somas de verificação também.<\/li>\n\n\n\n
  6. Outra característica presente no Git é sua área de teste<\/strong> ou índice<\/strong>. Na área de preparação, os desenvolvedores podem formatar commits<\/em> e receber feedback ​​antes de aplicá-los.<\/li>\n<\/ol>

    O Git é consideravelmente simples de usar. Para começar, você pode criar um repositório ou conferir um já existente. Após a instalação, um simples git-init<\/code> irá deixar tudo pronto. Da mesma maneira, o comando git clone<\/code> pode criar uma cópia de um repositório local para um usuário.<\/p>

    \n
    \"organograma<\/figure><\/div>

    1º Passo – Instalando o Git em Sistemas Diferentes<\/strong><\/h2>

    Nos parágrafos abaixo vamos ensinar a maneira mais simples de instalar o Git em diversos sistemas operacionais:<\/p>

    Como Instalar o GIT no Windows:<\/strong><\/h3>

    Instalar o Git no Windows é tão simples como baixar um instalador e executá-lo. Execute os seguintes passos para instalar o Git no Windows:<\/p>

      \n
    1. Acesse o site oficial<\/strong><\/a> e faça o download do instalador do Git para Windows.<\/li>\n\n\n\n
    2. Depois de baixado, clique duas vezes no arquivo para iniciar o assistente de instalação. Basta seguir as instruções na tela, clicando em Next<\/strong>. Ao término, clique em Finish<\/strong> para concluir com êxito a instalação.
      \"git<\/li>\n\n\n\n
    3. Abra o prompt de comando<\/strong><\/a> e digite os seguintes comandos no terminal:<\/li>\n<\/ol>
      git config --global user.name \"João Silva\"\ngit config --global user.email \"exemplo@seuemail.com.br\"<\/pre>
      \n\n\n
      Importante!<\/strong> Nota: Lembre de substituir João Silva<\/strong> e exemplo@seuemail.com.br<\/strong> com seus dados. Qualquer commit<\/em> criado posteriormente será associado à esses dados.<\/p><\/div>\n\n\n\n<\/p>
      Git instalado no Windows com sucesso!<\/p>
      Como Instalar o Git no MacOS:<\/strong><\/h3>
      Existem muitas maneiras de instalar o Git em um Mac. Inclusive, há uma chance de que o Git já esteja no seu computador se você tiver o XCode instalado. Execute o seguinte comando no terminal para verificar:<\/p>
      git --version<\/pre>
      Se você obtiver uma resposta como git version 2.7.0 (Apple Git-66)<\/code>, então você está com sorte. Caso você não tenha resposta, execute os seguintes passos:<\/p>
        \n
      1. Visite este site<\/a> e faça o download do instalador mais recente para Mac.<\/li>\n\n\n\n
      2. Siga as instruções na tela e conclua a instalação.
        \"git<\/li>\n\n\n\n
      3. Tente novamente o comando git --version<\/code> para confirmar se a instalação foi bem sucedida.<\/li>\n\n\n\n
      4. Execute os seguintes comandos no terminal para configurar seu e-mail e nome de usuário que serão associados à sua conta Git:<\/li>\n<\/ol>
        git config --global user.name \"João Silva\"\ngit config --global user.email \"exemplo@seuemail.com.br\"<\/pre>
        \n\n\n
        Importante!<\/strong> Nota: Lembre-se de substituir João Silva<\/strong> e exemplo@seuemail.com.br<\/strong> com seus dados. Qualquer commit<\/em> criado posteriormente será associado à esses dados.<\/p><\/div>\n\n\n\n<\/p>
        Como Instalar o GIT no Linux:<\/strong><\/h3>
        Se você usa Linux em qualquer sistema (ou num <\/strong>servidor VPS<\/a>), então você deve estar acostumado com instalar programas e pacotes em seu computador usando comandos de instalação apt-get<\/code> ou yum<\/code>. Instalar o Git não é diferente:<\/p>
        \"\"<\/a><\/figure>
        Para usuários Debian\/Ubuntu (apt-get):<\/strong><\/p>
          \n
        1. Abra o terminal e execute os seguintes comandos:\n
          sudo apt-get update \nsudo apt-get install git<\/pre>\n<\/li>\n\n\n\n
        2. Verifique se a instalação ocorreu com sucesso usando git --version<\/code>.<\/li>\n\n\n\n
        3. Execute os seguintes comandos no terminal para configurar seu e-mail e nome de usuário que serão associados à sua conta Git: 
          git config --global user.name \"João Silva\" 
          git config --global user.email \"exemplo@seuemail.com.br\"<\/pre><\/li>\n<\/ol>
          \n\n\n
          Importante!<\/strong> Nota: Lembre-se de substituir João Silva<\/strong> e exemplo@seuemail.com.br<\/strong> com seus dados. Qualquer commit<\/em> criado posteriormente será associado à esses dados.<\/p><\/div>\n\n\n\n<\/p>
          Fedora (yum\/dnf):<\/strong><\/p>
          Você pode baixar pacotes do Git usando yum e dnf.<\/p>
            \n
          1. Abra o terminal e execute os seguintes comandos:\n
            sudo dnf install git\nsudo yum install git<\/pre>\n<\/li>\n\n\n\n
          2. Verifique se a instalação ocorreu com sucesso usando git --version<\/code>.<\/li>\n\n\n\n
          3. Execute os seguintes comandos no terminal para configurar seu e-mail e nome de usuário que serão associados à sua conta GIT: 
            git config --global user.name \"João Silva\" git config --global user.email \"exemplo@seuemail.com.br\"<\/pre><\/li>\n<\/ol>
            Lembre-se de substituir João Silva<\/strong> e exemplo@seuemail.com.br<\/strong> com seus dados. Qualquer commit<\/em> criado posteriormente será associado à esses dados.<\/p>
            \n\n\n
            \n                    
            Dica<\/h4>\n                    
            Confira nosso tutorial completo sobre como instalar o Git no Ubuntu<\/a>, a distribuição Linux mais popular do mundo.<\/p>\n                <\/div>\n\n\n\n<\/p>
            2º Passo – Como Usar o Git<\/strong><\/h2>
            Agora que o Git está instalado e configurado no seu dispositivo, vamos explorar os seus conceitos básicos e como começar a usá-lo.<\/p>
            Criar, Configurar e Verificar um Repositório<\/strong><\/h3>
            Um repositório é o maior bem de qualquer projeto controlado por versão. Para transformar qualquer diretório em um repositório Git, o simples comando git init <directory><\/code> pode ser utilizado. Uma pasta chamada .git também deve começar a existir no diretório em que o comando foi executado.<\/p>
            Por outro lado, se você já tem um diretório e deseja verificar (clone-lo), você pode usar o comando git clone. Se você estiver tentando verificar um repositório local, use o seguinte comando:<\/p>
            git clone \/path\/to\/local\/repository<\/pre>
            Se você pretende verificar um repositório armazenado remotamente, use:<\/p>
            git clone user.name@host:\/path\/to\/remote\/repository<\/pre>
            \n
            \"fluxograma<\/figure><\/div>
            Se você tem uma conta na Hostinger, você pode facilmente clonar e gerenciar repositórios via hPanel → Hospedagem → Avançado → GIT<\/strong>. Por exemplo, se você quer clonar um repositório Git, basta digitar seu endereço, escolher um ramo e instalar o caminho, e clicar no botão criar.<\/p>
            \n
            \"a<\/figure><\/div>
            Após a conclusão da criação, você poderá gerenciar seu repositório na mesma seção.<\/p>
            Criando seu Fluxo de Trabalho<\/h2>
            Agora que o repositório está pronto, vamos falar sobre a estrutura que é mantida pelo Git.<\/p>
            Cada repositório local consiste em três árvores: o diretório de trabalho<\/strong> que contém os arquivos reais; O índice<\/strong> que desempenha o papel de uma área de teste e o HEAD<\/strong> que é um ponteiro para o último commit<\/em> feito pelo usuário.<\/p>
            Então, é assim que o fluxo de trabalho pode ser explicado: o usuário adiciona um arquivo ou alterações do diretório de trabalho para o índice (a área de teste) e uma vez revistos, o arquivo ou as alterações são finalmente comprometidos com o HEAD<\/strong>.<\/p>
            Os Comandos Add<\/em> e Commit:<\/em><\/strong><\/h3>
            Alterações ou adições de arquivos propostas são adicionadas ao índice usando o comando add<\/em>. Para adicionar qualquer arquivo, o comando é:<\/p>
            git add <nome_do_arquivo><\/pre>
            Se você está realmente confiante o suficiente para fazer essas mudanças no HEAD<\/strong><\/em>, então você pode usar o comando commit<\/em>:<\/p>
            git commit –m “Adicionar qualquer mensagem sobre o commit aqui”<\/pre>
            \n\n\n
            Importante!<\/strong> Nota: Uma vez que o comando commit<\/em> é executado (a partir do diretório de trabalho), o arquivo fica comprometido com o HEAD<\/strong><\/em>, mas ainda não é enviado para o repositório remoto.<\/p><\/div>\n\n\n\n<\/p>
            Dando Continuidade às Mudanças<\/h3>
            Depois de confirmar as alterações (e acreditar que elas estão prontas para serem enviadas para o repositório original), você pode usar o comando push.<\/p>
            Uma vez que o git push origin master<\/code> é executado de dentro do diretório de trabalho, as mudanças presentes no HEAD<\/strong> são enviadas para o repositório remoto. No comando acima mencionado, o master<\/strong> pode ser alterado para o nome do branch<\/em> ao qual você deseja que as alterações sejam comprometidas.<\/p>
            Se, no entanto, um repositório existente ainda não tiver sido clonado e você pretende estabelecer uma ligação entre o seu repositório e um servidor remoto, execute o seguinte comando:<\/p>
            git remote add origin <servidor><\/pre>
            \n\n\n
            Importante!<\/strong> Nota: Substitua  pelo endereço do servidor remoto.<\/p><\/div>\n\n\n\n<\/p>
            Uma vez clonado, quaisquer alterações feitas serão aplicadas para o servidor pertinente.<\/p>
            Branches<\/em><\/h3>
            Outra característica brilhante (mas avançada) do Git é sua capacidade de permitir que desenvolvedores e gerentes de projeto criem vários ramos (branches<\/em>) independentes dentro de um único projeto.<\/p>
            O objetivo principal de um branch<\/em> é desenvolver novas funcionalidades, mantendo-os isolados uns dos outros. O branch<\/em> padrão em qualquer projeto é sempre o master branch<\/em><\/strong>. Tantos branches<\/em> quanto necessários podem ser criados e eventualmente mesclados ao master branch<\/em>.<\/p>
            Um novo branch<\/em> pode ser criado usando o seguinte comando:<\/p>
            git checkout -b feature_n *<\/pre>
            feature_n<\/strong> é o nome do branch.<\/em><\/p>
            Se você deseja retornar ao master<\/em> branch, o seguinte comando pode ser usado:<\/p>
            git checkout master<\/pre>
            Qualquer branch<\/em> pode ser excluído usando o seguinte comando:<\/p>
            git checkout -b feature_n<\/pre>
            Para tornar o branch<\/em> disponível para outros usuários, você terá que movê-lo para o repositório remoto. Para fazer isso, use o seguinte comando:<\/p>
            git push origin feature_n<\/pre>
            \n
            \"organograma<\/figure><\/div>
            Atualizando e Dando Merge<\/em><\/h3>
            Caso você queira atualizar seu diretório de trabalho local para o mais recente do repositório remoto, o simples comando git pull<\/code> pode ser usado.<\/p>
            Para mesclar outro branch (dar um merge<\/em>) no atualmente ativo, use: git merge feature_n<\/code>.<\/p>
            Se você der um merge<\/em> ou pull<\/em>, o Git sempre tenta lidar com os conflitos por conta própria, mas as vezes não consegue. Em caso de falha devido a conflitos, o usuário tem que resolver os conflitos manualmente. Depois de editar os arquivos (para erradicar conflitos), marque-os como merged<\/em> usando:<\/p>
            git add <nome.arquivo><\/pre>
            Se antes do merge<\/em> você desejar visualizar as alterações, o seguinte comando pode ser executado:<\/p>
            git diff <nome_branch_origem> <nome_branch_alvo><\/pre>
            Tagging<\/em><\/h3>
            Antes de lançar atualizações\/alterações de software, é sempre recomendado criar tags. Para fazer isso no GIT, use o seguinte comando:<\/p>
            git tag 1.1.0 1c2d2d56fa<\/pre>
            O 1c2d2d56fa<\/strong> no comando acima refere-se aos primeiros 10 caracteres do commit-id<\/strong> que é referenciado com a tag. O ID de commit<\/em> pode ser encontrado no log.<\/p>
            Log<\/em><\/h3>
            O histórico do repositório pode ser estudado através do log. O comando git log<\/code> recupera as informações. Para recuperar os commits<\/em> feitos por um único usuário, você pode usar:<\/p>
            git log --author =Smith<\/pre>
            Uma versão compactada do log (um commit<\/em> por linha) pode ser visualizada usando:<\/p>
            git log --pretty=oneline<\/pre>
            Para exibir somente os arquivos que foram alterados:<\/p>
            git log --name-status<\/pre>
            Substituindo Alterações Locais<\/h3>
            Se você acabou fazendo bagunça e precisa reverter as alterações feitas em qualquer arquivo, faça isso usando o seguinte comando:<\/p>
            git checkout -- <nomedoarquivo><\/pre>
            Isso substituirá as alterações da árvore de trabalho pelos últimos dados presentes no HEAD<\/strong>. Quaisquer alterações que já tenham sido adicionadas ao índice não serão prejudicadas.<\/p>
            Por outro lado, se todas as alterações\/commits<\/em> locais devem ser eliminados e o master branch<\/em> local for necessário para apontar para o histórico mais recente do servidor, execute os seguintes comandos:<\/p>
            git fetch origin\n\ngit reset --hard origin\/master<\/pre>
            Conclusão – Tutorial Git<\/strong><\/h2>
            No mundo de projetos de software, é sempre reconfortante saber que alguém está cuidando de toda a gestão de código para você.<\/p>
            Nosso Git Tutorial para iniciantes<\/strong> irá ajudar qualquer desenvolvedor para começar a utilizar o Git, que é um rigoroso (e muito útil) sistema de controle de versão com uma infinidade de recursos. Se quiser saber mais sobre comandos Git, consulte nosso tutorial<\/a>.<\/p>
            Ficou com alguma dúvida? Tem alguma sugestão? Comente abaixo!<\/p>\n","protected":false},"excerpt":{"rendered":"
            Você conhece o Git? O objetivo desse tutorial é apresentar tudo o que você precisa para começar a usá-lo. Primeiro de tudo, é importante saber que o Git é um sistema de controle de versão (VCS). Os VCS são uma ótima forma de otimizar o trabalho ao analisar as alterações feitas em um código de […]<\/p>\n
            Read More…<\/a><\/p>\n","protected":false},"author":78,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"rank_math_title":"Como Usar Git: Tutorial Completo Para Iniciantes","rank_math_description":"Nosso tutorial do Git ensina como instal\u00e1-lo em sistemas diferentes e como us\u00e1-lo corretamente - tudo com uma linguagem simples de entender.","rank_math_focus_keyword":"GIT tutorial","footnotes":""},"categories":[4902],"tags":[4906,4903,4868,4852],"class_list":["post-4596","post","type-post","status-publish","format-standard","hentry","category-git","tag-basico","tag-comandos","tag-git","tag-linux"],"hreflangs":[{"locale":"pt-BR","link":"https:\/\/www.hostinger.com\/br\/tutoriais\/tutorial-do-git-basics-introducao","default":1},{"locale":"pt-PT","link":"https:\/\/www.hostinger.com\/pt\/tutoriais\/tutorial-do-git-basics-introducao","default":0}],"acf":[],"_links":{"self":[{"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/posts\/4596","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/users\/78"}],"replies":[{"embeddable":true,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/comments?post=4596"}],"version-history":[{"count":29,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/posts\/4596\/revisions"}],"predecessor-version":[{"id":44554,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/posts\/4596\/revisions\/44554"}],"wp:attachment":[{"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/media?parent=4596"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/categories?post=4596"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.hostinger.com\/br\/tutoriais\/wp-json\/wp\/v2\/tags?post=4596"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}