Se não está a partilhar o seu acordo com outros, isto é útil para empurrar todos os seus ramos para o remoto, e --set-upstream rastrear correctamente para si:

git push --all -u

(não é exactamente o que a OP estava a pedir, mas este transatlântico é muito popular)

Se você está compartilhando seu repo com outros esta não é realmente boa forma como você vai entupir o repo com todos os seus ramos experimentais duvidosos.

Antes da introdução de git push -u, não havia opção git push para obter o que deseja. Teve de adicionar novas instruções de configuração.

Se criar um novo ramo usando:

$ git checkout -b branchB
$ git push origin branchB:branchB

Pode usar o comando git config para evitar editar directamente o ficheiro .git/config.

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

Ou pode editar manualmente o ficheiro .git/config para ter informação de seguimento neste ramo.

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB

Simplificando, para criar um novoLocal , Faça:

git branch <branch-name>

Para o empurrar para o repositório remoto, Faça:

git push -u origin <branch-name>

UMA ligeira variação das soluções já apresentadas:

1. Criar um ramo local baseado noutro ramo (remoto ou local):

   git checkout -b branchname
   

2. Empurre o ramo local para o repositório remoto (publique), mas torne-o localizável para que git pull e git push funcionem imediatamente

   git push -u origin HEAD
   

   Usar HEAD é uma "forma útil de empurrar o ramo actual para o mesmo nome no remoto". Fonte: https://git-scm.com/docs/git-push Em termos gerais, maiúsculas) é uma referência ao topo do ramo atual (árvore).

   A opção -u é muito curta para --set-setupstream. Isto irá adicionar uma referência de rastreamento upstream para o ramo atual. você pode verificar isso olhando no seu .ficheiro git/config:

   

git clone http://github.com/myproject.git

1. Depois, na sua cópia local, crie um novo ramo e confira:

   git checkout -b <newbranch>
   

2. Supondo que fez um "GIT bare --init" no seu servidor e criou o myapp.git, devias:

   git remote add origin ssh://example.com/var/git/myapp.git
   git push origin master
   

3. Depois disso, os utilizadores devem ser capazes de

   git clone http://example.com/var/git/myapp.git
   

Nota: presumo que tenha o seu servidor a funcionar. Se não for, não vai funcionar. A bom how-to is here .

Adicionado

Adicionar um ramo remoto:

git push origin master:new_feature_name

Verifique se está tudo bem (obter a origem e listar os ramos remotos):

git fetch origin
git branch -r

Criar um ramo local e seguir o ramo remoto:

git checkout -tb new_feature_name origin/new_feature_name

Actualiza tudo:

git pull

Eu simplesmente faço

git push -u origin localBranch:remoteBranchToBeCreated

O Git cria um novo ramo chamado remoteBranchToBeCreated sob os meus commits que fiz em localBranch.

Editar desactualizado, basta usar git push -u origin $BRANCHNAME

Utilizar git publish-branch das ferramentas Git diversas do William (Gitorious repo e clone ).

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Depois executar git-publish-branch REMOTENAME BRANCHNAME, onde o REMOTENAME é normalmente de origem (poderá modificar o programa para tomar a origem por omissão, etc...)

Para criar um novo ramo, ramificando - se do ramo existente

git checkout -b <new_branch>

E depois empurrar esta nova ramificação para o repositório usando

git push -u origin <new_branch>

Isto cria e empurra todos os commits locais para um ramo remoto recentemente criado origin/<new_branch>

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Uso : basta escrever gcb thuy/do-sth-kool com thuy/do-sth-kool é o meu novo nome do ramo.

Para a versão do GitLab antes de 1, 7, utilizar:

git checkout -b name_branch

(name_branch, ex :master)

Para o enviar para o repositório remoto, faça:

git push -u origin name_new_branch

(name_new_branch, exemplo: funcionalidade)

Baseando-me ligeiramente nas respostas aqui, concluí este processo como um simples script Bash, que pode, naturalmente, ser usado como um nome falso Git também.

A adição importante para mim é que isso me leva a executar testes de unidade antes de cometer e passar no nome do ramo atual por padrão.

$ git_push_new_branch.sh

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

Git_push_new_branch.sh

function show_help()
{
  IT=$(CAT <<EOF

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

  )
  echo "$IT"
  exit
}

if [ -z "$1" ]
then
  show_help
fi

CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi

git push -u origin $BRANCH

Para enviar a sua sucursal local de um repositório público, você precisa cd para o repositório público e, em seguida, usar o seguinte código:

git push -u origin branchname