Como você cria uma ramificação Git remota?


3130

Eu criei um ramo local que eu quero 'empurrar' rio acima. Há uma pergunta semelhante aqui no Stack Overflow sobre como rastrear uma ramificação remota recém-criada.

No entanto, meu fluxo de trabalho é um pouco diferente. Primeiro , quero criar uma ramificação local e só a empurro para cima quando estiver satisfeito e quiser compartilhar minha ramificação.

  • Como eu faria isso? (minhas pesquisas no Google não pareciam ter nada).
  • Como eu diria aos meus colegas para retirá-lo do repositório upstream?

ATUALIZAÇÃO Com o Git 2.0, há uma resposta mais simples que escrevi abaixo: https://stackoverflow.com/a/27185855/109305


14
alguém já respondeu sua segunda pergunta? >> E como eu diria aos meus colegas para retirá-lo do repositório upstream?
milkplus

Possivelmente relacionado: Pro Git: 3.5 Git Branching - Remote Branches .

1
O @milkplus get fetch --allbusca as novas ramificações no lado remoto (mas apenas a get fetch --pruneexclui localmente as referências às ramificações remotas excluídas). Eu acho que, ou isso deve ser configurado por eles automaticamente, ou você precisa falar com eles verbalmente.
peterh - Restabelece Monica

Respostas:


3732

Primeiro, você cria sua filial localmente:

git checkout -b <branch-name> # Create a new branch and check it out

A ramificação remota é criada automaticamente quando você a envia para o servidor remoto. Então, quando você se sentir pronto, poderá:

git push <remote-name> <branch-name> 

Onde <remote-name>está normalmente origin, o nome que o git atribui ao controle remoto do qual você clonou. Seus colegas simplesmente puxariam esse ramo, e ele será criado automaticamente localmente.

Observe, porém, que formalmente, o formato é:

git push <remote-name> <local-branch-name>:<remote-branch-name>

Mas quando você omite um, ele assume que os dois nomes de ramificações são iguais. Dito isto, como uma palavra de cautela , não cometa o erro crítico de especificar apenas :<remote-branch-name>(com dois pontos), ou o ramo remoto será excluído!

Para que um subseqüente git pullsaiba o que fazer, você pode querer usar:

git push --set-upstream <remote-name> <local-branch-name> 

Conforme descrito abaixo, a --set-upstreamopção configura uma ramificação upstream:

Para cada ramificação atualizada ou enviada com êxito, adicione uma referência upstream (rastreamento), usada pelo git-pull (1) sem argumentos e outros comandos.


85
Observe que o comportamento padrão do git é enviar por push as referências correspondentes , portanto git push <remote>, não enviar por push se o branch não estiver presente <remote>.
Jakub Narębski 5/10/09

222
Você pode usar em git push -u <remote-name> <branch-name>vez disso, para que um subsequente git pullsaiba o que fazer.
22411 Bart

87
Em vez de especificar explicitamente o nome do servidor, você pode simplesmente usar origin, o que significa "o servidor do qual recebi o restante deste repositório": assim git push origin <branch-name>.
lambshaanxy

68
Se você esquecer de usar a -uopção, basta digitar git push -uposteriormente no ramo e, em seguida git pull, funcionará.
Jan

90
Juntar tudo, git push -u origin <local-branch-name>foi o que funcionou para mim.
Samo

881

Primeiro, você deve criar sua filial localmente

git checkout -b your_branch

Depois disso, você pode trabalhar localmente em sua filial, quando estiver pronto para compartilhar a filial, pressione-o. O próximo comando envia a ramificação para a origem do repositório remoto e a rastreia

git push -u origin your_branch

Os colegas de equipe podem alcançar seu ramo, fazendo:

git fetch
git checkout origin/your_branch

Você pode continuar trabalhando na ramificação e pressionando sempre que desejar, sem passar argumentos para o git push (o git push sem argumentos enviará o master para o master remoto, your_branch local para remote your_branch, etc ...)

git push

Os colegas de equipe podem enviar para o seu ramo fazendo confirmações e depois enviar explicitamente

... work ...
git commit
... work ...
git commit
git push origin HEAD:refs/heads/your_branch

Ou rastreando o ramo para evitar os argumentos de git push

git checkout --track -b your_branch origin/your_branch
... work ...
git commit
... work ...
git commit
git push

Existe uma maneira de criar uma ramificação remota sem criar uma ramificação local com o mesmo nome?
Ariel Gabizon

330

Solução simples Git 2.0+:

A partir do Git 2.0, o comportamento tornou-se mais simples :

