¿Cómo se crea una rama remota de Git?

3130

Creé una sucursal local que quiero 'empujar' corriente arriba. Hay una pregunta similar aquí en Stack Overflow sobre cómo rastrear una rama remota recién creada.

Sin embargo, mi flujo de trabajo es ligeramente diferente. Primero quiero crear una sucursal local, y solo la impulsaré en sentido ascendente cuando esté satisfecho y quiera compartir mi sucursal.

  • ¿Como podría hacerlo? (mis búsquedas en google no parecían tener nada).
  • ¿Cómo les diría a mis colegas que lo extraigan del repositorio ascendente?

ACTUALIZACIÓN Con Git 2.0 hay una respuesta más simple que he escrito a continuación: https://stackoverflow.com/a/27185855/109305

Jesper Rønn-Jensen
fuente
14
¿Alguien alguna vez respondió su segunda pregunta? >> ¿Y cómo les diría a mis colegas que lo saquen del repositorio ascendente?
milkplus
Posiblemente relacionado: Pro Git: 3.5 Git Branching - Ramas remotas .
1
@milkplus get fetch --allobtiene las nuevas ramas en el lado remoto (pero solo get fetch --pruneelimina localmente las referencias a las ramas remotas eliminadas). Creo que esto debería ser configurado por ellos automáticamente, o tienes que hablarles verbalmente.
peterh - Restablece a Monica el

Respuestas:

3732

Primero, crea su sucursal localmente:

git checkout -b <branch-name> # Create a new branch and check it out

La rama remota se crea automáticamente cuando la empuja al servidor remoto. Entonces, cuando te sientas listo para ello, puedes hacer lo siguiente:

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

Donde <remote-name>suele ser origin, el nombre que git le da al control remoto desde el que clonó. Sus colegas simplemente extraerían esa rama, y ​​se creará automáticamente localmente.

Sin embargo, tenga en cuenta que formalmente, el formato es:

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

Pero cuando omite uno, supone que ambos nombres de rama son iguales. Dicho esto, como advertencia , no cometa el error crítico de especificar solo :<remote-branch-name>(con los dos puntos), ¡o la rama remota se eliminará!

Para que un subsiguiente git pullsepa qué hacer, es posible que desee utilizar:

git push --set-upstream <remote-name> <local-branch-name> 

Como se describe a continuación, la --set-upstreamopción configura una rama ascendente:

Para cada rama que esté actualizada o que se haya enviado correctamente, agregue una referencia ascendente (seguimiento), utilizada por git-pull (1) sin argumentos y otros comandos.

Ikke
fuente
85
Tenga en cuenta que el comportamiento predeterminado de git es empujar referencias coincidentes , por git push <remote>lo que no empujaría la rama si no está presente <remote>.
Jakub Narębski el
222
Es posible que desee utilizar git push -u <remote-name> <branch-name>en su lugar, para que un posterior git pullsepa qué hacer.
Bart Schuller
87
En lugar de especificar explícitamente el nombre del servidor, simplemente puede usar origin, lo que significa "el servidor del que obtuve el resto de este repositorio": por lo tanto git push origin <branch-name>.
lambshaanxy
68
Si olvida usar la -uopción, puede escribir git push -uluego en la rama, y ​​luego git pullfuncionará.
Jan
90
Poner todo junto, git push -u origin <local-branch-name>es lo que funcionó para mí.
Samo
881

Primero, debes crear tu sucursal localmente

git checkout -b your_branch

Después de eso, puede trabajar localmente en su sucursal, cuando esté listo para compartir la sucursal, empújela. El siguiente comando empuja la rama al origen del repositorio remoto y la rastrea

git push -u origin your_branch

Los compañeros de equipo pueden llegar a su sucursal haciendo lo siguiente:

git fetch
git checkout origin/your_branch

Puede continuar trabajando en la rama y presionando cuando lo desee sin pasar argumentos a git push (git push sin argumentos empujará al maestro a maestro remoto, your_branch local a remoto your_branch, etc.)

git push

Los compañeros de equipo pueden empujar a su rama haciendo compromisos y luego empujar explícitamente

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

O rastrear la rama para evitar los argumentos para git push

git checkout --track -b your_branch origin/your_branch
... work ...
git commit
... work ...
git commit
git push
dseminara
fuente
¿Hay alguna manera de crear una rama remota sin crear una rama local del mismo nombre?
Ariel Gabizon
330

Solución simple Git 2.0+:

