git - uteis - ver lista de branches




Como você cria um branch remoto do Git? (12)

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 repositório 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

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 fluxo 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 repositório upstream?

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


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 fluxos de trabalho centrais e não centrais.

Para mim, esta é uma boa simplificação do meu fluxo 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 fluxo 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

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.


Como afirmado nas respostas anteriores,

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

é 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 fluxo usual:

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

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 repositório. 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.


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.


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!


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

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

Onde <remote-name> é 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 <remote-name> <local-branch-name>:<remote-branch-name>

Mas quando você omite um, ele assume que ambos os nomes de ramificação são os mesmos. Dito isto, como uma palavra de cautela , não cometa o erro crítico de especificar apenas :<remote-branch-name> (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 <remote-name> <local-branch-name> 

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.


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.


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.


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 .


git push -u <remote-name> <branch-name> não funciona se a ramificação recém-criada não for gerada do mesmo repositório, 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 repositórios diferentes localmente e eu tive que copiar repo2 / branch1 para repo1 / e, em seguida, empurrá-lo também.

This link me ajudou a empurrar meu branch local (clonado de outro repositório) para o meu repositório remoto:





git-branch