Você pode configurar o git com push.default = currentpara facilitar a vida:

Eu adicionei isso agora eu posso simplesmente empurrar um novo ramo a montante com

$ git push -u

-urastreará ramificação remota com o mesmo nome. Agora, com essa configuração, você adivinhará automaticamente a referência remota ao git push. Da documentação do git.config :

push.default

Define a ação que o git push deve executar se nenhum refspec for explicitamente fornecido.

push.default = current- pressione a ramificação atual para atualizar uma ramificação com o mesmo nome na extremidade receptora. Funciona em fluxos de trabalho centrais e não centrais.

Para mim, essa é uma boa simplificação do meu fluxo de trabalho diário do Git. A definição de configuração cuida do caso de uso 'usual' em que você adiciona uma ramificação localmente e deseja criá-la remotamente. Além disso, também posso criar ramificações locais a partir de controles remotos com a mesma facilidade git co remote_branch_name(em vez de usar o --set-upstream-tosinalizador).

Sei que esta pergunta e as respostas aceitas são bastante antigas, mas o comportamento mudou, de modo que agora existem opções de configuração para simplificar o seu fluxo de trabalho.

Para adicionar à sua configuração global do Git, execute isso na linha de comando:

$ git config --global push.default current

5
Acho git push -u origin HEADque aqui respondi um pouco mais detalhado (você escreve o que está fazendo) sem precisar digitar demais. Além disso, um git push -usem argumentos adicionais não funcionou para mim se o ramo foi criado com-t
Qw3ry

git config --global push.default upstream && git checkout -b foo && <change a file> && git push -unão funciona (a partir do git 2.19.1); push requer os argumentos remote e branch.
Knite

Você poderia expandir o que você quer dizer com git co remote_branch_name?
Flannelbeard 16/09/19

84

Conforme indicado nas respostas anteriores,

git push <remote-name> <local-branch-name>:<remote-branch-name>

é suficiente para enviar uma filial local.

Seus colegas podem obter todas as ramificações remotas (incluindo novas) com este comando:

git remote update

Então, para fazer alterações na ramificação, o fluxo usual:

git checkout -b <local-branch-name> <remote-name>/<remote-branch-name>

Eu gosto dessa causa, pois permite que o nome remoto seja diferente do local
Ariel Gabizon

66

Crie uma nova ramificação localmente com base na ramificação atual:

git checkout -b newbranch

Confirme as alterações normalmente. Em seguida, empurre-o a montante:

git push -u origin HEAD

Este é um atalho para enviar a ramificação atual para uma ramificação com o mesmo nome origine rastreá-la, para que você não precise especificar origin HEADno futuro.


4
Isso ajudou no meu caso: git push -u origin HEAD. Eu acho que é a maneira mais clara.
Scadge 7/03/14

2
Sim, você nunca se lembra exatamente o que digitou como ramo, então esse é o caminho a seguir.
marksyzm

4
@marksyzm Se você não consegue se lembrar em que ramo você está ou como o nomeou, você provavelmente não deve insistir! Pelo menos, não sem correr git statusprimeiro.
Zenexer

1
Sim, tenho que garantir que o mundo não exploda nesse impulso; Concordo.
marksyzm

1
Essa é a maneira mais eficiente de criar uma ramificação de rastreamento e uma ramificação remota ao mesmo tempo. Também gostaria de adicionar git remote show origincomo um terceiro passo apenas para visualizar o novo relacionamento de rastreamento / rastreamento.
Hb5fa 12/09/16

54

Se você deseja criar uma ramificação a partir da ramificação atual

git checkout -b {your_local_branch_name} 

você quer uma ramificação de uma ramificação remota, pode tentar

git checkout -b {your_local_branch_name} origin/<remote_branch_name>

Se você concluir as alterações, poderá adicionar o arquivo.

git add -A or git add <each_file_names>

Em seguida, faça uma confirmação localmente

git commit -m 'your commit message'

Quando você deseja enviar para um repositório remoto

git push -u origin <your_local_branch_name>

Todos juntos serão

git checkout -b bug_fixes 

ou Se você deseja criar uma ramificação a partir de uma ramificação remota, diga development

origem / desenvolvimento do git checkout -b bug_fixes

Você pode enviar para a filial para repo remoto,

git push -u origin bug_fixes

Sempre que você quiser atualizar sua filial de qualquer outra filial, diga master .

git pull origin master.


46

Se você deseja apenas criar uma filial remota sem a local, você pode fazer assim:

git push origin HEAD:refs/heads/foo

Empurra o que quer que seja o seu HEAD para ramificar foo que não existia no controle remoto.