A partir de Git 2.0, el comportamiento se ha vuelto más simple :

Puede configurar git con push.default = currentpara hacer la vida más fácil:

Agregué esto, así que ahora puedo empujar una nueva sucursal hacia arriba con

$ git push -u

-urastreará la rama remota del mismo nombre. Ahora con esta configuración, adivinará automáticamente la referencia remota a git push. De la documentación de git.config :

push.default

Define la acción que git push debería tomar si no se proporciona explícitamente refspec.

push.default = current- presione la rama actual para actualizar una rama con el mismo nombre en el extremo receptor. Funciona en flujos de trabajo centrales y no centrales.

Para mí, esta es una buena simplificación de mi flujo de trabajo diario de Git. La configuración se encarga del caso de uso 'habitual' en el que agrega una rama localmente y desea crearla de forma remota. Además, puedo crear fácilmente ramas locales a partir de controles remotos simplemente haciendo git co remote_branch_name(en lugar de usar la --set-upstream-tobandera).

Conozco esta pregunta y las respuestas aceptadas son bastante antiguas, pero el comportamiento ha cambiado, por lo que ahora existen opciones de configuración para simplificar su flujo de trabajo.

Para agregar a su configuración global de Git, ejecute esto en la línea de comando:

$ git config --global push.default current
Jesper Rønn-Jensen
fuente
55
Encuentro git push -u origin HEADcomo respondido aquí un poco más detallado (usted escribe lo que está haciendo) sin ser demasiado para escribir. Además, git push -usin argumentos adicionales no funcionaría para mí si la rama se creó con-t
Qw3ry
git config --global push.default upstream && git checkout -b foo && <change a file> && git push -uno funciona (a partir de git 2.19.1); push requiere los argumentos remotos y de ramificación.
Knite
¿Podría ampliar lo que quiere decir con git co remote_branch_name?
flannelbeard
84

Como se indicó en las respuestas anteriores,

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

es suficiente para empujar una sucursal local.

Sus colegas pueden extraer todas las ramas remotas (incluidas las nuevas) con este comando:

git remote update

Luego, para realizar cambios en la rama, el flujo habitual:

git checkout -b <local-branch-name> <remote-name>/<remote-branch-name>
Lucian
fuente
Me gusta esto porque permite que el nombre remoto sea diferente al local
Ariel Gabizon
66

Crear una nueva sucursal localmente basada en la rama actual:

git checkout -b newbranch

Confirma los cambios como lo harías normalmente. Luego, empuje hacia arriba:

git push -u origin HEAD

Este es un acceso directo para empujar la rama actual a una rama del mismo nombre originy rastrearla para que no necesite especificar origin HEADen el futuro.

Zenexer
fuente
44
Esto ayudó en mi caso: git push -u origin HEAD. Creo que es la forma más clara.
Scadge
2
Sí, nunca recuerdas exactamente lo que escribiste por última vez como una rama, así que este es el camino a seguir.
marksyzm
44
@marksyzm Si no puedes recordar en qué rama estás o cómo la llamaste, ¡probablemente no deberías estar presionando para nada! Al menos, no sin correr git statusprimero.
Zenexer
1
Sí, tengo que asegurarme de que el mundo no explote con ese impulso; Estoy de acuerdo.
marksyzm
1
Esta es la forma más eficiente de crear una rama de seguimiento, así como una rama remota al mismo tiempo. También me gustaría agregar git remote show origincomo tercer paso solo para visualizar la nueva relación de seguimiento / seguimiento.
hb5fa
54

Si desea crear una rama desde la rama actual

git checkout -b {your_local_branch_name} 

quieres una rama de una rama remota, puedes intentar

git checkout -b {your_local_branch_name} origin/<remote_branch_name>

Si ha terminado con los cambios, puede agregar el archivo.

git add -A or git add <each_file_names>

Luego haz un compromiso local

git commit -m 'your commit message'

Cuando quieres empujar al repositorio remoto

git push -u origin <your_local_branch_name>

Todos juntos serán

git checkout -b bug_fixes 

o si desea crear una rama desde una rama remota, por ejemplo, desarrollo

git checkout -b correcciones de errores origen / desarrollo

Puede empujar a la sucursal al repositorio remoto mediante

git push -u origin bug_fixes

Cada vez que desee actualizar su sucursal desde cualquier otra sucursal, diga master .

git pull origin master.

sreekumar
fuente
46

