¿Cómo puedo insertar una nueva sucursal local en un repositorio remoto de Git y también rastrearla?


4307

Quiero poder hacer lo siguiente:

  1. Cree una sucursal local basada en alguna otra sucursal (remota o local) (a través de git brancho git checkout -b)

  2. Empuje la rama local al repositorio remoto (publicar), pero hágalo rastreable git pully git pushfuncionará de inmediato.

¿Cómo puedo hacer eso?

Lo sé --set-upstreamen Git 1.7, pero esa es una acción posterior a la creación. Quiero encontrar una manera de hacer un cambio similar al empujar la rama al repositorio remoto.



72
solo para señalar que - up-upstream es -u
Baiyan Huang

@BaiyanHuang gracias por señalar eso. Inicial pensé que -u significaba sin seguimiento, lo que no tenía sentido para mí
Dmitry

Respuestas:


6613

En Git 1.7.0 y posterior, puedes pagar una nueva rama:

git checkout -b <branch>

Edite archivos, agregue y confirme. Luego presione con la-u--set-upstream opción (abreviatura de ) :

git push -u origin <branch>

Git configurará la información de seguimiento durante el envío.


81
También vale la pena señalar que si tiene una rama de seguimiento existente ya establecida en la rama que está presionando, y push.defaultestá configurada en upstream, esto no hará lo que cree que hará. Intentará superar la rama de seguimiento existente. Uso: git push -u origin mynewfeature:mynewfeatureo hacer git branch --unset-upstreamprimero.
void.pointer

13
Para las personas que usan Git de Visual Studio: En realidad, esto es lo que hace "Publicar rama" en Visual Studio. Después de ejecutar git push con el parámetro -u finalmente puedo ver mi rama como se publicó en VS UI.
Puterdo Borato

3
¿Es git push -u origin <branch> lo mismo que git push -u origin HEAD (suponiendo que tenga la rama que desea extraer?)
gymbrall

13
¿Necesitamos la -uopción cada vez que empujamos la rama a su control remoto o solo la necesitamos la primera vez?
Stephane

17
@Stephane Solo necesita -uuna vez para iniciar el seguimiento. Después solo usegit push
Todd

491

Si no está compartiendo su repositorio con otros, esto es útil para enviar todas sus sucursales al control remoto y realizar un --set-upstreamseguimiento correcto para usted:

git push --all -u

(No es exactamente lo que pedía el OP, pero esta frase es bastante popular)

Si está compartiendo su repositorio con otros, esta no es una buena forma, ya que obstruirá el repositorio con todas sus ramas experimentales poco fiables.


14
y lo git pull --allretira todo a otra parte? kewl
commonpike

1
Este comando configura el seguimiento a la rama correcta sin la necesidad de empujar nada. Gracias.
amey91

45
Git permite comprometer una rama y no empujarla por muy buenas razones. Solo usar git push --todos es como soltar una pieza de arquitectura git. Si funciona para ti, está perfectamente bien, genial, hazlo para siempre. Pero POR FAVOR, no recomiende a otros que eviten aprender git solo porque es una forma rápida de hacer las cosas.
Federico Razzoli

44
Esta realmente no es la respuesta correcta y no es una buena herramienta para recomendar sin una explicación real de lo que hace y cuáles son las implicaciones. Por favor considere tomar esta respuesta.
akronymn

3
@Federico @akronymn ¿Dónde se pueden encontrar los peligros de hacer git push --all -u?
user1823664

155

Antes de la introducción de git push -u, no había git pushopción para obtener lo que desea. Tuvo que agregar nuevas declaraciones de configuración.

Si crea una nueva rama usando:

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

Puede usar el git configcomando para evitar editar directamente el .git/configarchivo.

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

O puede editar manualmente el .git/configarchivo que tenía información de seguimiento para esta rama.

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

44
a veces necesitas estogit push origin -u local_branch:remote_branch
Bruce Lee

127

En pocas palabras, para crear una nueva sucursal local , haga:

git branch <branch-name>

Para enviarlo al repositorio remoto , haga lo siguiente:

git push -u origin <branch-name>

17
git branch <branch-name>y git checkout -b <branch-name>ambos crean una bifurcación, pero el proceso de pago cambia a la nueva bifurcación
Robert

1
El soporte tipo es solo para mencionar que debes reemplazarlo con el nombre de la rama que quieras crear y presionar.
piyushmandovra

es una rama inexistente en remoto, y rechazar consrc branch-name does not match any
Adi Prasetyo

96

Una ligera variación de las soluciones ya dadas aquí:

  1. Cree una rama local basada en alguna otra rama (remota o local):

    git checkout -b branchname
    
  2. Empuje la rama local al repositorio remoto (publicar), pero hágalo rastreable git pully git pushfuncionará de inmediato

    git push -u origin HEAD
    

    Usar HEADes una "forma práctica de empujar la rama actual al mismo nombre en el control remoto". Fuente: https://git-scm.com/docs/git-push En términos de Git, HEAD (en mayúsculas) es una referencia a la parte superior de la rama actual (árbol).

    La -uopción es solo la abreviatura de --set-upstream. Esto agregará una referencia de seguimiento ascendente para la rama actual. puede verificar esto buscando en su archivo .git / config:

    Ingrese la descripción de la imagen aquí


2
Gracias :) git push -u origin <branch-name>no funcionaba para mí, pero usarlo en HEADlugar de <branch-name>funcionar perfectamente :)
Daniel Tonon

57

Yo simplemente hago