Fazer isso confundiu completamente meu Visual Studio a ponto de não inicializar corretamente. O Team Explorer não carregava nada, mas todo o resto era louco, lançando erros também. Apenas para sua informação.
27416 Josh

Parece que deveria funcionar, mas quando eu realmente tentei, o nosso servidor gitlab não reconheceu o resultado como um ramo.
Josephh

De que ramo se ramifica no controle remoto? E se eu quisesse sair do foo2? Isso é possível? Obrigado.
user674669

Também funciona no servidor gerrit, criando uma nova ramificação no controle remoto que não existia antes deste comando.
MichaelZ

33

Solução mais fácil ... Drumm Roll ... git versão 2.10.1 (Apple Git-78)

1) git checkout -b localBranchNameThatDoesNotExistInRemote

2) Do your changes, and do a git commit 

3) git push origin localBranchNameThatDoesNotExistInRemote --force

NB - A ramificação que você acabou de criar no ambiente local e a ramificação remota e inexistente na qual você está tentando enviar devem ter o mesmo nome .


3
Obrigado por sua sugestão. Mesmo que você chame isso de uma solução fácil, ainda acho que git push -ué muito mais fácil. Requer que você tenha uma linha de configuração global, consulte stackoverflow.com/a/27185855/109305 . Eu uso git push -uconstantemente, ele cobre 99% dos meus casos de uso ao trabalhar.
Jesper Rønn-Jensen

30

[Resposta rápida]

Você pode fazer isso em duas etapas:

1. Use o checkoutpara criar a ramificação local:

git checkout -b yourBranchName

2. Use o pushcomando para criar automaticamente a ramificação e enviar o código ao repositório remoto:

git push -u origin yourBanchName

Existem várias maneiras de fazer isso, mas acho que dessa maneira é realmente simples.


1
Rápido e direto ao ponto!
Dev

26

Primeiro você cria a ramificação localmente:

git checkout -b your_branch

E, em seguida, para criar a ramificação remotamente:

git push --set-upstream origin your_branch

Nota: Isso funciona nas versões mais recentes do git:

$ git --version
git version 2.3.0

Felicidades!


Este é apenas o texto de ajuda gerado pelo comando git pushquando sua ramificação local não é rastreada por um controle remoto.
Nurettin

18

Crie a filial na sua máquina local e alterne nesta filial:

$ git checkout -b [name_of_your_new_branch]

Empurre o ramo no github:

$ git push origin [name_of_your_new_branch]

Quando você deseja confirmar algo em sua ramificação, certifique-se de estar em sua ramificação.

Você pode ver todos os ramos criados usando:

$ git branch

O que mostrará:

* approval_messages
  master
  master_clean

Adicione um novo controle remoto para sua filial:

$ git remote add [name_of_your_remote] 

Envie as alterações do seu commit para o seu branch:

$ git push origin [name_of_your_remote]

Atualize sua filial quando a filial original do repositório oficial for atualizada:

$ git fetch [name_of_your_remote]

Então você precisa se inscrever para mesclar alterações, se sua ramificação for derivada do desenvolvimento, você deverá fazer:

$ git merge [name_of_your_remote]/develop

Exclua uma ramificação no seu sistema de arquivos local:

$ git branch -d [name_of_your_new_branch]

Para forçar a exclusão da ramificação local no seu sistema de arquivos:

$ git branch -D [name_of_your_new_branch]

Exclua a ramificação no github:

$ git push origin :[name_of_your_new_branch]

Aqui todas as informações

Outro projeto existente


14

Criando uma ramificação local a partir de uma ramificação existente (pode ser master / develop / any-other-branch).

git checkout -b branch_name

Envie isso para o controle remoto

git push -u remote_name local_branch_name: remote_branch_name

Aqui,

  1. -u: define o ramo upstream
  2. remote_name: o git define o nome por padrão como "origem" quando cria o repositório. No entanto, isso pode ser alterado para um nome arbitrário diferente.
  3. local_branch_name: é o nome da ramificação local a ser enviada por push.
  4. remote_branch_name: é o nome da ramificação remota que queremos criar no controle remoto.

Se removermos os nomes das filiais local e remota, ele terá o formato

git push -u remote_name branch_name

Isso enviará a ramificação local para remoto e com o mesmo nome que a ramificação local branch_name. A filial local também rastreará a filial remota.


10

Sei que esta pergunta está bem respondida, mas só queria listar as etapas que segui para criar uma nova ramificação "myNewBranch" e enviar para remoto ("origem" no meu caso) e configurar o rastreamento. Considere isso a versão "TL; DR" :)