Si realmente quiere crear una rama remota sin tener la local, puede hacerlo así:

git push origin HEAD:refs/heads/foo

Empuja lo que sea su CABEZA para ramificar foo que no existía en el control remoto.

Tassadar
fuente
Hacer esto confundió completamente mi Visual Studio hasta el punto de que no se iniciaba correctamente. El Team Explorer no se cargó en absoluto, pero todo lo demás también se volvió loco lanzando errores. Solo para tu información.
Josh
Parece que debería funcionar, pero cuando realmente lo probé, nuestro servidor gitlab no reconoció el resultado como una rama.
JosephH
¿De qué rama se ramifica foo en el control remoto? ¿Qué pasa si quisiera engañarme para ramificarme de foo2? ¿Es eso posible? Gracias.
user674669
También funciona en el servidor gerrit, creando una nueva rama en el control remoto que no existía antes de este comando.
MichaelZ
33

Solución más fácil ... Drumm Roll ... git versión 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: la rama que acaba de crear en su entorno local y la rama remota no existente donde está tratando de empujar, debe tener el mismo nombre .

sapy
fuente
3
Gracias por tu sugerencia. Aunque llames a esto una solución fácil, sigo pensando que git push -ues mucho más fácil. Requiere que tenga una línea de configuración global, consulte stackoverflow.com/a/27185855/109305 . Lo uso git push -uconstantemente, cubre el 99% de mis casos de uso cuando trabajo.
Jesper Rønn-Jensen
31

[Respuesta rápida]

Puedes hacerlo en 2 pasos:

1. Use checkoutpara crear la rama local:

git checkout -b yourBranchName

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.

Javier C.
fuente
1
¡Rápido y al punto!
Dev
26

Primero crea la rama localmente:

git checkout -b your_branch

Y luego para crear la rama de forma remota:

git push --set-upstream origin your_branch

Nota: Esto funciona en las últimas versiones de git:

$ git --version
git version 2.3.0

¡Salud!

ipegasus
fuente
Este es solo el texto de ayuda generado por el comando git pushcuando su sucursal local no es rastreada por un control remoto.
nurettin
18

Cree la rama en su máquina local y cambie en esta rama:

$ git checkout -b [name_of_your_new_branch]

Empuje la rama en github:

$ git push origin [name_of_your_new_branch]

Cuando desee comprometer algo en su sucursal, asegúrese de estar en su sucursal.

Puede ver todas las ramas creadas usando:

$ git branch

Que mostrará:

* approval_messages
  master
  master_clean

Agregue un nuevo control remoto para su sucursal:

$ git remote add [name_of_your_remote] 

Empuje los cambios de su confirmación a su rama:

$ git push origin [name_of_your_remote]

Actualice su sucursal cuando se haya actualizado la sucursal original del repositorio oficial:

$ git fetch [name_of_your_remote]

Luego debe aplicar para fusionar cambios, si su rama se deriva del desarrollo, debe hacer:

$ git merge [name_of_your_remote]/develop

Eliminar una rama en su sistema de archivos local:

$ git branch -d [name_of_your_new_branch]

Para forzar la eliminación de la rama local en su sistema de archivos:

$ git branch -D [name_of_your_new_branch]

Eliminar la rama en github:

$ git push origin :[name_of_your_new_branch]

Aquí toda la información

Otro proyecto existente

Numan Turkeri
fuente
14

Crear una sucursal local a partir de una sucursal existente (puede ser maestro / desarrollo / cualquier otra sucursal).

git checkout -b nombre_búsqueda

Empuje esto al control remoto

git push -u nombre_remoto nombre_ranch_local: nombre_ranch_remoto

Aquí,

  1. -u: establece la rama ascendente
  2. nombre_remoto: git establece el nombre por defecto como "origen" cuando crea el repositorio. Sin embargo, esto se puede cambiar a un nombre arbitrario diferente.
  3. local_branch_name: es el nombre de la rama local que se empujará.
  4. remote_branch_name: es el nombre de la rama remota que queremos crear en remoto.

Si eliminamos los nombres de las sucursales locales y remotas, tendrá el formato

git push -u nombre_remoto nombre_ sucursal

Esto empujará la sucursal local a remota y con el mismo nombre que la sucursal local nombre_ sucursal. La sucursal local también rastreará la sucursal remota.

iosCurator
fuente
10

Sé que esta pregunta está bien respondida, pero solo quería enumerar los pasos que tomo para crear una nueva rama "myNewBranch" y presionar a remoto ("origen" en mi caso) y configurar el seguimiento. Considere esta la versión "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
sufinawaz
fuente
8

