Como você cria um branch remoto do Git?

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

No entanto, meu stream de trabalho é um pouco diferente. Primeiro , quero criar uma ramificação local e só vou empurrá-la para cima quando estiver satisfeito e quiser compartilhar minha ramificação.

  • Como eu faria isso? (minhas pesquisas no google não parecem ter nada).
  • Como eu diria aos meus colegas para retirá-lo do repository upstream?

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

Primeiro, você cria sua filial localmente:

 git checkout -b  # 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 para isso, você pode apenas fazer:

 git push   

Onde é tipicamente origin , o nome que o git dá ao controle remoto do qual você foi clonado. Seus colegas, então, apenas puxariam essa ramificação e ela é criada automaticamente localmente.

Note no entanto que formalmente, o formato é:

 git push  : 

Mas quando você omite um, ele assume que ambos os nomes de ramificação são os mesmos. Dito isto, como uma palavra de caucanvas , não cometa o erro crítico de especificar apenas : (com os dois pontos), ou a ramificação remota será excluída!

Para que um git pull subsequente saiba o que fazer, você pode querer usar:

 git push --set-upstream   

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

Para cada ramificação que esteja atualizada ou enviada com sucesso, inclua referência de upstream (rastreamento), usada por git-pull (1) sem argumentos e outros comandos.

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 o ramo, enviá-lo. O próximo comando envia a ramificação para a origem do repository remoto e a rastreia

 git push -u origin your_branch 

Os colegas de equipe podem entrar em contato com sua filial, fazendo:

 git fetch git checkout origin/your_branch 

Você pode continuar trabalhando no ramo e empurrando sempre que quiser sem passar argumentos para o git push (o git push sem argumentos pressionará o master para o master remoto, your_branch local para o remote your_branch, etc …)

 git push 

Os colegas de equipe podem empurrar para o seu ramo fazendo commits e depois empurrar explicitamente

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

Ou rastrear o ramo para evitar os argumentos para empurrar

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

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 = current para facilitar a vida:

Eu adicionei isso agora eu posso apenas empurrar uma nova filial para cima com

 $ git push -u 

-u irá rastrear ramificação remota de mesmo nome. Não, com esta configuração você irá adivinhar automaticamente a referência remota para 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 – empurra a ramificação atual para atualizar uma ramificação com o mesmo nome na extremidade de recebimento. Funciona em streams de trabalho centrais e não centrais.

Para mim, esta é uma boa simplificação do meu stream de trabalho do Git do dia-a-dia. A definição de configuração cuida do caso de uso ‘usual’ em que você adiciona um branch localmente e deseja criá-lo remotamente. Além disso, posso facilmente criar ramificações locais a partir de controles remotos apenas fazendo git co remote_branch_name (em vez de usar --set-upstream-to flag).

Eu conheço essa pergunta e as respostas aceitas são bastante antigas, mas o comportamento mudou, de modo que agora existem opções de configuração para tornar seu stream de trabalho mais simples.

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

 $ git config --global push.default current 

Como afirmado nas respostas anteriores,

 git push  : 

é suficiente para empurrar um ramo local.

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

 git remote update 

Então, para fazer mudanças no ramo, o stream usual:

 git checkout -b  / 

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

 git checkout -b newbranch 

Confirme as alterações como faria normalmente. Então, empurre-o para cima:

 git push -u origin HEAD 

Este é um atalho para enviar a ramificação atual para uma ramificação do mesmo nome na origin e rastreá-la para que você não precise especificar a origin HEAD no futuro.

Se você quer apenas criar um branch remoto sem ter o local, você pode fazer assim:

 git push origin HEAD:refs/heads/foo 

Ele empurra o que quer que seja seu CABEÇA para ramificar o foo que não existia no controle remoto.

Se você quiser criar um ramo a partir do ramo atual

 git checkout -b {your_local_branch_name} 

você quer um ramo de um ramo remoto, você pode tentar

 git checkout -b {your_local_branch_name} origin/ 

Se você terminou de fazer alterações, pode adicionar o arquivo.

 git add -A or git add  

Então faça um commit localmente

 git commit -m 'your commit message' 

Quando você quer empurrar para repo remoto

 git push -u origin  

Todos juntos serão

 git checkout -b bug_fixes 