# create new branch and checkout that branch
git checkout -b myNewBranch
# now push branch to remote 
git push origin myNewBranch
# set up the new branch to track remote branch from origin
git branch --set-upstream-to=origin/myNewBranch myNewBranch

8

Agora, com o git, você pode digitar apenas quando estiver no ramo correto

git push --set-upstream origin <remote-branch-name>

e o git cria para você o ramo de origem.


1
-u é a abreviação de --set-upstream .. portanto, o comando pode ser git push -u origin <remote-branch-name>
Exceção não capturada

fatal: 'origem' não parece ser um repositório git
Dmitry Grinko

talvez você tem que definir a origem de seu repositório git
Maurizio Brioschi

8

Só queria adicionar isso enquanto:

git checkout -b {branchName}

Cria um novo ramo, também faz check-out desse ramo / o torna seu ramo atual. Se, por algum motivo, tudo o que você deseja fazer é desativar uma ramificação, mas não torná-la sua ramificação atual, use o seguinte comando:

git branch {branchName}

No primeiro comando, "checkout" torna esse ramo seu ramo atual e o "-b" significa: esse ramo ainda não existe, portanto, faça isso por mim.


6

Como fazer através da Árvore de Origem

 1: Open SourceTree, click on Repository -> Checkout
 2 :Click on Create New Branch
 3: Select branch where from you want to get code for new branch 
 4: Give your branch name
 5: Push the branch  (by click on Push button)

5

git push -u <remote-name> <branch-name> não funcionará se o ramo recém-criado não for gerado no mesmo repositório, ou seja, se você não tiver criado o novo ramo usando git checkout -b new_branch , isso não funcionará.

Por exemplo, eu clonei dois repositórios diferentes localmente e tive que copiar o repo2 / branch1 para o repo1 / e depois enviá-lo também.

Esse link me ajudou a enviar minha filial local (clonada de outro repositório) para o repositório remoto:


3

Aqui está como você faz isso em eclipse através do Egit.

1) Acesse a visualização "Git Repository Exploring" e explore o projeto git no qual deseja criar uma ramificação. Em Ramos -> Local .. selecione o ramo para o qual você deseja criar o ramo (no meu caso, selecionei mestre. Você pode selecionar outro ramo, se desejar) .. clique com o botão direito do mouse e clique na opção Criar ramo. selecione a opção de finalização do projeto e clique no botão Concluir.

2) Agora, no explorador de projetos, selecione o projeto. Clique com o botão direito do mouse em Equipe -> Empurrar Ramificação.

Uma nova ramificação remota será criada. Você pode dar o nome da ramificação aos seus colegas para que eles possam obtê-la.


Aviso tangencial sobre o Egit - e todos os clientes baseados em JGit, AFAIK: eles não suportam atributos .gitat! Isso significa que, se sua equipe usa uma combinação de Windows (CRLF) e Linux / OSX (LF), você deve depender de cada cliente com as configurações corretas o tempo todo. Naturalmente, é melhor gerenciar as terminações de linha centralmente no nível de repo ou projeto, e .gitattributes é a maneira suportada de fazer isso. Então, se você não precisa usar o Egit ... não! :)
cweekly

2

Eu usei duas maneiras de criar ramo

Se você estiver usando o TortoiseGit, siga estas etapas: -

1.Criar Ramificação usando o TortoiseGit

Clique com o botão direito do mouse em seu projeto >>> TortoiseGit >>> Criar ramificação >>> escreva o nome da ramificação e selecione a ramificação base e pressione ok

2.Empurre o ramo

Clique com o botão direito do mouse em seu projeto >>> TortoiseGit >>> push >>> clique em ok

3.Alterar para nova ramificação

Clique com o botão direito do mouse em seu projeto >>> TortoiseGit >>> Switch / Checkout >>> selecione o ramo recém-criado e pressione ok

Se você estiver usando o prompt de comando, siga estas etapas: -

Criar uma ramificação usando o prompt de comando

$ git checkout -b new_branch_name

2.Empurre o ramo

origem do push do $ git new_branch_name

3.Mude para o novo ramo, ele já será alterado para new_branch_name, caso contrário você poderá usar

$ git checkout new_branch_name


0

Eu uso isso e é bastante útil:

git config --global alias.mkdir '!git checkout -b $1; git status; git push -u origin $1; exit;'

Uso: git mkdir NEW_BRANCH

Você nem precisa do status git; talvez, eu só quero ter certeza de que tudo está indo bem ...

Você pode ter ambas as ramificações LOCAL e REMOTE com um único comando.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.