Porque muitos têm usado o trabalho recente com base em Git desenvolvimento, que exige a compreensão em profundidade de Git funciona, anterior Git Basics falhou para atender a demanda, e, portanto, escreveu este Git artigo avançado é a introdução de algumas das pessoas geralmente encontram, mas raramente conhecer o Git conhecimento e Git alguns trabalhos internos. Normalmente, usamos Git um monte de ação só pode se lembrar de um termo, ou um comando que, não sei Git porque, para escrever este artigo é para deixar todo mundo para Git aplicações ainda mais acessível.
Depois de ler este artigo você vai aprender o seguinte Git:
✦ Por Git
Visão geral Uso ✦ Git Básico
Diferença ✦ check-out, merge, rebase, reset, reverter a
✦ fluxo GIT
ganchos ✦ Git
✦ Git submódulo
✦ Git funcionamento interno
Por Git
controle de versão centralizado
Por exemplo, nós usamos SVN, controle de versão que o maior inconveniente é o ponto único de falha de um servidor central, uma vez que o servidor central vai para baixo, todos os desenvolvedores são incapazes de atualizar o código para funcionar corretamente, se o centro do disco está danificado e não reside de dados de backup, versão dos dados serão perdidos para sempre.
sistemas de controle de versão distribuído
O cliente não apenas extrair um instantâneo da versão mais recente do arquivo, mas irá completar todo o repositório de código espelhamento puxado para baixo, a maneira como as informações são armazenadas em uma lista svn alteração de arquivo, tais sistemas irá poupar-lhes a informação como um conjunto de documentos básicos e todos os arquivos ao longo do tempo acumulado progressivamente diferença.
Visão geral Uso Git Básico
submissão Git e processo de sincronização
mudanças Git undo
Git comandos mais usados
caixa, inversa, de reset, alteração de base, de intercalação
1. check-out
Aqui vamos discutir o funcionamento do git checkout ramo detecção, quando executamos git checkout <branchname> operação, na verdade, o princípio é o ponteiro aponta cabeça para ser verificados para fora neste ramo.
Bifurcação situação:
Quando desenvolvemos simultaneamente em vários ramos, ramos diferentes têm diferentes cometer registro, situação assim não haverá bifurcada.
Neste ponto temos de co-desenvolver vários ramos integradas ao ramo principal, que é nas operações git merge. Como mostrado, o ramo a montante depois que tinha diferenças com nossa filial, desta vez, execute o comando é realmente mesclar o conteúdo do C, D apresentou uma fusão, em seguida, tal como apresentado.
2. Go merge
3. git rebase <branchname>
operação de mesclagem é um C, D são combinados em um commit , se não quer fazer, pode ser operação de rebase usado. Como o nome sugere, é rebase para mudar a base do seu (entendimento pessoal), rebase é atualmente dividida serão enviados diretamente para forçosamente movido para a parte de trás de um outro ramo.
4. git reset
CABEÇA operação de reposição de ponteiro é alterada de C para D, que é apresentada depois do início da linha a partir da parte traseira B, C torna-se um estado livre.
5. revert git
operação relativamente reset, revert relativamente mais seguro, uma vez que não descarta o tom C, mas uma cópia de B após C como B'.
fluxo git
Git fluxo de trabalho, principalmente para permitir que desenvolvedores para desenvolver um padrão unificado na colaborativo, processo unificado, reduzir a carga de trabalho extra.
Simplesmente significa que nós certas coisas no processo de desenvolvimento para usar um ramo específico, se você pensar sobre o desenvolvimento, teste, altere o bug, solte tudo feito no mesmo ramo, desta vez para o gerente de projeto escolher o que ele quer enviar a fusão é como problemático coisa em muitos ramos. fluxo git é resolver tais problemas.
fluxo Git haverá dois ramos de longa duração:
mestre: para registro oficial trilha liberação
desenvolver de: Integração Branch, desenvolver novas funcionalidades para o controle de gravação
Há também algum outro ramo temporária:
Metragens (ramos novo recurso): derivadas do desenvolvimento ramo ramo, quando você precisa adicionar uma nova funções de tempo disponíveis neste ramo, após a conclusão dos novos recursos, funcionalidade e desenvolver a fusão de ir.
Release (ramo release): usado para desenvolver o recurso ramos fundir.
Mantaince (ramo hotfix): bug linha correção ramo, o ramo diretamente derivado do fora radiação, fusão e desenvolver após a conclusão do branch master para cima.
Release (ramo release): usado para desenvolver o recurso ramos fundir.
Mantaince (ramo hotfix): bug linha correção ramo, derivado diretamente do maser ramo,
Após a conclusão da fusão e para dominar desenvolver diferente ramo.
ramos azuis no mapa é mestre, é roxo desenvolver, o vermelho é a correcção, laranja é uma característica, o verde é a liberação
Git fluxo de etapas de desenvolvimento
1. Crie desenvolver ramo
git branch desenvolver
git push origin -u desenvolver
2. Caixa Iniciar desenvolver ramo
git checkout -b desenvolver origem / desenvolver
3. Criar um novo ramo de recurso baseado em desenvolver
git checkout recurso -b / my-recurso desenvolver
4. ramo de mesclagem
origem git pull desenvolver
git checkout desenvolver
recurso de mala git / my-recurso
git push
git branchn recurso -d / my-recurso
A versão online é liberado
a. Criar ramo realse pronto para liberar a partir do ramo desenvolver
git checkout liberação-1.0.0 -b desenvolver
git push
b. Coloque desenvolver ramo em realse
c. para jogar tag. realse é um mestre evoluir para um dos ramos do tampão, sempre de origem necessita de ser incorporado na etiqueta o mestre
git tag -a 1.0.0-release -m "primeira versão" master
--tags git push
6. correções de bugs online
No código apresentado ao mestre na linha após o início do projeto, desta vez como enviar código de linha correção de bug?
a. Criar um ramo hotfix git checkout -b issue- # 001 mestre
b. correção de bug
c. para completar a reparação incorporada no mestre
d. Marcação
e. desenvolver para mesclar
git ganchos (gancho)
ganchos Git são alguns scripts podem ser a qualquer momento no armazém automaticamente executar esses scripts são interceptores semelhantes que podem executar alguns eventos específicos antes e depois das operações de prazo git.
Ao inicializar um armazém, irá gerar automaticamente .example sob .git / ganchos arquivos sufixo diretório, que é ganchos, ganchos git para prevenir estes execução padrão, mais o sufixo .example para executar esses ganchos simplesmente .example sufixo removido.
Ganchos em ganchos e o servidor local.
ganchos Locais:
pré-compromisso
preparar-commit-msg
comprometer-msg
post-commit
Estes são no processo de alguns cometem ganchos.
pós-checkout
pré-rebase
Estes dois ganchos são usados para fazer alguma operação extra ou algumas verificações de segurança.
pré ganchos prefixo para a adição de uma operação adicional, ganchos pós prefixo servir para notificação.
Apresentação do caso:
A montagem de um gancho preparar-commit-msg.
Primeiro, nós primeiro .git / sufixo preparar-commit-msg.example sob o diretório ganchos removido.
Então nós usamos para abrir o arquivo para edição, que é um script shell, também podemos usar python ou Ruby tal linguagem para ganchos de escrita.
Salvar e sair, os ganchos são acionados após a adição de msg quando a operação de confirmação.
Comprometemo-nos a realizar a operação.
Pode ser visto nos ganchos do programa foi executado .
Mais destes ganchos são ganchos locais, e alguns ganchos são adicionados ao repositório remoto, que é um ganchos do lado do servidor.
pré-receber: git impulso desencadeia operação execução
actualização: Após cada accionador de emissão
pós receber: empurrar o gatilho depois do sucesso de
git submódulo
No trabalho que, muitas vezes encontramos tal situação um: queremos introduzir excepções a um projeto no projeto atual, pode haver uma biblioteca, mas se adicionado diretamente a este projecto, temos de assegurar que cada armazém contidas neste biblioteca, ou implantar muito difícil, cada vez que neste projeto ou casos de fusão da biblioteca vai fazer uma ação personalizada a montante incrivelmente difícil. Se pudermos usar esses clones da biblioteca para os seus próprios projectos, e mantenha esta biblioteca para enviar independente seria perfeito. git sub-módulo é para resolver este problema.
Em seguida, vamos mostrar-lhe como ser dividida em sub-projectos em mais de um projeto para o desenvolvimento.
Em primeiro lugar, queremos acrescentar sub-módulo pró-serviço em nosso projeto principal no pro-main
endereço armazém pró-main: [email protected]: CodeNerverEnd / pró-main.git
pró-service endereço do armazém: [email protected]: CodeNerverEnd / pró-service.git
Primeiro, nosso Senhor clonagem projeto para baixo,
Em seguida, adicionando submodule no artigo principal,
Use o suplemento de comando git submódulo [email protected]: CodeNerverEnd / pró-service.git
Podemos ver o seguinte diretório no armazém
mais um arquivo .gitmodules, abra o arquivo para ver o caminho para salvar o sub-módulo, se você não quer sub-módulo no caminho principal repositório do projeto, um caminho onde você pode alterar o caminho desejado.
Nós adicionamos um sub-módulo dos principais projectos apresentados para o repositório remoto, todos os desenvolvedores podem usar esta biblioteca, aqui vamos dar uma olhada em outros desenvolvedores como usá-lo.
Primeiro, outros desenvolvedores podem clonar o projeto com sub-módulo, podemos usar o seguinte comando:
git clone --recursive [email protected]: CodeNerverEnd / pró-main.git
Se clonar quando não há aumento --recursive, padrão não é o conteúdo do sub-módulo de clone para baixo, você só pode ver a pasta de arquivo em um sub-módulo do projeto, mas o que está dentro está vazio.
Agora, se os desenvolvedores precisam para atualização sub-módulo, execute o seguinte comando:
--remote atualização submodule git
Neste momento, se o desenvolvedor deseja codificar o programa principal, ao mesmo tempo, no sub-módulo de código, execute os seguintes passos
1. Vá para um diretório submodule detecção ramo
estável git checkout
2.merge sub-módulo
atualização submodule git --remote --merge
3. Se outros fizeram mudanças no upstream, precisamos incorporar
git submódulo --remote --rebase
4. Queremos localmente mudando para melhor após o lançamento mudanças sub-módulo
git push --recurse-submódulos = ondemand
Para Git está em causa, estes não são suficientes para descrevê-lo está longe de ser abrangente. Eu vou no próximo espaço, continuam a apresentar-lhe Git avançado.
