branch ver - ¿Cómo se crea una rama Git remota?




ramas remotas (15)

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

NB: la rama que acaba de crear en su entorno local, y la rama remota no existente en la que intenta ingresar, debe tener el mismo nombre .

Creé una sucursal local que quiero 'empujar' hacia arriba. Hay una pregunta similar aquí en Desbordamiento de pila 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 enviaré hacia arriba cuando esté satisfecho y quiera compartir mi sucursal.

  • ¿Como podría hacerlo? (Mis búsquedas de google no parecían llegar a nada).
  • ¿Cómo le diría a mis colegas que lo retiren del repositorio anterior?

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


Primero, debes crear tu rama localmente.

git checkout -b your_branch

Después de eso, puedes trabajar localmente en tu rama, cuando estés listo para compartir la rama, presiona. 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 tu sucursal haciendo:

git fetch
git checkout origin/your_branch

Puede continuar trabajando en la rama y presionando siempre que lo desee sin pasar argumentos a git push (gust push sin argumentos empujará el maestro a maestro remoto, su sucursal local a su sucursal remoto, etc.)

git push

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

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

O rastreando 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

Crea una nueva rama localmente basada en la rama actual:

git checkout -b newbranch

Confirma cualquier cambio como lo harías normalmente. Luego, empuje hacia arriba:

git push -u origin HEAD

Este es un atajo para empujar la rama actual a una rama del mismo nombre en origin y seguirla para que no tenga que especificar el origin HEAD en el futuro.


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.


git push -u <remote-name> <branch-name> no funciona si la nueva rama creada no se genera a partir del mismo repositorio, es decir, si no ha creado la nueva rama con git checkout -b new_branch , entonces Esto no funcionará.

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

This enlace me ayudó a empujar mi sucursal local (clonada de otro repositorio) a mi repositorio remoto:


Sólo quería añadir que mientras:

git checkout -b {branchName}

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

git branch {branchName}

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


Creación de una sucursal local a partir de una sucursal existente (puede ser maestro / desarrollar / cualquier otra rama).

git checkout -b branch_name

Empuja esto al control remoto

git push -u remote_name local_branch_name: remote_branch_name

Aquí,

  1. -u: establece la rama aguas arriba
  2. remote_name: 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 va a empujar.
  4. remote_branch_name: es el nombre de la rama remota que queremos crear en el control remoto.

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

git push -u remote_name branch_name

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


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

1) Vaya a la vista "Exploración del repositorio Git" y expanda el proyecto git en el que desea crear una rama. Bajo Ramas -> Local ... seleccione la rama para la que desea crear la rama (en mi caso, seleccioné la maestra ... 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 y envío de este proyecto y luego haga clic en el botón Finalizar.

2) Ahora, desde el explorador de proyectos, seleccione el proyecto. Haga clic con el botón derecho y luego Equipo -> Rama Push.

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


Cómo hacerlo a través de Source Tree

 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)

Simple solución Git 2.0+:

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

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

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

$ git push -u

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

push.default

Define la acción que debe realizar 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 tanto en flujos de trabajo centrales como no centrales.

Para mí, esta es una buena simplificación de mi flujo de trabajo diario de Git. El ajuste de configuración se ocupa del caso de uso "habitual" en el que agrega una sucursal localmente y desea crearla de forma remota. Además, puedo crear fácilmente sucursales locales a partir de controles remotos simplemente haciendo git co remote_branch_name (en lugar de usar --set-upstream-to flag).

Sé que 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

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 quiera cometer algo en su sucursal, asegúrese de estar en su sucursal.

Puedes ver todas las ramas creadas usando:

$ git branch

Lo que mostrará:

* approval_messages
  master
  master_clean

Agrega un nuevo control remoto para tu rama:

$ git remote add [name_of_your_remote] 

Impulsa los cambios desde tu compromiso a tu rama:

$ git push origin [name_of_your_remote]

Actualice su sucursal cuando la sucursal original del repositorio oficial haya sido actualizada:

$ git fetch [name_of_your_remote]

Luego, debe aplicar para fusionar cambios, si su rama 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 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


Primero, creas tu rama 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. Así que cuando te sientas listo para ello, simplemente puedes hacer:

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

Donde <remote-name> suele ser el origin , el nombre que git le da al remoto desde el que se clonó. Tus colegas solo tirarían de esa rama y se crearía automáticamente de forma local.

Tenga en cuenta sin embargo que formalmente, el formato es:

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

Pero cuando omites uno, se asume 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 git pull posterior de git pull sepa qué hacer, es posible que desee utilizar:

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

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

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


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

git push origin HEAD:refs/heads/foo

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


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!


Otros chicos y chicas dan las soluciones, pero tal vez pueda decirte por qué.

prueba de comprobación de git que no hace nada

Does nothing hace Does nothing , no doesn't work , así que supongo que cuando escribe 'git checkout test' en su terminal y presiona la tecla Intro, no aparece ningún mensaje y no se produce ningún error. Estoy en lo cierto

Si la respuesta es 'sí', te puedo decir la causa.

La causa es que hay un archivo (o carpeta) llamado "prueba" en su árbol de trabajo.

Cuando git checkout xxx analizó,

  1. Git ve a xxx como un nombre de rama al principio, pero no hay ninguna rama llamada prueba.
  2. Entonces Git piensa que xxx es una ruta, y afortunadamente (o desafortunadamente), hay un archivo llamado prueba. Entonces git checkout xxx significa descartar cualquier modificación en el archivo xxx .
  3. Si tampoco hay un archivo llamado xxx , Git intentará crear el xxx acuerdo con algunas reglas. Una de las reglas es crear una rama llamada xxx si existen remotes/origin/xxx .




git branch git-branch