O desenvolvimento de software é um trabalho colaborativo. Como engenheiro de software, você precisa compartilhar seu trabalho com outras pessoas. Mas compartilhar código e colaborar pode ser complicado. É difícil acompanhar as várias mudanças que acontecem durante o ciclo de vida de um software. Portanto, as equipes de desenvolvimento contam com ferramentas de controle de versão para ajudar no processo de colaboração de software. Git é uma das ferramentas de controle de versão mais proeminentes na indústria de software.
Dica: Neste tutorial, você aprenderá como usar os fundamentos do Git. Cada seção termina com algumas perguntas. Você pode ler as perguntas antes de começar a ler a seção. Isso ajudará você a entender e prestar atenção aos pontos importantes.
Divirta-se aprendendo Git!
Git: uma breve visão geral
Git é um sistema de controle de versão distribuído. Ele mantém o controle de todas as alterações feitas em seus arquivos e pastas. Isso torna mais fácil salvar seu trabalho em andamento. Se houver um problema, você pode facilmente verificar uma versão anterior do arquivo ou pasta. Se necessário, você pode até mesmo reverter toda a sua base de código para uma versão mais antiga.
O desenvolvimento do Git começou em 2005. O grupo do kernel Linux costumava manter seu código no BitKeeper, um sistema proprietário de controle de versão distribuída. No entanto, o BitKeeper retirou o uso gratuito do produto. Então Linus Torvalds, o criador e principal desenvolvedor do Linux, projetou um novo sistema de controle de versão distribuído de código aberto que atenderia aos requisitos da comunidade de desenvolvimento Linux. E Git nasceu.
Como um sistema de controle de versão distribuído, o Git não requer uma autoridade centralizada para controlar o código. Controles de versão centralizada mais antigos como CVS, SVN ou Perforce requerem servidores centrais para manter o histórico de mudanças. Git pode acompanhar todas as mudanças localmente e trabalhar ponto a ponto. Portanto, é mais versátil do que sistemas centralizados.
Questões:
- Por que você deve usar o Git?
- Qual é a vantagem do controle de versão distribuída?
Instalando Git
Para sistemas Linux, instalar o Git é fácil. Se estiver usando uma distribuição baseada em Debian como o Ubuntu, você pode usar apt install:
$ sudo apt install git-allPara Fedora, RHEL ou CentOS, você pode usar:
$ sudo dnf install git-allVocê pode verificar se o Git foi instalado, usando o seguinte comando:
$ git --versionEle deve mostrar a versão do Git que você instalou, por exemplo:
git versão 2.17.0Depois de instalar o Git, é hora de configurar seu nome de usuário e e-mail:
$ git config - usuário global.nome "seunomedeusuario"$ git config - usuário global.email "[email protegido]"
Você pode verificar se as configurações foram definidas corretamente usando o seguinte comando:
$ git config --listdo utilizador.nome = seunomedeusuario
do utilizador.email = seunomedeusuario @ exemplo.com
Dica: É importante definir o usuário.nome e usuário.e-mail porque essas configurações são usadas para rastrear suas alterações.
Questões
- Qual é o comando para instalar o Git em seu sistema Linux?
- Por que você deve configurar o usuário.nome e usuário.configuração de e-mail? Como você os configura?
Compreendendo o Git conceitualmente
Para usar o Git, primeiro você precisa entender estes quatro conceitos:
- Diretório de trabalho
- Área de Preparação
- Repositório
- Repositório Remoto
O diretório de trabalho, a área de teste e o repositório são locais para sua máquina. O repositório remoto pode ser qualquer outro computador ou servidor. Vamos pensar nesses conceitos como quatro caixas que podem conter papéis A1 padrão.
Suponha que você esteja escrevendo um documento à mão em um papel A1 em sua mesa. Você mantém este documento na caixa do diretório de trabalho. Em um determinado estágio de seu trabalho, você decide que está pronto para manter uma cópia do trabalho que você já fez. Então você faz uma fotocópia do seu artigo atual e a coloca na caixa de teste.
A caixa de teste é uma área temporária. Se você decidir descartar a fotocópia na caixa de teste e atualizá-la com uma nova cópia do documento do diretório de trabalho, não haverá registro permanente desse documento de teste.
Suponha que você tenha certeza de que deseja manter o registro permanente do documento que você tem na caixa de teste. Em seguida, você faz uma fotocópia do documento da caixa de teste e o move para a caixa de repositório.
Quando você o move para a caixa do repositório, duas coisas acontecem:
- Um instantâneo do documento é salvo permanentemente.
- Uma entrada no arquivo de registro é feita para acompanhar o instantâneo.
A entrada de registro irá ajudá-lo a encontrar aquele instantâneo específico do seu documento se você precisar dele no futuro.
Agora, na caixa do repositório local, você tem um instantâneo do seu trabalho e uma entrada de registro. Mas só está disponível para você. Então você faz uma cópia do seu documento de repositório local junto com o arquivo de log e o coloca em uma caixa no almoxarifado da empresa. Agora, qualquer pessoa na sua empresa pode vir e fazer uma cópia do seu documento e levá-la para sua mesa. A caixa na sala de abastecimento seria o repositório remoto.
O repositório remoto é como compartilhar seu documento usando o Google Docs ou Dropbox.
Questões:
- Você pode definir o diretório de trabalho, teste, repositório e repositório remoto?
- Você pode desenhar como os documentos se movem de um estágio para outro?
Seu primeiro repositório Git
Depois de instalar o Git, você pode começar a criar seus próprios repositórios Git. Nesta seção, você inicializará seu repositório Git.
Suponha que você esteja trabalhando em um projeto de desenvolvimento web. Vamos criar uma pasta chamada project_helloworld e mudar para o diretório:
$ mkdir project_helloworld$ cd project_helloworld
Você pode dizer ao Git para monitorar este diretório com o seguinte comando:
$ git initVocê deve ver uma saída como esta:
Repositório Git vazio inicializado em / Users / zakh / _work / LearnGIT / git_tutorial /project_helloworld /.idiota
Agora, todos os arquivos e pastas dentro do project_helloworld serão rastreados pelo Git.
Questões:
- Como você inicializa um diretório a ser rastreado pelo Git?
Comandos Git básicos: status, registro, adição e confirmação
O comando status mostra a condição atual do seu diretório de trabalho e o comando log mostra o histórico. Vamos tentar o comando de status:
$ git statusNo mestre de filial
Commit inicial
nada para confirmar (criar / copiar arquivos e usar "git add" para rastrear)
A saída do comando git status está dizendo que você está no branch master. Este é o branch padrão que o Git inicializa. (Você pode criar seus próprios ramos. Mais sobre branches posteriormente). Além disso, a saída está dizendo que não há nada a ser confirmado.
Vamos tentar o comando log:
$ git logfatal: seu branch atual 'master' ainda não tem nenhum commit
Então, é hora de criar algum código. Vamos criar um arquivo chamado índice.html:
Olá Mundo
Você pode usar o editor de texto para criar o arquivo. Depois de salvar o arquivo, verifique o status novamente:
$ git statusNo mestre de filial
Commit inicial
Arquivos não rastreados:
(use "git add
índice.html
nada adicionado ao commit, mas arquivos não rastreados presentes (use "git add" para rastrear)
O Git está dizendo que você tem um arquivo chamado index.html em seu diretório de trabalho que não é rastreado.
Vamos nos certificar de que o índice.html é rastreado. Você precisará usar o comando add:
$ git add index.htmlAlternativamente, você pode usar o “.”Opção para adicionar tudo no diretório:
$ git add .Agora vamos verificar o status novamente:
$ git statusNo mestre de filial
Commit inicial
Mudanças a serem confirmadas:
(use "git rm --cached
novo arquivo: índice.html
O verde indica que o índice.arquivo html está sendo rastreado pelo Git.
Dica: Conforme mencionado nas instruções acima, se você usar o comando:
$ git rm - índice em cache.htmlSeu índice.html irá voltar ao status não rastreado. Você terá que adicioná-lo novamente para trazê-lo de volta ao teste.]
Vamos verificar o log novamente:
$ git logfatal: seu branch atual 'master' ainda não tem nenhum commit
Portanto, embora o Git esteja rastreando o índice.html, não há nada no repositório Git sobre o arquivo ainda. Vamos comprometer nossas mudanças:
$ git commit -m "Índice de confirmação.html "A saída deve ser semelhante a esta:
[master (root-commit) f136d22] Índice de comprometimento.html
1 arquivo alterado, 6 inserções (+)
modo de criação 100644 índice.html
O texto entre aspas após o “-m” é um comentário que irá para o arquivo de log. Você pode usar o git commit sem “-m”, mas então o Git abrirá um editor de texto pedindo que você escreva os comentários. É mais fácil simplesmente colocar os comentários diretamente na linha de comando.
Agora vamos verificar nosso arquivo de log:
$ git logcommit f136d22040ba81686c9522f4ff94961a68751af7
Autor: Zak H
Data: Seg 4 de junho 16:53:42 2018 -0700
Índice de comprometimento.html
Você pode ver que ele está mostrando um commit. Você confirmou com sucesso suas alterações em seu repositório local. Se quiser ver o mesmo registro de forma concisa, você pode usar o seguinte comando:
$ git log --onelinef136d22 Índice de comprometimento.html
Seguindo em frente, usaremos esta forma do comando log porque torna mais fácil entender o que está acontecendo.
Vamos começar a editar o índice.html. Abra o índice.arquivo html em um editor e altere a linha “Hello world” para “Hello world! Wsou eu!”E salve-o. Se você verificar o status novamente, verá que o Git notou que você está editando o arquivo:
$ git statusNo mestre de filial
Mudanças não preparadas para confirmação:
(use "git add
(use "git checkout --
modificado: índice.html
nenhuma alteração adicionada ao commit (use "git add" e / ou "git commit -a")
A mudança ainda está em seu diretório de trabalho. Você precisa empurrá-lo para a área de preparação. Use o comando add que você usou antes:
$ git add .Verifique o status novamente:
$ git statusNo mestre de filial
Mudanças a serem confirmadas:
(use "git reset HEAD
modificado: índice.html
Agora suas mudanças estão na área de preparação. Você pode enviá-lo para o repositório para proteção permanente:
$ git commit -m "Índice modificado.html para uma mensagem mais feliz "[master 0586662] Índice modificado.html para uma mensagem mais feliz
1 arquivo alterado, 1 inserção (+), 1 exclusão (-)
Você pode verificar o log de suas alterações permanentes:
$ git log --oneline0586662 Índice modificado.html para uma mensagem mais feliz
f136d22 Índice de comprometimento.html
Nesta seção, você aprendeu a usar os comandos status, log, add e commit para controlar seus documentos no Git.
Questões:
- O que git status faz?
- O que o git log faz?
- O que git add faz?
- O que git commit faz?
Voltar para arquivos mais antigos usando o check-out
Quando você confirma um arquivo no Git, ele cria um hash único para cada confirmação. Você pode usá-los como identificadores para retornar a uma versão mais antiga.
Vamos supor que você queira voltar para a sua versão anterior do índice.html. Primeiro, vamos olhar para o índice.html na condição atual:
índice $ cat.htmlOlá Mundo! Wsou eu!
Você pode ver que tem a versão mais recente (“Olá, mundo! Wsou eu!”). Vamos verificar o log:
$ git log --oneline0586662 Índice modificado.html para uma mensagem mais feliz
f136d22 Índice de comprometimento.html
O hash da versão anterior era f136d22 (“Olá, mundo”). Você pode usar o comando checkout para obter essa versão:
$ git checkout f136d22Nota: verificando 'f136d22'.
Você está no estado de 'HEAD desanexado'. Você pode olhar ao redor, fazer mudanças experimentais
e enviá-los, e você pode descartar todos os commits que fizer neste estado
sem impactar nenhuma filial executando outra verificação.
Se você deseja criar um novo branch para reter os commits que você criou, você pode
faça isso (agora ou mais tarde) usando -b com o comando checkout novamente. Exemplo:
git checkout -b
HEAD está agora em f136d22 ... Índice de confirmação.html
Se você olhar para o conteúdo do índice.html, você verá:
índice $ cat.htmlOlá Mundo
Tem apenas “Olá, mundo”. Então, seu índice.html mudou para a versão mais antiga. Se você verificar o status:
$ git statusHEAD desconectado em f136d22
nada para confirmar, diretório de trabalho limpo
O Git está basicamente dizendo que o HEAD não está no commit mais recente. Você pode voltar para o commit mais recente fazendo check-out do branch master usando o seguinte comando:
$ git checkout masterA posição HEAD anterior era f136d22 ... Índice de confirmação.html
Mudou para branch 'master'
Agora, se você verificar o status:
$ git statusNo mestre de filial
nada para confirmar, diretório de trabalho limpo
O aviso vermelho se foi. Além disso, se você verificar o seu índice.html, você deve voltar para a versão mais recente:
índice $ cat.htmlOlá Mundo! Wsou eu!
O comando checkout leva você a vários estados. Aprenderemos mais sobre check-out na próxima seção.
Questões:
- Como você usa o comando git checkout para ir para uma versão mais antiga de um arquivo?
- Como você usa git checkout para voltar para a versão mais recente do arquivo?
Check-out, Ramificação e Mesclagem
Ramificação é uma das melhores características do Git. Ajuda a separar seu trabalho e experimentar mais. Em outros sistemas de controle de versão, a ramificação era demorada e difícil. O Git tornou a ramificação e a fusão mais fáceis.
Como você notou no comando de status, quando você cria um novo repositório Git, você está no branch master.
$ git statusNo mestre de filial
nada para confirmar, diretório de trabalho limpo
Suponha que você esteja fazendo um site para seu amigo David. Você deseja reutilizar o código do seu próprio site. Ramificação é uma ótima solução. Vamos chamar o branch david_website.
Você pode emitir o seguinte comando:
$ git branch david_websiteVocê pode usar o seguinte comando para ver todas as ramificações:
$ git branch --listdavid_website
* mestre
A estrela (*) ao lado do mestre significa que você ainda está no ramo mestre. Você pode verificar o branch david_website com o seguinte comando:
$ git checkout david_websiteMudou para o branch 'david_website'
Agora, se você verificar novamente a lista de ramos, verá:
$ git branch --list* david_website
mestre
Então você está no branch david_website.
Vamos mudar o índice.html de “Hello world! Wsou eu!”Para“ Olá, mundo! É o David!”E, em seguida, encenar e confirmar:
$ git add .$ git commit -m "Site alterado para David"
Se você verificar os registros, verá:
$ git log --oneline345c0f4 Site alterado para David
0586662 Índice modificado.html para uma mensagem mais feliz
f136d22 Índice de comprometimento.html
E seu arquivo de índice deve ser assim:
índice $ cat.htmlOlá Mundo! É o David!
Agora vamos verificar o branch master novamente:
$ git checkout masterMudou para branch 'master'
Se você verificar o status e o registro:
$ git statusNo mestre de filial
nada para confirmar, diretório de trabalho limpo
$ git log --oneline
0586662 Índice modificado.html para uma mensagem mais feliz
f136d22 Índice de comprometimento.html
Observe que você não tem seu terceiro commit no master. Porque esse commit é mantido apenas no branch david_website.
Isso é o que aconteceu
Suponha que, nesta fase, você decida que não deseja continuar com o seu site. Você será apenas o desenvolvedor de David. Então você deseja mesclar as mudanças no branch david_website para o master. Do branch master, você só precisa emitir os seguintes comandos (o comando status é usado para verificar se você está no lugar certo):
$ git statusNo mestre de filial
nada para confirmar, diretório de trabalho limpo
$ git merge david_website
Atualizando 0586662… 345c0f4
Avanço rápido
índice.html | 2 +-
1 arquivo alterado, 1 inserção (+), 1 exclusão (-)
Dica: Você está puxando mudanças de david_website para master. Você tem que estar no mestre para conseguir isso.
Agora, se você verificar o log no master, verá que o terceiro commit está lá:
$ git log --oneline345c0f4 Site alterado para David
0586662 Índice modificado.html para uma mensagem mais feliz
f136d22 Índice de comprometimento.html
Você fundiu com sucesso o branch david_website no master. E seu índice.html para o branch master é idêntico ao branch david_website:
índice $ cat.htmlOlá Mundo! É o David!
Você pode manter o branch david_website:
$ git branch --listdavid_website
* mestre
Ou você pode excluí-lo:
$ git branch -d david_websiteRamo david_website excluído (era 345c0f4).
Após a exclusão, você não verá mais o branch david_website:
$ git branch --list* mestre
Dica: Durante uma fusão, se o Git não puder fazer a fusão automaticamente, ele apresentará erros de conflito de fusão. Nesse caso, você deve resolver manualmente os problemas de mesclagem.
Questões:
- Por que você precisa de ramificação?
- Como você ramifica e mescla arquivos e pastas?
Repositório Remoto
Até agora, todo o seu trabalho tem sido local. Você tem enviado suas alterações para um repositório local. Mas é hora de compartilhar seu trabalho com o mundo.
O repositório remoto Git é basicamente outra cópia do seu repositório local que pode ser acessado por outros. Você pode configurar um servidor e torná-lo o repositório remoto. Mas a maioria das pessoas usa GitHub ou Bitbucket para este propósito. Você pode criar repositórios públicos gratuitamente lá, que podem ser acessados por qualquer pessoa.
Vamos criar um repositório remoto no GitHub.
Primeiro, você precisa criar uma conta GitHub []. Depois de ter a conta, crie um novo repositório usando o botão “Novo repositório”. Use “project_website” como o nome do repositório (você pode escolher qualquer outra coisa se quiser).
Você deverá ver uma guia Código com instruções como estas:
… Ou crie um novo repositório na linha de comando
echo "# project_website" >> LEIA-ME.mdgit init
git add README.md
git commit -m "primeiro commit"
git remote add origin git @ github.com: seunomedeusuario / project_website.idiota
git push -u origin master
Copie o seguinte comando “git remote add origin” e execute-o em seu diretório de trabalho:
$ git remote add origin git @ github.com: seunomedeusuario / project_website.idiotaObservação: no seu caso, seu nome de usuário deve ser o mesmo que você usou para criar sua conta do GitHub.
No comando acima, você instruiu o Git sobre a localização do repositório remoto. O comando está dizendo ao Git que a “origem” para seu diretório de trabalho project_helloworld será “[email protected]: yourusername / project_website.idiota ”.
Agora envie seu código do branch master para a origem (repositório remoto):
$ git push origin masterContando objetos: 9, concluído.
Compressão delta usando até 4 threads.
Comprimir objetos: 100% (6/6), concluído.
Escrevendo objetos: 100% (9/9), 803 bytes | 0 bytes / s, concluído.
Total 9 (delta 2), reutilizado 0 (delta 0)
remoto: Resolvendo deltas: 100% (2/2), concluído.
Para git @ github.com: seunomedeusuario / project_website.idiota
* [novo ramo] mestre -> mestre
Se você atualizar seu navegador no GitHub, verá que o índice.arquivo html está lá em cima. Portanto, seu código é público e outros desenvolvedores podem verificar e modificar o código no repositório remoto.
Como desenvolvedor, você trabalhará com o código de outras pessoas. Portanto, vale a pena tentar verificar o código do GitHub.
Vamos para um novo diretório onde você não tem nada. No lado direito do repositório GitHub, você notará o botão “Clonar ou baixar”. Se você clicar nele, deverá fornecer um endereço SSH. Execute o seguinte comando com o endereço SSH:
$ git clone git @ github.com: seunomedeusuario / project_website.idiotaA saída deve ser semelhante a esta:
$ git clone git @ github.com: seunomedeusuario / project_website.idiotaClonando em 'project_website' ..
remoto: Contando objetos: 9, concluído.
remoto: compactando objetos: 100% (4/4), concluído.
remoto: Total 9 (delta 2), reutilizado 9 (delta 2), embalagem reutilizada 0
Recebendo objetos: 100% (9/9), concluído.
Resolvendo deltas: 100% (2/2), concluído.
Verificando a conectividade ... concluído.
Irá criar um project_website na sua pasta limpa. Se você entrar, deverá ver o índice.html do seu project_helloworld.
Então você conseguiu o seguinte:
- Criou e fez alterações em project_helloworld
- Carregou o código para GitHub em project_website
- Baixou o código do GitHub
Vamos outro arquivo do novo diretório de trabalho project_website:
$ touch ReadMe.md$ git add .
$ git commit -m "ReadMe adicionado.md "
$ git push origin master
Se você atualizar a página project_website do GitHub, deverá ver o ReadMe.arquivo md lá.
Observação: quando você baixa o código do GitHub, o diretório de trabalho conhece automaticamente a origem. Você não precisa defini-lo com o comando “git remote add origin”.
Questões:
- Por que você precisa usar repositórios remotos?
- Como você configura seu repositório local atual para se conectar ao repositório remoto?
- Como você clona repositórios remotos para o seu computador local?
Conclusão
Você pode encontrar mais informações sobre todos os comandos na documentação do Git []. Mesmo que haja ferramentas de IU do Git disponíveis, a linha de comando é a melhor maneira de dominar o Git. Isso lhe dará uma base mais sólida para o seu trabalho de desenvolvimento.
Um estudo mais aprofundado:
- https: // git-scm.com / docs
- https: // git-scm.com / book / en / v2
- https: // git-scm.com / videos