git push -u origin localBranch:remoteBranchToBeCreated

sobre un proyecto ya clonado.

Git crea una nueva rama nombrada remoteBranchToBeCreatedbajo mis commits que hice localBranch.

Editar : esto cambia de su rama local actual (posiblemente llamado localBranch) aguas arriba a origin/remoteBranchToBeCreated. Para arreglar eso, simplemente escriba:

git branch --set-upstream-to=origin/localBranch

Entonces su sucursal local actual ahora rastrea origin/localBranch.


1
Esto es exactamente lo que estaba buscando activamente
eli

Git lanza error: src refspec <new branch> does not match any.cuando intento esto.
codeforester

1
Esta debería ser la mejor respuesta.
Aditya Abhas

30

Supongo que ya has clonado un proyecto como:

git clone http://github.com/myproject.git
  1. Luego, en su copia local, cree una nueva sucursal y compruébelo:

    git checkout -b <newbranch>
    
  2. Suponiendo que creó un "git bare --init" en su servidor y creó el myapp.git, debe:

    git remote add origin ssh://example.com/var/git/myapp.git
    git push origin master
    
  3. Después de eso, los usuarios deberían poder

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

NOTA: Supongo que tiene su servidor en funcionamiento. Si no es así, no funcionará. Un buen tutorial está aquí .

ADICIONAL

Agregar una rama remota:

git push origin master:new_feature_name

Comprueba si todo está bien (busca el origen y enumera las ramas remotas):

git fetch origin
git branch -r

Cree una sucursal local y rastree la sucursal remota:

git checkout -tb new_feature_name origin/new_feature_name

Actualiza todo:

git pull

1
El guión de William con el que me vinculé hace casi lo mismo con la opción adicional de eliminar ramas remotas y algunas salvaguardas, también
Tobias Kienzler

1
> para empujar la rama local al repositorio remoto (publicar), pero hacerla> rastreable para que git pull y git push funcionen de inmediato. es lo que github hace automáticamente cuando empujas tu código a su repositorio :-)
VP.

1
Esto no responde a la pregunta, el <newbranch> del repositorio original no se puede rastrear (y se renombra como <master> es el nuevo repositorio que clonas en el paso 3).
Lohrun

1
Parece un poco exagerado. ¿ git remote add originhace que la sucursal local sea rastreable? ¿Es ese el comando de teclado aquí?
Roni Yaniv

3
@Roni Yaniv: no git remote add originsolo registra un nuevo repositorio remoto. Es solo un paso necesario antes de llevar su sucursal a ese repositorio remoto (si no desea escribir la dirección completa cada vez)
Lohrun

23

editar Desfasado, solo usegit push -u origin $BRANCHNAME


Úselo git publish-branchde las diversas herramientas Git de William ( repositorio y clon gitorios ).

OK, no Ruby, entonces, ¡ignorando las salvaguardas! - tome las últimas tres líneas del guión y cree un guión bash git-publish-branch:

#!/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}

Luego git-publish-branch REMOTENAME BRANCHNAME, ejecute , donde REMOTENAME suele ser el origen (puede modificar el script para que tenga su origen como predeterminado, etc.)


1
Esto supone que tengo instalado Ruby. No hay tanta suerte. alguna otra idea?
Roni Yaniv

2
el script ruby ​​llama git pushy git configordena. Usé el código del script para editar mi respuesta. Puede usar esta información para crear un pequeño script de shell que lo empuje por usted.
Lohrun

1
Las diversas herramientas de git de William parecen haberse movido (ese enlace ahora está muerto). Un enlace de trabajo es: gitorious.org/willgit
Mike D

1
Enlace de "William" roto de nuevo; nuevo enlace parece ser git-wt-commit.rubyforge.org
ScottJ

22

Para crear una nueva rama ramificándose desde una rama existente

git checkout -b <new_branch>

y luego empuje esta nueva rama al repositorio usando

git push -u origin <new_branch>

Esto crea y empuja todos los commits locales a una rama remota recién creada origin/<new_branch>


12

Para la versión de GitLab anterior a 1.7, use:

git checkout -b name_branch

(name_branch, ex: master)

Para enviarlo al repositorio remoto, haga lo siguiente:

git push -u origin name_new_branch

(name_new_branch, ejemplo: feature)


9

Hice un alias para que cada vez que cree una nueva rama, empuje y rastree la rama remota en consecuencia. Puse el siguiente fragmento en el .bash_profilearchivo:

# 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 : simplemente escriba gcb thuy/do-sth-koolcon thuy/do-sth-koolmi nuevo nombre de sucursal.


4

Basándome ligeramente en las respuestas aquí, he terminado este proceso como un simple script Bash, que por supuesto podría usarse también como un alias de Git.

La adición importante para mí es que esto me lleva a ejecutar pruebas unitarias antes de confirmar y pasa el nombre de la sucursal actual de forma predeterminada.

$ 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

2

Puedes hacerlo en 2 pasos:

1. Use checkoutpara crear la rama local:

git checkout -b yourBranchName

Trabaja con tu sucursal como quieras.

2. Use el pushcomando para crear automáticamente la rama y enviar el código al repositorio remoto:

git push -u origin yourBanchName

Hay varias formas de hacer esto, pero creo que esta forma es realmente simple.


0

Para mayor flexibilidad, puede usar un comando Git personalizado . Por ejemplo, cree el siguiente script de Python en algún lugar $PATHdebajo del nombre git-publishy hágalo ejecutable:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Luego git publish -hle mostrará información de uso:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.