Pregunta ¿Cómo se crea una sucursal remota de Git?


Creé una sucursal local que quiero "impulsar" en sentido ascendente. 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 desee compartir mi sucursal.

  • ¿Como podría hacerlo? (Mis búsquedas de Google no parecían tener nada).
  • ¿Cómo le diría a mis colegas que lo extraigan del repositorio aguas arriba?

ACTUALIZAR Con Git 2.0 hay una respuesta más simple He escrito a continuación: https://stackoverflow.com/a/27185855/109305


2705
2017-10-05 09:21


origen


Respuestas:


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 inserta en el servidor remoto. Entonces, cuando se sienta preparado, puede hacer lo siguiente:

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

Dónde <remote-name> es típicamente origin, el nombre que da git al control remoto desde el que clonaste. Sus colegas simplemente sacarán 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 omites uno, asume que ambos nombres de rama son iguales. Habiendo dicho esto, como una palabra de precaución, no cometas el grave error de especificar solo :<remote-branch-name> (con los dos puntos), o la rama remota será eliminada!

De modo que una subsiguiente git pull sabrá qué hacer, en su lugar podría querer usar:

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

Como se describe a continuación, el --set-upstream opción configura una rama ascendente:

Para cada sucursal que está actualizada o   empujado con éxito, agregar aguas arriba   (seguimiento) de referencia, utilizado por   sin argumento git-pull (1) y otros   comandos.


3288
2017-10-05 09:29



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 lo 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

Puedes continuar trabajando en la rama y presionar siempre que quieras sin pasar argumentos a git push (sin argumento git push empujará el master al master remoto, your_branch local a remote your_branch, etc ...)

git push

Los compañeros de equipo pueden presionar a su sucursal haciendo commits y luego presionar explícitamente

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

O rastreando la rama para evitar los argumentos de git push

git checkout --track -b your_branch origin/your_branch
... work ...
git commit
... work ...
git commit
git push

796
2017-07-26 01:09



Solución Simple Git 2.0+:

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

Puedes configurar git con push.default = current para hacer la vida más fácil:

Agregué esto así que ahora puedo empujar una nueva rama aguas arriba con

$ git push -u

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

push.default 

Define la acción que debe tomar git push 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 de configuración se ocupa del caso de uso 'habitual' donde agrega una rama localmente y desea crearla de forma remota. Además, puedo crear fácilmente ramas locales desde controles remotos simplemente haciendo git co remote_branch_name (en lugar de usar --set-upstream-to bandera).

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 el 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

241
2017-11-28 09:46



Como se dijo en las respuestas anteriores,

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

es suficiente para impulsar una sucursal local.

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

git remote update

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

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

65
2017-12-27 14:12



Crea una nueva rama localmente basada en la rama actual:

git checkout -b newbranch

Cometa cualquier cambio como lo haría normalmente. Luego, empuje hacia arriba:

git push -u origin HEAD

Este es un atajo para pasar la rama actual a una rama del mismo nombre en origin y rastrearlo para que no necesite especificar origin HEAD en el futuro.


48
2018-02-24 14:58



Si realmente quieres crear una sucursal remota sin tener una local, puedes hacerlo así:

git push origin HEAD:refs/heads/foo

Impulsa lo que sea que tu CABEZA se ramifique foo eso no existía en el control remoto.


32
2017-11-25 15:29



Si quieres crear una rama desde la rama actual

git checkout -b {your_local_branch_name} 

quieres una sucursal de una sucursal 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>

Entonces haz un commit localmente

git commit -m 'your commit message'

Cuando desee enviar al repositorio remoto

git push -u origin <your_local_branch_name>

Todos juntos serán

git checkout -b bug_fixes 

o Si quieres crear una rama desde una rama remota, di desarrollo 

git checkout -b corrección de errores origen/desarrollo

Puede enviar a la sucursal a repositorio remoto

git push -u origin **bug_fixes**

Cada vez que desee actualizar su rama desde cualquier otra rama diga dominar.

git pull origin master.


23
2018-05-01 06:12



Primero creas 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

¡Aclamaciones!


22
2018-04-21 23:43



Crea la rama en tu máquina local y cambia en esta rama:

$ git checkout -b [name_of_your_new_branch]

Empuja 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 al usar:

$ git branch

Que mostrará:

* approval_messages
  master
  master_clean

Agregue un nuevo control remoto para su sucursal:

$ git remote add [name_of_your_remote] 

Transfiere los cambios de tu compromiso a tu sucursal:

$ git push origin [name_of_your_remote]

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

$ git fetch [name_of_your_remote]

Luego debe presentar una solicitud para fusionar los cambios, si su sucursal se deriva del desarrollo que necesita 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 una 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


16
2018-05-27 11:39



La 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 go a git commit 

3) git push origin localBranchNameThatDoesNotExistInRemote --force

nótese bien - La rama que acaba de crear en su entorno local, y la rama remota no existente en la que está tratando de impulsar, debe tener el mismo nombre.


13
2018-03-18 06:23



Ahora con git, puedes escribir, cuando estás en la rama correcta

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

y git crea para ti la rama de origen.


8
2017-10-27 17:05