ou se você quiser criar um ramo de um ramo remoto, diga desenvolvimento

git checkout -b bug_fixes origem / desenvolvimento

Você pode empurrar para o ramo para repo remoto por

 git push -u origin **bug_fixes** 

Sempre que você quiser atualizar sua filial de qualquer outro ramo, diga mestre .

git pull origin master .

Primeiro você cria o ramo localmente:

 git checkout -b your_branch 

E então para criar a filial 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!

Crie a ramificação em sua máquina local e alterne nesta ramificação:

 $ git checkout -b [name_of_your_new_branch] 

Empurre o ramo no github:

 $ git push origin [name_of_your_new_branch] 

Quando você quiser comprometer algo em seu ramo, certifique-se de estar em seu ramo.

Você pode ver todos os ramos criados usando:

 $ git branch 

Que mostrará:

 * approval_messages master master_clean 

Adicione um novo controle remoto ao seu ramo:

 $ 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 ramificação original do repository oficial for atualizada:

 $ git fetch [name_of_your_remote] 

Então você precisa aplicar para mesclar as alterações, se sua filial é derivada de desenvolver você precisa fazer:

 $ git merge [name_of_your_remote]/develop 

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

 $ git branch -d [name_of_your_new_branch] 

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

 $ git branch -D [name_of_your_new_branch] 

Exclua o ramo no github:

 $ git push origin :[name_of_your_new_branch] 

Aqui todas as informações

Outro projeto existente

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 go a git commit 3) git push origin localBranchNameThatDoesNotExistInRemote --force 

Nota: A ramificação que você acabou de criar em seu ambiente local e a ramificação remota não existente em que você está tentando enviar deve ter o mesmo nome .

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

git push --set-upstream origin >

e git criar para você o ramo de origem.

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

git checkout -b branch_name

Empurre isto para remoto

git push -u remote_name local_branch_name: remote_branch_name

Aqui,

  1. -u: define o ramo do upstream
  2. remote_name: git define o nome por padrão para ser “origin” quando cria o repository. Isso pode, no entanto, ser alterado para um nome arbitrário diferente.
  3. local_branch_name: é o nome da ramificação local a ser pressionada.
  4. remote_branch_name: é o nome do ramo remoto que queremos que seja criado no remoto.

Se removermos os nomes das ramificações locais e remotas, ele terá o formato

git push -u remote_name branch_name

Isso fará com que a ramificação local seja remota e com o mesmo nome da ramificação local branch_name. O ramo local também rastreará o ramo remoto.

Eu sei que esta pergunta é bem respondida, mas só queria listar as etapas que eu tomo para criar uma nova filial “myNewBranch” e empurrar 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 

Só queria adicionar isso enquanto:

 git checkout -b {branchName} 

Cria um novo branch, ele também verifica esse branch / faz dele o seu branch atual. Se, por algum motivo, tudo o que você deseja fazer é extrair uma ramificação, mas não torná-la sua ramificação atual, use o seguinte comando:

 git branch {branchName} 

No primeiro comando, “checkout” faz com que o ramo seja o seu branch atual, e o “-b” significa: este branch ainda não existe, então faça isso por mim.

Como fazer através da tree 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) 

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

1) Vá para a visualização “Git Repository Exploring” e explique o projeto git no qual você deseja criar um branch. Em Brances -> Local .. selecione o ramo para o qual você deseja criar o ramo (No meu caso eu selecionei master .. você pode selecionar outro outro ramo, se desejar) .. então clique direito e clique em Criar opção Branch .. e selecione a opção checkout this project e, em seguida, clique no botão finish.

2) Agora, a partir do explorador do projeto, selecione o projeto. Clique com o botão direito do mouse em Team -> Push Branch.

Um novo ramo remoto será criado. Você pode dar o nome do ramo aos seus colegas para que eles possam puxá-lo.

git push -u não funciona se a ramificação recém-criada não for gerada do mesmo repository, ou seja, se você não criou a nova ramificação usando git checkout -b new_branch , isso não funcionará.

Por exemplo, eu tinha clonado dois repositorys diferentes localmente e eu tive que copiar repo2 / branch1 para repo1 / e, em seguida, empurrá-lo também.

Este link me ajudou a empurrar meu branch local (clonado de outro repository) para o meu repository remoto: