¿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 twig 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 repository aguas arriba?

ACTUALIZAR Con Git 2.0 hay una respuesta más simple que he escrito a continuación: http://sofes.miximages.com/a/27185855/109305

Primero, crea su sucursal localmente:

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

La twig remota se crea automáticamente cuando la inserta en el server remoto. Entonces, cuando se sienta preparado, puede hacer lo siguiente:

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

Donde <remote-name> es típicamente origin , el nombre que da git al control remoto desde el que se clonó. Sus colegas simplemente sacarán esa twig y se creará automáticamente localmente.

Sin embargo, tenga en count que formalmente, el formatting es:

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

Pero cuando omites uno, asume que ambos nombres de twig son iguales. Una vez dicho esto, como precaución , no cometa el grave error de especificar solo :<remote-branch-name> (con los dos puntos), o se borrará la twig remota.

Para que una git pull posterior sepa qué hacer, en su lugar podría querer usar:

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

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

Para cada twig que esté actualizada o presionada con éxito, agregue una reference en sentido ascendente (seguimiento), utilizada por el command sin argumento git-pull (1) y otros commands.

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 command empuja la twig al origen del repository 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 twig y presionar cuando quieras sin pasar arguments 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 twig para evitar los arguments de git push

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

Solución Simple Git 2.0+:

A partir de Git 2.0 el comportamiento se ha simplificado :

Puede configurar git con push.default = current para facilitar la vida:

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

 $ git push -u 

-u rastreará la twig remota del mismo nombre. No con esta configuration, usted adivinará automáticamente la reference remota a git push. De la documentation 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 twig actual para actualizar una twig 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 configuration de configuration se ocupa del caso de uso 'habitual' donde agrega una twig localmente y desea crearla de forma remota. Además, puedo crear fácilmente twigs locales desde controles remotos simplemente haciendo git co remote_branch_name (en lugar de usar --set-upstream-to flag).

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

Para agregar a su configuration global de Git, ejecute esto en la línea de command:

 $ git config --global push.default current 

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 twigs remotas (incluidas las nuevas) con este command:

 git remote update 

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

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

Crea una nueva twig localmente basada en la twig 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 insert la twig actual en una twig con el mismo nombre en el origin y rastrearla para que no sea necesario especificar origin HEAD en el futuro.

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

 git push origin HEAD:refs/heads/foo 

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

Primero creas la twig localmente:

 git checkout -b your_branch 

Y luego para crear la twig 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!

Si quieres crear una twig desde la twig 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 file.

 git add -A or git add <each_file_names> 

Entonces haz un commit localmente

 git commit -m 'your commit message' 

Cuando desee enviar al repository remoto

 git push -u origin <your_local_branch_name> 

Todos juntos serán

 git checkout -b bug_fixes 

o si desea crear una twig desde una twig remota, diga desarrollo

git checkout -b bug_fixes origen / desarrollo

Puede enviar a la sucursal a repository remoto

 git push -u origin **bug_fixes** 

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

git pull origin master .

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

 $ git checkout -b [name_of_your_new_branch] 

Empuja la twig 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 twigs 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 repository oficial se haya actualizado:

 $ git fetch [name_of_your_remote] 

Luego debe presentar una request para fusionar los cambios, si su sucursal se deriva del desarrollo que necesita hacer:

 $ git merge [name_of_your_remote]/develop 

Eliminar una twig en su sistema de files local:

 $ git branch -d [name_of_your_new_branch] 

Para forzar la eliminación de una twig local en su sistema de files:

 $ git branch -D [name_of_your_new_branch] 

Eliminar la twig en github:

 $ git push origin :[name_of_your_new_branch] 

Aquí toda la información

Otro proyecto existente

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: el brunch en el que se encuentra actualmente en local y la twig remota no existente en la que está intentando enviar contenido, debe tener el mismo nombre .

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

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

y git crea para ti la twig de origen.

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

Solo quería agregar eso mientras:

 git checkout -b {branchName} 

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

 git branch {branchName} 

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

Crear una twig local a partir de una twig existente (puede ser master / develop / any-other-branch).

git checkout -b branch_name

Empuja esto hacia el control remoto

git push -u remote_name local_branch_name: remote_branch_name

Aquí,

  1. -u: establece la twig ascendente
  2. remote_name: git establece el nombre por defecto para que sea "origen" cuando crea el repository. Sin embargo, esto se puede cambiar a un nombre arbitrario diferente.
  3. local_branch_name: es el nombre de la twig local que se va a insert.
  4. remote_branch_name: es el nombre de la sucursal remota que queremos que se cree en remoto.

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

git push -u remote_name branch_name

Esto empujará la twig local a remota y con el mismo nombre que la twig local branch_name. La sucursal local también hará un seguimiento de la sucursal remota.

Cómo hacer 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) 

Aquí es cómo lo haces en eclipse a través de Egit.

1) Vaya a la vista "Exploración de repository de Git" y explique el proyecto de git al que desea crear una twig. En Brances -> Local … select la twig para la cual desea crear la twig (en mi caso, yo seleccioné el maestro … puede seleccionar otra twig si lo desea) .. luego haga clic derecho y click la opción Crear twig. y select la opción de pago de este proyecto y luego click el button finalizar.

2) Ahora, desde el explorador del proyecto, select el proyecto. Haga clic con el button derecho y luego Team -> Push Branch.

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

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

Por ejemplo, he clonado dos repositorys diferentes localmente y tuve que copyr repo2 / branch1 para repo1 / y luego presionarlo también.

Este enlace me ayudó a impulsar mi twig local (clonada desde otro repository) a mi repository remoto: