Git Pull explicado

Resumo:

Git Pull é um comando comumente usado no Git usado para buscar e mesclar mudanças de um repositório remoto para o seu repositório local. Ele atualiza seu repositório local com as últimas alterações do repositório remoto.

Pontos chave:

1. Git Pull combina os comandos Git Breting e Git Merge em um comando conveniente.
2. É usado para buscar as últimas alterações no repositório remoto e mesclar com sua filial local.
3. O Git Pull pode ser usado para atualizar várias ramificações no seu repositório local.
4. Quando você executa o Git Pull, ele verifica se há novas alterações no repositório remoto desde a sua última atração ou busca.
5. Se houver novas alterações, o Git Pull Downloads e aplica essas alterações ao seu repositório local.
6. Git Pull mescla automaticamente as alterações com sua filial local.
7. Se houver algum conflito durante o processo de mesclagem, você precisa resolvê -los manualmente.
8. Você pode usar a origem do git comando para atualizar uma filial específica.
9. Git Pull é um comando útil para manter seu repositório local atualizado com o repositório remoto.
10. Recomenda -se executar o Git Pull regularmente para garantir que você tenha as últimas alterações.

Questões:

1. Git puxa puxe todos os galhos?

Quando você executa o Git Pull, ele atualiza a filial atual em seu repositório local com as alterações do repositório remoto. Ele não atualiza automaticamente todas as filiais no seu repositório local.

2. Como o Git Pull Work?

Git Pull combina os comandos Git buscam e mesclagem do git. Primeiro, ele busca as mudanças mais recentes do repositório remoto e depois mescla essas mudanças com sua filial local. Se houver algum conflito durante o processo de mesclagem, você precisa resolvê -los manualmente.

3. Pode git puxar atualizar uma filial específica?

Sim, você pode usar a origem do git comando para atualizar uma filial específica em seu repositório local com as alterações do repositório remoto.

4. Com que frequência devo executar o git pux?

Recomenda -se executar o Git Pull regularmente, especialmente antes de iniciar qualquer trabalho ou empurrar suas alterações no repositório remoto. Isso garante que você tenha as mudanças mais recentes e reduz as chances de conflitos.

5. O que acontece se houver conflitos durante o git pux?

Se houver conflitos durante o processo de mesclagem, o git parou e solicita que você resolva os conflitos manualmente. Você precisa editar os arquivos conflitantes, resolver os conflitos e depois cometer as mudanças.

6. Posso desfazer um puxão git?

Desfazer uma tração git pode ser um pouco complicado. Depois de retirar as mudanças do repositório remoto e mesclá -las em sua filial local, ele se torna parte do seu histórico de commit. Você pode usar o Git Revert para reverter as alterações, mas é recomendável criar um backup ou consultar sua equipe antes de executar qualquer operação de desfazer.

7. Pode git puxar sobrewrite alterações locais?

Se você fez alterações locais em um arquivo que também foi modificado no repositório remoto, o Git Pull tenta mesclar automaticamente essas mudanças. Se houver conflitos, isso o leva a resolvê -los manualmente. Por padrão, o Git Pull não substitui com força suas alterações locais sem a sua permissão.

8. Como posso verificar se minha filial local está atualizada com a filial remota?

Você pode usar o comando Git Branch para verificar se sua filial local está atualizada com a filial remota. Depois de executar o Git Pull, você pode usar o git ramo -vv para mostrar informações mais detalhadas sobre suas filiais locais e remotas.

9. Posso usar o git puxar para atualizar várias ramificações?

Sim, o Git Pull pode ser usado para atualizar várias ramificações no seu repositório local. Você pode mudar para uma filial específica e executar o git puxar para atualizar essa filial com as últimas alterações do repositório remoto.

10. É git puxar o mesmo que o git buscar?

Não, o git pull não é o mesmo que o git busca. Git Fetch apenas baixar as mudanças mais recentes do repositório remoto, mas não as mescla com sua filial local. Git Pull, por outro lado, pega as mudanças e as mescla com sua filial local.

11. Pode git ser usado para atualizar uma filial de um repositório remoto diferente?

Sim, você pode especificar o repositório remoto ao executar o comando git pull. Por exemplo, git pux Atualiza a filial especificada do repositório remoto especificado.

12. Posso executar o git puxar sem especificar um ramo?

Se você executar o Git Pull sem especificar uma filial, ele atualiza a filial atual em seu repositório local com as alterações do repositório remoto.

13. Posso usar o git puxar para atualizar uma ramificação para um compromisso específico?

Não, o Git Pull é usado principalmente para atualizar uma filial com as últimas alterações do repositório remoto. Se você deseja atualizar uma filial para uma confirmação específica, você pode usar o comando git reset.

14. Como posso evitar conflitos durante o git pux?

Para evitar conflitos durante o Git Pull, é recomendável atualizar regularmente seu repositório local com as últimas alterações do repositório remoto executando o Git Pull. Isso ajuda a manter suas filiais locais e remotas em sincronia. Também é uma boa prática se comunicar e coordenar com sua equipe para minimizar as chances de mudanças conflitantes.

15. Pode git puxar os arquivos de exclusão no meu repositório local?

Não, o git pull não exclui arquivos no seu repositório local, a menos que tenham sido excluídos no repositório remoto. Mesmo nesse caso, Git Pull tenta mesclar as mudanças e preservar suas modificações locais, se possível. No entanto, é sempre uma boa prática fazer backup do seu repositório local antes de executar qualquer operações de mesclagem.

Git Pull explicado

Correr ramo git Novamente e verifique se as filiais existem localmente:

Git puxa puxe todos os galhos

Mudanças no Git-Pull manual

1. 2.40.1 sem alterações
2. 2.40.0 03/12/23
3. 2.36.1 → 2.39.3 sem alterações
4. 2.36.0 18/04/22
5. 2.35.1 → 2.35.8 Sem alterações
6. 2.35.0 24/01/24/22
7. 2.34.1 → 2.34.8 Sem alterações
8. 2.34.0 15/11/21
9. 2.33.2 → 2.33.8 Sem alterações
10. 2.33.1 12/12/21
11. 2.33.0 16/08/21
12. 2.32.1 → 2.32.7 Sem alterações
13. 2.32.0 06/06/21
14. 2.31.1 → 2.31.8 Sem alterações
15. 2.31.0 15/03/21
16. 2.30.1 → 2.30.9 Sem alterações
17. 2.30.0 27/12/20
18. 2.29.1 → 2.29.3 sem alterações
19. 2.29.0 19/10/20
20. 2.27.1 → 2.28.1 sem alterações
21. 2.27.0 06/01/20
22. 2.25.2 → 2.26.3 sem alterações
23. 2.25.1 17/02/20
24. 2.25.0 13/01/20

Verifique sua versão do Git executando

NOME

Git -Pull – busque e integra -se com outro repositório ou uma filial local

SINOPSE

Git Pull [] [[…]]

DESCRIÇÃO

Incorpora mudanças de um repositório remoto na filial atual. Se a filial atual estiver atrás do controle remoto, então, por padrão. Se a filial atual e o controle remoto divergiram, o usuário precisar.rebase).

Mais precisamente, o git pull execuções git buscam com os parâmetros fornecidos e, dependendo das opções de configuração ou sinalizadores da linha de comando, chamarão o git rebase ou o git se fundir para reconciliar ramos divergentes.

deve ser o nome de um repositório remoto, como passado para o git-fetch [1]. pode nomear uma referência remota arbitrária (por exemplo, o nome de uma tag) ou mesmo uma coleção de árvores com ramos de rastreamento remoto correspondentes (e.g., Refs/Heads/*: Refs/Remotes/Origin/*), mas geralmente é o nome de um ramo no repositório remoto.

Valores padrão para e são lidos na configuração “remoto” e “mescla” para a filial atual, conforme definido por git-rale [1]–track .

Suponha que o histórico a seguir exista e o ramo atual seja “mestre”:

A --- B --- C Master on Origin / D --- E --- F --- G MASTER ^ ORIGEM / MASTRO EM SEU

Então “Git Pull” buscará e reproduzirá as mudanças do ramo principal remoto, pois divergiu do mestre local (i.e., E) até que seu compromisso atual (c) no topo do mestre e registre o resultado em um novo compromisso junto com os nomes dos dois pais cometidos e uma mensagem de log do usuário que descreve as alterações.

A --- B --- C Origin / Master / \ D --- e --- F --- G --- H Mestre

Veja Git-Merge [1] para obter detalhes, incluindo como os conflitos são apresentados e manuseados.

No git 1.7.0 ou posterior, para cancelar uma mesclagem conflitante, use o Git Reset -Merge . Aviso: Em versões mais antigas do git, executando Git Pull Com mudanças não comprometidas, é desencorajado: embora possível, isso deixa você em um estado que pode ser difícil de recuar no caso de um conflito.

Se alguma das alterações remotas se sobrepor com alterações não comprometidas locais, a mesclagem será cancelada automaticamente e a árvore de trabalho intocada. Geralmente, é melhor obter as mudanças locais na ordem de funcionamento antes de retirá-las ou escondê-las com o git-shark [1].

Opções

Isso é transmitido para o git-fetch subjacente ao reportagem de squelch de durante a transferência e subjacente à saída Git-Merge para despachar durante a fusão durante a fusão.

Passe –verbose para git-fetch e git-merge.

Esta opção controla se novos comprometimentos de submódulos povoados devem ser buscados e se as árvores de trabalho dos submódulos ativos também devem ser atualizados (consulte Git-Fetch [1], Git-Config [1] e Gitmodules [5]).

Se a finalização da compra for feita via rebase, os compromissos locais também serão reprimidos.

Se a atualização for feita via mesclagem, os conflitos do submódulo serão resolvidos e verificados.

Opções relacionadas à fusão

–Commit-não-comprometido

Executar a mesclagem e cometer o resultado. Esta opção pode ser usada para substituir-não-comprometer. Só útil ao se fundir.

Com-não-compromisso, execute a mesclagem e pare pouco antes de criar um compromisso de mesclagem, para dar ao usuário a chance de inspecionar e ajustar ainda mais o resultado da mescla.

Observe que as atualizações avançadas não criam uma confirmação de mescla. Assim, se você deseja garantir que sua filial não seja alterada ou atualizada pelo comando Merge, use-não.

–Edit -e – -no -edit

Invoque um editor antes de cometer uma fusão mecânica bem-sucedida para editar ainda mais a mensagem de mesclagem gerada automaticamente, para que o usuário possa explicar e justificar a mesclagem. A opção–não edit pode ser usada para aceitar a mensagem gerada automaticamente (geralmente é desencorajada).

Scripts mais antigos podem depender do comportamento histórico de não permitir que o usuário edite a mensagem de log de mesclagem. Eles verão um editor aberto quando eles executarem o Git mescla . Para facilitar o ajuste desses scripts para o comportamento atualizado, a variável de ambiente git_merge_autoedit pode ser definida como não no início deles.

Esta opção determina como a mensagem de mesclagem será limpa antes de se comprometer. Veja Git-Commit [1] para obter mais detalhes. Além disso, se for dado um valor de tesoura, a tesoura será anexada a Merge_MSG antes de ser repassada ao mecanismo de compromisso no caso de um conflito de mesclagem.

Atualizar apenas para o novo histórico se não houver história local divergente. Este é o padrão quando nenhum método para conciliar histórias divergentes é fornecido (via –rebase =* sinalizadores).

Ao se fundir em vez de se rebasar, especifica como uma mesclagem é tratada quando a história mesclada já é um descendente da história atual. Se a fusão for solicitada, –ff é o padrão, a menos que a fusão de uma tag anotada (e possivelmente assinada) que não seja armazenada em seu lugar natural nos árbitros/ tags/ hierarquia, nesse caso-não-ff é assumido.

Com –ff, quando possível, resolva a mescla. Quando não é possível (quando a história mesclada não for descendente da história atual), crie um commit de mesclagem.

Com–no-ff, crie uma confirmação de mesclagem em todos os casos, mesmo quando a mescla.

-S []–GPG-SIGN [=]–no-gpg-sign

GPG-SIGN A COMITE DE MERGE DE. O argumento KeyId é opcional e padroniza a identidade do compromisso; Se especificado, deve ser preso à opção sem um espaço. –não-gpg-sinal é útil para contrariar ambos.Variável de configuração GPGSIGN, e anteriormente–GPG-SIGN .

Além dos nomes de ramifica. Veja também Git-FMT-Merge-MSG [1]. Só útil ao se fundir.

Com-não-log, não liste as descrições de uma linha das comprometimentos reais sendo mesclados.

–Signoff-Não-Signoff

Adicione um trailer assinado por The Comitter no final da mensagem de log do Commit. O significado de uma geração depende do projeto para o qual você’está cometendo. Por exemplo, pode certificar que o componente tem os direitos de enviar o trabalho sob o projeto’S Licença ou concorda com alguma representação de colaboradores, como um Certificado de Origem do Desenvolvedor. (Ver http: // desenvolvecertificate.org para o usado pelo kernel Linux e projetos Git.) Consulte a documentação ou liderança do projeto para o qual você’estar contribuindo para entender como as linhas são usadas nesse projeto.

A opção -no-signoff pode ser usada para contrariar uma opção anterior-signoff na linha de comando.

–stat -n – -no -stat

Mostre um diferente no final da mesclagem. O Diffstat também é controlado pela opção de configuração mescla.Estado.

Com -n ou – -não -stat não mostra um Diffstat no final da mesclagem.

–Squash-Não-squash

Produza a árvore que trabalha e o estado de índice como se uma mesclagem real tivesse acontecido (exceto as informações de mesclagem), mas na verdade não se comprometeu, mova a cabeça ou grave $ git_dir/merge_head (para causar o próximo comando Git Commit para criar um compromisso de mesclagem). Isso permite que você crie um único compromisso no topo do ramo atual cujo efeito é o mesmo que fusão de outro ramo (ou mais em caso de polvo).

Com-no-squash executar a mesclagem e cometer o resultado. Esta opção pode ser usada para substituir -Squash.

Com – -squash, – -comprometer não é permitido e falhará.

Só útil ao se fundir.

Por padrão, os ganchos de pré-fusão e comprometimento são executados. Quando–não-verify é dado, estes são ignorados. Veja também Githooks [5]. Só útil ao se fundir.

Use a estratégia de mesclagem fornecida; pode ser fornecido mais de uma vez para especificá -los na ordem em que deveriam ser julgados. Se não houver opção -s, uma lista interna de estratégias é usada (ORT ao mesclar uma única cabeça, polvo de outra forma).

Passe a opção específica da estratégia de mesclagem até a estratégia de mesclagem.

Verifique se a confirmação da dica do ramo lateral que está sendo mesclada está assinada com uma chave válida, i.e. Uma chave que possui um UID válido: no modelo de confiança padrão, isso significa que a chave de assinatura foi assinada por uma chave confiável. Se o comprometimento da dica do ramo lateral não for assinado com uma chave válida, a mesclagem será abortada.

Só útil ao se fundir.

–Resumo-Não-vencimento

Sinônimos para–stat e –no-stat; estes são depreciados e serão removidos no futuro.

Crie automaticamente uma entrada temporária de esconderijo antes do início da operação, grave -a no ref Merge_autosh e aplique -a após o término da operação terminar. Isso significa que você pode executar a operação em um trabalho sujo. No entanto, use com cuidado: a aplicação final do Stash após uma mesclagem bem-sucedida pode resultar em conflitos não triviais.

Por padrão, o comando Git Merge se recusa a mesclar histórias que não compartilham um ancestral comum. Esta opção pode ser usada para substituir essa segurança ao mesclar histórias de dois projetos que começaram suas vidas de forma independente. Como essa é uma ocasião muito rara, nenhuma variável de configuração para permitir isso por padrão existe e não será adicionada.

Só útil ao se fundir.

-r –rebase [= false | true | mescla | interativo]

Quando é verdade, refaça o ramo atual no topo da filial a montante depois de buscar. Se houver um ramo de rastreamento remoto correspondente ao ramo a montante e o ramo a montante foi rebocado desde a última vez que o rebase usa essas informações para evitar mudanças não locais de rebanho.

Quando definido como fusão, Rebase usando o Git Rebase-Rebase-Merges para que os comissões de mesclagem local sejam incluídos no Rebase (consulte Git-Rebase [1] para obter detalhes).

Quando falsa, mescla a ramificação a montante na filial atual.

Quando interativo, ative o modo interativo de rebase.

Veja puxar.Rebase, filial..Rebase e ramo.AUTOSETUPREBASE em Git-Config [1] Se você quiser fazer o git puxar sempre usar-REBASE em vez de mesclar.

Isso é abreviado para –rebase = false.

Opções relacionadas à busca

Buscar todos os controles remotos.

Anexar nomes de ref e nomes de objetos de referências buscadas ao conteúdo existente de .git/fetch_head . Sem esta opção dados antigos em .git/fetch_head será substituído.

Use uma transação atômica para atualizar árbitros locais. Todos os referidos são atualizados ou por erro, nenhum refs é atualizado.

Limite a busca no número especificado de começos da ponta de cada história da ramificação remota. Se buscar um raso repositório criado por clone git com–depth = option (consulte Git-clone [1]), aprofundar ou encurtar a história para o número especificado de commits. Tags para os comprometimentos aprofundados não são buscados.

Semelhante a -profundidade, exceto que especifica o número de commits a partir do limite raso atual, em vez de da ponta de cada histórico de ramificação remota.

Aprofundar ou encurtar a história de um repositório superficial para incluir todas .

Aprofundar ou encurtar a história de um repositório raso para excluir os compromissos alcançáveis ​​de uma filial ou tag remota especificada. Esta opção pode ser especificada várias vezes.

Se o repositório de origem estiver completo, converta um repositório raso em um completo, removendo todas as limitações impostas por repositórios rasos.

Se o repositório de origem for superficial, busque o máximo possível para que o repositório atual tenha o mesmo histórico que o repositório de origem.

–Update-Shallow

Por padrão ao buscar um repositório raso, o git busca recusa refs que requerem atualização .git/raso. Esta opção é atualizada .git/raso e aceite tais árbitros.

Por padrão, o Git relatará, ao servidor, compromete-se de todos os árbitros locais para encontrar compromissos comuns na tentativa de reduzir o tamanho do arquivo de Pack Packfile a ser recebido. Se especificado, o Git relatará apenas cometidos acessíveis a partir das dicas fornecidas. Isso é útil para acelerar as busca quando o usuário sabe qual árbitro local provavelmente terá compromissos em comum com o referência a montante sendo buscada.

Esta opção pode ser especificada mais de uma vez; Nesse caso, o git relatará os compromissos alcançáveis ​​de qualquer um dos compromissos fornecidos.

O argumento dessa opção pode ser um globo em nomes de ref, um ref, ou o (possivelmente abreviado) sha-1 de um compromisso. Especificar um glob é equivalente a especificar esta opção várias vezes, uma para cada nome de referência correspondente.

Veja também a busca.Negociação e empurrar.Negocie as variáveis ​​de configuração documentadas no Git-Config [1], e a opção–negotiada abaixo.

–apenas negociar

Não busque nada do servidor e imprima os ancestrais dos argumentos fornecidos-negociação-tip =*, que temos em comum com o servidor.

Isso é incompatível com–recurse-submodules = [sim | sob demanda] . Internamente, isso é usado para implementar o empurrão.Negociar opção, consulte o Git-Config [1].

Mostre o que seria feito, sem fazer mudanças.

Quando git busca é usado com: RefSpec, ele pode se recusar a atualizar a filial local, conforme discutido na parte da documentação Git-Fetch [1]. Esta opção substitui esse cheque.

Mantenha o pacote baixado.

Modifique o RefSpec configurado para colocar todos os refs no Reces/ Prefetch/ Namespace. Veja a tarefa de pré-busca na manutenção do git [1].

Antes de buscar, remova quaisquer referências de rastreamento remoto que não existam mais no controle remoto. As tags não estão sujeitas a poda se forem buscadas apenas por causa da tag padrão de seguir ou devido a uma opção-Tags. No entanto, se as tags forem buscadas devido a um refSpec explícito (na linha de comando ou na configuração remota, por exemplo, se o controle remoto foi clonado com a opção – -Mirror), elas também estarão sujeitas a poda para podar. Fornecimento-Prine-Tags é uma abreviação para fornecer a tag RefSpec.

Por padrão, tags esse ponto em objetos que são baixados do repositório remoto são buscados e armazenados localmente. Esta opção desativa esta tag automática seguinte. O comportamento padrão para um controle remoto pode ser especificado com o controle remoto..Configuração do Tagopt. Veja Git-Config [1].

Ao buscar refs listados na linha de comando, use o refSpec especificado (pode ser dado mais de uma vez) para mapear os árbitros para ramificações de rastreamento remoto, em vez dos valores de remoto.*.buscar variáveis ​​de configuração para o repositório remoto. Fornecer um vazio à opção –Refmap faz com que o Git ignore os refSpecs configurados e confie inteiramente nos refspecs fornecidos como argumentos da linha de comando. Consulte a seção em “Filiais de rastreamento remoto configurados” para obter detalhes.

Pegue todas as tags do controle remoto (i.e., buscar tags remotas refs/tags/* em tags locais com o mesmo nome), além de tudo o que mais seria buscado. O uso dessa opção sozinho não sujeita as tags de poda, mesmo que -Prine seja usado (embora as tags possam ser podadas de qualquer maneira se também forem o destino de um refSpec explícito; veja –prune).

Número de crianças paralelas a serem usadas para todas as formas de busca.

Se a opção -Multiple foi especificada, os diferentes controles remotos serão buscados em paralelo. Se vários submódulos forem buscados, eles serão buscados em paralelo. Para controlá -los de forma independente, use as configurações de configuração buscar.paralelo e submódulo.FetchJobs (ver Git-Config [1]).

Normalmente, as buscas paralelas recursivas e multi-remetentes serão mais rápidas. Por padrão, as buscas são realizadas sequencialmente, não em paralelo.

–configuração de configuração

Se o controle remoto for buscado com sucesso, adicione a referência a montante (rastreamento), usada por Git-Pull sem argumento [1] e outros comandos. Para mais informações, consulte a filial..mesclar e ramificar..Remoto no Git-Config [1].

Quando dados, e o repositório para buscar é tratado por Git Fetch-Pack, –EXEC = é passado para o comando para especificar o caminho não padrão para o comando executado do outro lado.

O status de progresso é relatado no fluxo de erro padrão por padrão quando está conectado a um terminal, a menos que -q seja especificado. Esta bandeira força o status de progresso, mesmo que o fluxo de erro padrão não seja direcionado para um terminal.

Transmitir a sequência fornecida ao servidor ao se comunicar usando o protocolo versão 2. A string dada não deve conter um caractere nu ou LF. O servidor’S Manipulação de opções de servidor, incluindo as desconhecidas, é específico do servidor. Quando múltiplos-Server-opção = são dados, todos são enviados para o outro lado da ordem listada na linha de comando.

Por padrão, o Git verifica se uma filial é atualizada durante a busca. Isso pode ser desativado através da busca.ShowforcedUpdates, mas a opção–Show Forceddates garante que essa verificação ocorra. Veja Git-Config [1].

Por padrão, o Git verifica se uma filial é atualizada durante a busca. Passe-não-show-forceddates ou define uma busca.Showforcedupdates para false para pular esta verificação por razões de desempenho. Se usado durante Git-Pull A opção–FLY ainda verificará as atualizações forçadas antes de tentar uma atualização rápida. Veja Git-Config [1].

Use apenas endereços IPv4, ignorando endereços IPv6.

Use apenas endereços IPv6, ignorando endereços IPv4.

O repositório “remoto” que é a fonte de uma operação de busca ou puxão. Este parâmetro pode ser um URL (consulte os URLs do git da seção abaixo) ou o nome de um controle remoto (consulte a seção controlados abaixo).

Especifica quais refs buscam e quais refs locais para atualizar. Quando nenhum aparece na linha de comando, os árbitros para buscar são lidos no controle remoto..Busca variáveis ​​(consulte a seção “Filiais de rastreamento remoto configurados” em Git-Fetch [1]).

O formato de um parâmetro é um plus + opcional, seguido pela fonte, seguido por um cólon :, seguido pelo referência de destino . O cólon pode ser omitido quando está vazio. é normalmente um ref, mas também pode ser um nome de objeto hexadecimal totalmente escrito.

A pode conter um * em seu para indicar uma correspondência de padrão simples. Tal funções RefSpec, como um glob que corresponde a qualquer árbitro com o mesmo prefixo. Um padrão deve ter um * em e . Ele mapeará refs para o destino substituindo o * pelo conteúdo correspondente da fonte.

Se um refSpec for prefixado por ^, ele será interpretado como um refSpec negativo. Em vez de especificar quais árbitros buscarem ou quais árbitros locais atualizam, esse refSpec especificará refs para excluir. Um REF será considerado para corresponder se corresponder a pelo menos um RefSpec positivo e não corresponder a nenhum refSpec negativo. RefSpecs negativos podem ser úteis para restringir o escopo de um padrão refSpec, para que não inclua refs específicos. RefSpecs negativos podem ser o padrão refspecs. No entanto, eles podem conter apenas um e não especificar um . Totalmente soletrados nomes de objetos hexadecimais também não são suportados.

tag significa o mesmo que refs/tags/: refs/tags/; Solicita buscar tudo até a tag fornecida.

O referência remoto que corresponde é buscado e, se não for uma corda vazia, é feita uma tentativa de atualizar o árbitro local que combina.

Se essa atualização é permitida sem -force depende do espaço de nome de ref’está sendo buscado, o tipo de objeto sendo buscado e se a atualização é considerada uma avançada rápida. Geralmente, as mesmas regras se aplicam a buscar ao empurrar, veja o . Seção de Git-Push [1] para o que esses são. Exceções a essas regras específicas para git busca são observados abaixo.

Até o Git versão 2.20, e diferentemente ao empurrar com o git-push [1], quaisquer atualizações para refs/tags/* seriam aceitas sem + no refSpec (ou-force). Ao buscar, consideramos promiscuamente todas as atualizações de tags de um controle remoto a serem forçadas a buscar. Desde o Git versão 2.20, buscando atualizar refs/tags/* funciona da mesma maneira que ao empurrar. EU.e. Quaisquer atualizações serão rejeitadas sem + no RefSpec (ou -Force).

Ao contrário do empurrão com o Git-Push [1], qualquer atualização fora do Ref’s trocando e.g. um objeto de árvore para uma bolha, ou um compromisso para outro compromisso que’s não’T tem o compromisso anterior como ancestral etc.

Ao contrário de ao empurrar com Git-Push [1], não há configuração que’altera essas regras, e nada como um gancho de pré-busca análogo ao gancho pré-recebido.

Como em empurrar com Git-Push [1], todas as regras descritas acima sobre o que’S não é permitido como uma atualização pode ser substituído adicionando um líder opcional + a uma opção de linha de comando refSeC (ou usando -force). A única exceção a isso é que nenhuma quantidade de força fará com que os árbitros/cabeças/* namespace aceitem um objeto que não seja de compromisso.

Git Pull explicado

Git Pull é um comando git usado para atualizar a versão local de um repositório de um controle remoto.

É um dos quatro comandos que leva a interação da rede por Git. Por padrão, Git Pull faz duas coisas.

1. Atualiza o ramo de trabalho local atual (atualmente checado a filial)
2. Atualiza as galhos de rastreamento remoto para todas as outras filiais.

Git Pull Fetches (git Fetch) Os novos compromissos e mesclagem (Git mesclar) isso na sua filial local.

Este comando’S Sintaxe é a seguinte:

# Formato geral Git Pull Options Repository RefSpec # Pull de git específico Git Pull Nome Remote Name Name Nome

• Opções são as opções de comando, como –quiet ou –verbose . Você pode ler mais sobre as diferentes opções na documentação do Git
• REPOSITÓRIO é o URL para o seu repo. Exemplo: https: // github.com/Freecodecamp/Freecodecamp.git
• RefSpec Especifica quais refs buscam e quais refs locais para atualizar
• Nome remoto é o nome do seu repositório remoto. Por exemplo: origem.
• Nome do ramo é o nome do seu ramo. Por exemplo: desenvolver.

Observação

Se você tiver alterações não comprometidas, a parte de mescla.

Assim você deveria Sempre comprometa suas mudanças em um ramo antes de puxar Novos começos de um repositório remoto.

Índice

• Usando o git pull
• Controle de versão distribuída
• Git Fetch + Git Merge
• Git Pull in Ides

Usando o git pull

Use Git Pull para atualizar um repositório local do repositório remoto correspondente. Ex: Enquanto trabalha localmente no mestre, execute o git puxão para atualizar a cópia local do mestre e atualizar as outras filiais de rastreamento remoto. (Mais informações sobre filiais de rastreamento remoto na próxima seção.)

Mas, há algumas coisas a ter em mente para que esse exemplo seja verdadeiro:

O repositório local tem um repositório remoto vinculado

• Verifique isso executando o git remoto -v
• Se houver vários controles remotos, o Git Pull pode não ser informações suficientes. Pode ser necessário entrar no git puxar origem ou git puxar a montante .

A filial para a qual você está checado tem uma filial de rastreamento remoto correspondente

• Verifique isso executando o status Git . Se não houver uma filial de rastreamento remoto, Git não’Saiba onde puxar informações de.

Controle de versão distribuída

Git é um Sistema de controle de versão distribuída (DVCs). Com os DVCs, os desenvolvedores podem estar trabalhando no mesmo arquivo ao mesmo tempo em ambientes separados. Depois empurrando Código até o repositório remoto compartilhado, outros desenvolvedores podem puxar código alterado.

Interações de rede no Git

Existem apenas quatro comandos que provocam interações de rede no Git. Um repositório local não tem consciência das mudanças feitas no repositório remoto até que haja um pedido de informação. E, um repositório remoto não tem consciência das mudanças locais até que os compromissos sejam empurrados.

Os quatro comandos de rede são:

• clone git
• git busca
• Git Pull
• git push

Ramificações em DVCs

Ao trabalhar com o Git, pode parecer que há muitas cópias do mesmo código flutuando em todo o lugar. Existem diferentes versões do mesmo arquivo em cada ramo. E cópias diferentes dos mesmos ramos em todos os desenvolvedores’s computador e no controle remoto. Para acompanhar isso, Git usa algo chamado ramificações de rastreamento remoto.

Se você executar o git ramo -todos dentro de um repositório Git, os ramos de rastreamento remoto aparecem em vermelho. Essas são cópias somente leitura do código, como aparece no controle remoto. (Quando foi a última interação da rede que teria trazido informações localmente? Lembre -se de quando essas informações foram atualizadas pela última vez. As informações nos ramos de rastreamento remoto refletem as informações dessa interação.)

Com ramificações de rastreamento remoto, Você pode trabalhar em Git em várias filiais sem interação de rede. Toda vez que você executa os comandos Git Pull ou Git Fetch, você atualiza ramificações de rastreamento remoto.

Git Fetch Plus Git Merge

Git Pull é um comando combinado, igual a Git Fetch + Git Merge .

git busca

Por si só, o Git busca atualizações de todas as filiais de rastreamento remoto no repositório local. Nenhuma alteração é realmente refletida em nenhum dos ramos locais de trabalho.

Merge do Git

Sem nenhum argumento, o Git Merge mesclará a filial de rastreamento remoto correspondente para a filial de trabalho local.

Git Pull

Git busca atualizações de ramificações de rastreamento remoto. O Git Merge atualiza a filial atual com a filial de rastreamento remoto correspondente. Usando o Git Pull, você recebe as duas partes dessas atualizações. Mas, isso significa que, se você for check -out para apresentar a filial e executar o git pux. Sempre que você faz o check -out para outro ramo que pode ter novas alterações, é’é sempre uma boa ideia executar o git pux .

Git Pull in Ides

Linguagem comum em outros IDEs pode não incluir a palavra puxar . Se você cuidar das palavras, git puxe, mas não’T vejo, procure a palavra sincroniza em vez disso.

buscando um PR remoto (solicitação de tração) para repositório local

Para fins de revisão e tal, os PRs no controle remoto devem ser buscados no repositório local. Você pode usar o comando git buscam o seguinte para conseguir isso.

Git Fetch Origin Pull/Id/Head: Nome do ramo

ID é o ID da solicitação de tração e o nome do ramo é o nome do ramo que você deseja criar. Depois que a filial for criada, você poderá usar o checkout git para mudar para aquele brach.

Outros recursos no git você pode gostar:

• Mesclar Git e Git Rebase
• Checkout git
• Git Commit
• Git Stash
• Ramo git

Como puxar todos os galhos em Git

Git é um sistema de controle de versão que permite aos usuários manter várias linhas de desenvolvimento, i.e., ramificações, em um único projeto. Quando você começa a trabalhar em um projeto e deseja clonar o repositório para uma máquina local, o Git permite recuperar galhos individuais ou todas.

Neste tutorial, você aprenderá a puxar todos os galhos no Git.

• Git instalado (veja como instalar o Git no Ubuntu, MacOS, Windows, Centos 7 ou CentOS 8).
• Um repositório git.

Puxando todos os galhos no git

As filiais Git podem ser armazenadas em um repositório remoto ou local. Quando você deseja trabalhar em um recurso de uma filial armazenada em um repositório remoto, você deve baixá -lo para o repositório local primeiro.

Os dois comandos git usados ​​para baixar conteúdo de um repositório remoto são puxadores git e git busca :

• git busca é a versão mais segura de Git Pull . Ele baixará o conteúdo remoto sem atualizar o estado de trabalho do repositório local, o que significa que seu trabalho permanece intacto.
• Git Pull é mais agressivo porque baixa o conteúdo do repositório remoto e executa a fusão Git no ramo ativo local. A mesclagem cria um novo comprometimento de mesclagem e integra o conteúdo com seu trabalho. No entanto, a fusão de conteúdo como esse pode causar conflitos com o trabalho em andamento e pode exigir resolução manual.

As seções abaixo mostram como puxar todas as filiais Git para um repositório local usando os dois comandos.

Método de busca git

Com git busca , Você pode baixar metadados do repositório remoto sem afetar seu trabalho local. É uma opção útil quando você deseja verificar se outro desenvolvedor fez alguma alteração no repositório remoto. git busca também é usado ao clonar um repositório e baixar os dados para uma máquina local.

O git busca O comando recupera as atualizações mais recentes do repositório remoto. Dependendo se você deseja baixar metadados para ramos individuais ou todas as filiais, o comando tem as seguintes variações:

git busca

• O comando busca apenas o ramo especificado do repositório remoto.

git busca -tudo

• Um comando é considerado um movimento de poder, pois busca todos os controles remotos registrados e seus ramos.

Para este tutorial, clonaremos um novo repositório e buscaremos todos os ramos associados. Siga os passos abaixo:

1. Abra um prompt de comando bash git no Windows ou abra uma nova janela de terminal no Linux (Ctrl+Alt+T) ou macOS.

2. Navegue até o diretório onde deseja armazenar os arquivos do repositório. Use o comando CD para alterar o diretório.

3. No Github, localize o repositório remoto que você deseja clonar e clique no <> Código botão. Por exemplo, clonaremos. A plataforma BMC Github Actions permite automatizar tarefas em seu repositório Git.

4. No menu suspenso, selecione a opção de segurança que você deseja usar para o Git e Copie o URL. Neste tutorial, usaremos HTTPs, pois é o mais fácil de configurar. Se você quiser uma opção mais segura, vá com SSH.

5. Em Git Bash, clone o repositório remoto usando o clone git comando e o URL que você copiou. A sintaxe é:

clone git

6. Depois de clonar o repositório, verifique as filiais disponíveis nos repositórios locais e remotos. Para verificar as filiais locais, execute:

ramo git

Verifique as filiais remotamente disponíveis em execução:

ramo git -r

Apenas o desenvolver A filial está disponível no repositório local, o que significa que precisamos buscar os restantes.

7. Busque os metadados para galhos remotos e comece a rastreá -los. Correr:

git busca -tudo

O –todos Flag diz a Git para buscar os metadados para todos os ramos do repositório.

8. Depois de buscar os metadados, comece a rastrear as filiais com este comando:

Ramo Git -R | grep -v '\ ->' | sed "s, \ x1b \ [[0-9;]*[a-za-z] ,, g" | enquanto lido remoto; Do Git Branch - -track "$" "$ remoto"; feito

O comando configura os ramos no repositório local e os faz rastrear seus colegas no repositório remoto.

Correr ramo git Novamente e verifique se as filiais existem localmente:

No exemplo acima, vemos que todos os ramos do repositório remoto agora existem no local também.

Observação: Leia nossa comparação de ssh e https para git.

Método Git Pull

O Git Pull Método é uma combinação de git busca e Merge do Git . O comando recupera metadados do ramo do repositório remoto e atualiza sua cópia de trabalho local para refletir as alterações.

Observação: O Git Pull O método funciona melhor em um repositório existente, onde você deseja que as alterações implementadas por outros desenvolvedores reflitam em seu repositório local. Clonando um repositório e depois executando Git Pull não produziria resultado, pois tudo já está atualizado.

Siga as etapas abaixo para puxar todos os galhos remotos:

1. Abra uma janela Git Bash e altere o local para o repositório local.

2. Execute o comando a seguir para garantir que o GIT comece a rastrear todas as filiais remotas, incluindo as que não existem em sua cópia local:

Ramo Git -R | grep -v '\ ->' | sed "s, \ x1b \ [[0-9;]*[a-za-z] ,, g" | enquanto lido remoto; Do Git Branch - -track "$" "$ remoto"; feito

7. Puxe todos os galhos do repositório Remote Git:

Git Pull -tudo

A saída mostra que todos os ramos remotos foram puxados com sucesso e exibe as mudanças.

Este tutorial mostrou como puxar todos os galhos de um repositório remoto para sua cópia de trabalho local. Existem dois métodos disponíveis – git busca e Git Pull , cada um adequado para seu próprio caso de uso.

Saiba mais sobre o Git em nosso guia para iniciantes do Git ou baixe uma prática comandos git e salve -o para uso futuro.

Git: puxe todos os galhos

Git permite manter várias linhas de desenvolvimento separadas para um projeto. Essas linhas de desenvolvimento são chamadas de ramos. Você pode recuperar a versão mais recente de uma filial de um repositório remoto de forma independente ou pode recuperar a versão mais recente de todas as filiais de uma só vez.

Neste guia, falamos sobre como usar o comando git buscando – tudo e git – todos para recuperar mudanças de um repositório remoto.

O que é ramificação?

Deixar&rsquo;s Diga que estamos trabalhando em um site de blog. Nós&rsquo;Vou adicionar um recurso ao blog que permite que os usuários comentem. Nós Don&rsquo;quero que esse recurso faça parte da versão principal do nosso projeto, porque ainda estamos trabalhando nisso.

Encontre sua partida de bootcamp

• Carma Karma combina com você com o TEP TECH BOOTCAMPS
• Acesse bolsas exclusivas e cursos de preparação

Selecione seu interesse
Primeiro nome

Sobrenome

E-mail

Número de telefone

Ao continuar, você concorda com nossos Termos de Serviço e Política de Privacidade e concorda em receber ofertas e oportunidades do carma de carreira por telefone, mensagem de texto e email.

Podemos usar um ramo git para isso. Podemos criar um ramo chamado &ldquo;comentários&rdquo; Para armazenar todo o código para o nosso recurso de comentar. Isso nos permitirá trabalhar em nosso recurso de comentar sem alterar a versão principal da nossa base de código que é implantada em um site.

Filas podem ser armazenadas localmente ou remotamente. Se você estiver trabalhando em uma versão local de um projeto, uma filial será local. Filiais remotas são armazenadas com a versão principal de um projeto.

Git: busque todos os ramos

Nós&rsquo;está trabalhando em um projeto chamado blog-site. Este projeto contém duas filiais: Origin Master e Origin Dev.

O ramo de dev contém todos os recursos experimentais com os quais estamos trabalhando. Achamos que outro colaborador levou mudanças para ambas as ramificações. Queremos ter certeza e recuperar os metadados para qualquer alteração, se tiverem sido feitos.

Podemos fazer isso usando o comando busca. O comando Fetch diz ao Git para recuperar metadados de uma filial remota nas últimas atualizações. O comando Fetch não atualiza os arquivos armazenados em uma versão local de um repositório.

Para rastrear todos os galhos remotos e buscar os metadados para esses ramos, podemos usar o comando git busca com a bandeira –Al:

Este comando retorna:

Buscar origem remota: enumerando objetos: 5, feito. Remoto: Counting Objects: 100% (5/5), feito. Remoto: Total 3 (Delta 0), reutilizado 0 (delta 0), Rezimento de embalagem 0 Depatando objetos: 100% (3/3), Concluído. De https: // github.com/carreira-karma-tutorials/blog-site 3FCEA0C..da74d68 dev -> origem/dev

O comando buscador buscou todas as mudanças que nós&rsquo;Fiz para o nosso repositório remoto. O comando Fetch sabe que nosso ramo de dev remoto contém alterações que não temos em nossa máquina local. Acabamos de recuperar os metadados para aqueles que.

Podemos recuperar os metadados para uma filial individual usando o comando Git Fetch Origin.

Git: puxe todos os galhos

E se você quiser atualizar sua cópia de trabalho local e recuperar metadados? Que&rsquo;s onde o comando git pux é útil.

“Carma de carreira entrou na minha vida quando eu precisava mais e rapidamente me ajudou a combinar com um bootcamp. Dois meses depois de me formar, achei o emprego dos meus sonhos que se alinhava com meus valores e objetivos na vida!”

Vênus, engenheiro de software da Rockbot

Encontre sua partida de bootcamp

Agora sabemos que as mudanças foram feitas em nosso repositório. Estamos felizes em fundir essas mudanças com nosso repositório local. Para baixar as alterações em nossa máquina local, precisamos usar o comando git pull:

Nós&rsquo;Usei a bandeira –Al para indicar que queremos recuperar alterações de cada ramo. Nosso comando retorna:

Buscar origem remota: enumerando objetos: 5, feito. Remoto: Counting Objects: 100% (5/5), feito. Remoto: Total 3 (Delta 0), reutilizado 0 (delta 0), Rezimento de embalagem 0 Depatando objetos: 100% (3/3), Concluído. De https: // github.com/carreira-karma-tutorials/blog-site 3FCEA0C..DA74D68 Dev -> Origin/Dev atualizando 3FCEA0C..DA74D68 Readme avançado rápido.md | 1 + 1 arquivo alterado, 1 inserção ( +)

O comando git pull primeiro executa um comando git busca para verificar se há alterações. A operação de busca retorna os metadados para nossos compromissos . Em seguida, o comando git pull recupera todas as mudanças que fizemos em nosso repositório remoto e altera nossos arquivos locais.

Podemos ver o ReadMe.O arquivo md foi alterado em nosso repositório remoto. Agora que nós&rsquo;Execute uma operação de tração, temos a mudança em nossa máquina local.

Para recuperar o código de uma filial, poderíamos usar o comando Git Pull Origin.

Conclusão

O comando git busca – todos recupera metadados em cada alteração feita para todos os ramos de um repositório. O comando git – todo o comando baixar todas as alterações feitas em todas as ramificações em sua máquina local.
Agora você tem o conhecimento de que você precisa para puxar todos os galhos do Git como um profissional !

Sobre nós: O Career Karma é uma plataforma projetada para ajudar os candidatos a emprego a encontrar, pesquisar e se conectar com programas de treinamento de emprego para avançar suas carreiras. Aprenda sobre a publicação CK.

Qual é o próximo?

James Gallagher

Sobre o autor: James Gallagher é um programador autodidata e o gerente de conteúdo técnico da Career Karma. Ele tem experiência em gama de linguagens de programação e ampla experiência em Python, HTML, CSS e JavaScript. James escreveu centenas de tutoriais de programação e freqüentemente contribui para publicações como Codecademy, Treehouse, Repl.Afrotech e outros.

Artigos relacionados

• Git Pull
• Erro: Falha ao empurrar alguns árbitros para remoto
• Git: listar ramificações remotas
• Desfazer Git Pull: um guia
• Git: puxe todos os galhos

• Reinicialização do Git para o resgate
• Git Pull Solicy: Como criar uma solicitação de tração
• Git Fetch: um guia passo a passo
• Como usar a mesclagem git
• Pick Cherry Git: um guia passo a passo