Ahora con git, puede escribir, cuando esté en la rama correcta

git push --set-upstream origin <remote-branch-name>

y git crea para ti la rama de origen.

Maurizio Brioschi
fuente
1
-u es la abreviatura de --set-upstream ... por lo que el comando podría ser git push -u origin <remote-branch-name>
Excepción no detectada
fatal: 'origen' no parece ser un repositorio git
Dmitry Grinko
tal vez tengas que configurar el origen de tu repositorio git
Maurizio Brioschi
8

Solo quería agregar eso mientras:

git checkout -b {branchName}

Crea una nueva rama, también comprueba esa rama / la convierte en su rama actual. Si, por alguna razón, todo lo que quiere hacer es cortar una rama pero no convertirla en su rama actual, entonces usaría el siguiente comando:

git branch {branchName}

En el primer comando, "checkout" hace que dicha rama sea su rama actual, y el "-b" significa: esta rama aún no existe, así que hágala por mí.

Brian Sachetta
fuente
6

Cómo hacerlo a través del árbol de origen

 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)
Monis Majeed
fuente
5

git push -u <remote-name> <branch-name>no funciona si la rama recién creada no se genera desde el mismo repositorio, es decir, si no ha creado la nueva rama usando git checkout -b new_branch, entonces esto no funcionará.

Por ejemplo, había clonado dos repositorios diferentes localmente y tuve que copiar repo2 / branch1 a repo1 / y luego empujarlo también.

Este enlace me ayudó a enviar mi sucursal local (clonada desde otro repositorio) a mi repositorio remoto:

pie roto
fuente
3

Así es como lo haces en eclipse a través de Egit.

1) Vaya a la vista "Exploración del repositorio de Git" y explique el proyecto git para el que desea crear una rama. En Brances -> Local ... seleccione la rama para la que desea crear la rama (en mi caso seleccioné master ... puede seleccionar otra rama si lo desea) ... luego haga clic derecho y haga clic en la opción Crear rama ... y seleccione la opción de pago de este proyecto y luego haga clic en el botón Finalizar.

2) Ahora, desde el explorador del proyecto, seleccione el proyecto ... haga clic derecho y luego Equipo -> Push Branch.

Se creará una nueva sucursal remota. Puede dar el nombre de la sucursal a sus colegas para que puedan extraerla.

usuario2225713
fuente
Advertencia tangencial sobre Egit - y todos los clientes basados ​​en JGit, AFAIK: ¡no admiten .gitattributes! Esto significa que si su equipo utiliza una combinación de Windows (CRLF) y Linux / OSX (LF), debe depender de que cada cliente tenga la configuración correcta en todo momento. Naturalmente, es mejor administrar las terminaciones de línea centralmente a nivel de repositorio o proyecto, y .gitattributes es la forma compatible de hacerlo. Entonces, si no tienes que usar Egit ... ¡no lo hagas! :)
cada
2

He usado dos formas de crear sucursales

Si está utilizando TortoiseGit, siga estos pasos:

1.Create Branch usando TortoiseGit

Haga clic derecho en su proyecto >>> TortoiseGit >>> Crear rama >>> escriba el nombre de la rama y seleccione la rama base, luego presione OK

2. Empuja la rama

Haga clic derecho en su proyecto >>> TortoiseGit >>> push >>> haga clic en ok

3. Cambiar a una nueva sucursal

Haga clic derecho en su proyecto >>> TortoiseGit >>> Switch / Checkout >>> seleccione una rama recién creada y presione ok

Si está utilizando el símbolo del sistema, siga estos pasos:

1.Cree una rama usando el símbolo del sistema

$ git checkout -b nombre_branch_nuevo

2. Empuja la rama

$ git push origin new_branch_name

3. Cambie a una nueva rama, ya cambiará a new_branch_name; de ​​lo contrario, puede usar

$ git checkout new_branch_name

Mandeep Singh Gill
fuente
0

Yo uso esto y es bastante útil:

git config --global alias.mkdir '!git checkout -b $1; git status; git push -u origin $1; exit;'

Uso: git mkdir NEW_BRANCH

Ni siquiera necesitas el estado de git; tal vez, solo quiero asegurarme de que todo vaya bien ...

Puede tener AMBAS ramas LOCALES y REMOTAS con un solo comando.

Tarik
fuente