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

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.

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

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

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>

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.

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.

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.

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 .

[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.

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!

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

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.

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

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.

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í.

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)

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:

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.

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

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.