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

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.

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

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

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>

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.

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.

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.

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 .

[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.

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!

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

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.

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

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.

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.

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)

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:

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.

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

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.