Crea una rama en Git desde otra rama

Tengo dos ramas: master y dev.

Quiero crear una "rama de funciones" desde la rama de desarrollo .

Actualmente en la rama dev , hago:

git checkout -b myfeature dev

... (algo de trabajo)

git commit -am "blablabla"
git push origin myfeature

Pero, después de visualizar mis ramas, obtuve:

--**master**
------0-----0-----0-----0-----0
------------------------**dev**----**myfeature**

Quiero decir que la rama parece fusionada rápidamente y no entiendo por qué...

¿Qué estoy haciendo mal?

¿Cómo puede separarse de otra rama y regresar al repositorio remoto para la rama de funciones?

Todo eso en un modelo ramificado como el que se describe aquí .

Dec 17 '10 19:12 revohsalf

Si desea crear una nueva rama a partir de cualquiera de las ramas existentes en Git, simplemente siga las opciones.

Primero cambie/pague en la sucursal desde donde desea crear una nueva sucursal. Por ejemplo, si tiene las siguientes ramas como:

• maestro
• desarrollador
• rama1

Entonces, si desea crear una nueva rama llamada "subbranch_of_b1" debajo de la rama llamada "branch1", siga los pasos:

1. Pagar o cambiar a "branch1"

    git checkout branch1
   

2. Ahora cree su nueva rama llamada "subbranch_of_b1" debajo de "branch1" usando el siguiente comando.

    git checkout -b subbranch_of_b1 branch1
   

   Lo anterior creará una nueva rama llamada subbranch_of_b1 debajo de la rama rama1 (tenga en cuenta que branch1en el comando anterior no es obligatorio ya que HEAD actualmente apunta a ella, aunque puede especificarlo si está en una rama diferente).

3. Ahora, después de trabajar con subbranch_of_b1 , puede confirmarlo y enviarlo o fusionarlo de forma local o remota.

Empuje el subbranch_of_b1 al control remoto:

 git push origin subbranch_of_b1

Sep 04 '2015 07:09 Praveen George

Varias formas de crear una rama en Git desde otra rama:

Esta respuesta agrega información adicional, que aún no está presente en las respuestas existentes, con respecto solo al título de la pregunta en sí ( Crear una rama en Git desde otra rama ), pero no aborda los detalles más específicos de la pregunta que ya tienen suficientes respuestas. aquí.

Estoy agregando esto porque realmente necesitaba saber cómo hacer el punto 1 a continuación (crear una nueva rama a partir de una rama que no he verificado ), y no era obvio cómo hacerlo, y las búsquedas en Google me llevaron hasta aquí como uno de los mejores resultados de búsqueda. Entonces, compartiré mis hallazgos aquí. Esto no se aborda bien, en todo caso, en ninguna otra respuesta aquí.

Mientras estoy en esto, también agregaré mis otros git branchcomandos más comunes que uso en mi flujo de trabajo habitual, a continuación.

1. Para crear una nueva sucursal a partir de una sucursal que no ha retirado:

Cree branch2desde branch1mientras tiene cualquier rama desprotegida (por ejemplo, digamos que ha masterdesprotegido):

git branch branch2 branch1

El formato general es:

git branch <new_branch> [from_branch]

man git branchlo muestra de la siguiente manera. Lo que yo llamo <new_branch>es lo que ellos llaman <branchname>, y lo que yo llamo [from_branch]es lo que ellos llaman [<start-point>]:

git branch [--track | --no-track] [-l] [-f] <branchname> [<start-point>]

2. Para crear una nueva sucursal a partir de la sucursal que ya ha retirado:

git branch new_branch

Esto es excelente para hacer copias de seguridad antes de cambiar la base, aplastar, restablecer por completo, etc., antes de hacer cualquier cosa que pueda estropear gravemente su rama.

Ejemplo: estoy en feature_branch1y estoy a punto de convertir 20 confirmaciones en 1 usando git rebase -i master. En caso de que alguna vez quiera "deshacer" esto, ¡primero hagamos una copia de seguridad de esta rama! Hago esto TODO...EL...TIEMPO y me resulta muy útil y reconfortante saber que siempre puedo volver fácilmente a esta rama de respaldo y volver a ramificarla para volver a intentarlo en caso de que me equivoque feature_branch1en el proceso:

git branch feature_branch1_BAK_20200814-1320hrs_about_to_squash

La 20200814-1320hrsparte es la fecha y hora en formato YYYYMMDD-HHMMhrs, por lo que serían las 13:20 horas (1:20 p.m.) del 14 de agosto de 2020. De esta manera tengo una manera fácil de encontrar mis sucursales de respaldo hasta que esté seguro de que estoy listo para eliminarlos. Si no haces esto y te equivocas mucho, tienes que usar git reflogpara buscar tu rama antes de estropearla, lo cual es mucho más difícil, más estresante y más propenso a errores.

Interjección: notas sobre git checkoutvsgit switch

1. La clásica y universal "navaja suiza" que puede hacer 1000 cosas: git checkout.
2. Los nuevos y experimentales comandos alternativos a git checkout: git switch+ git restore.

git switchse agregó recientemente en Git v2.23. Vea su versión de git con git --version. Está diseñado para ser una forma extremadamente limitada de git checkout, diseñado sólo para cambiar de rama en lugar de tener también la capacidad de extraer o restaurar archivos, como git checkoutpuede hacer. Lea más aquí: https://www.git-tower.com/learn/git/commands/git-switch.

Ver también: ¿Qué sigue haciendo git checkout después de que se introdujo git switch? . git restoreofrece algunas del resto de funcionalidades que git checkoutno git switchcontiene.

Ambos man git switchy man git restoreprecaución:

ESTE COMANDO ES EXPERIMENTAL. EL COMPORTAMIENTO PUEDE CAMBIAR.

Así que siéntete libre de seguir git checkoutsi quieres. No es probable que su comportamiento cambie.

Prácticamente solo lo uso git checkoutyo mismo, pero puedes usarlo git switch(y git restorerestaurar o "revisar" archivos) si lo deseas.

3. Para crear y retirar una nueva sucursal de la sucursal que ya ha retirado:

# the standard, "classic" command most people still use; `-b` stands
# for "create 'b'ranch"
git checkout -b new_branch

# the newer, "experimental" command now available as of Git v2.23; `-c` stands
# for "'c'reate branch"
git switch -c new_branch

Para que quede claro lo que está sucediendo allí, sepa que este comando anterior es equivalente a estos dos comandos separados:

# classic
git branch new_branch
git checkout new_branch

# OR: new/experimental as of Git v2.23
git branch new_branch
git switch new_branch

4. Para crear y retirar una nueva sucursal de una sucursal que no ha retirado:

# classic
git checkout -b new_branch from_branch

# OR: new/experimental as of Git v2.23
git switch -c new_branch from_branch

Para que quede claro lo que está sucediendo allí, sepa que este comando anterior es equivalente a estos tres comandos separados:

# classic
git checkout from_branch
git branch new_branch
git checkout new_branch

# OR: new/experimental as of Git v2.23
git switch from_branch
git branch new_branch
git switch new_branch

5. Para cambiar el nombre de una sucursal

Al igual que cambiar el nombre de un archivo o carpeta normal en la terminal, gitse considera que "cambiar el nombre" es más como un comando 'm'ove', por lo que se utiliza git branch -mpara cambiar el nombre de una rama. Aquí está el formato general:

git branch -m <old_name> <new_name>

man git branchlo muestra así:

git branch (-m | -M) [<oldbranch>] <newbranch>

Ejemplo: cambiemos el nombre branch_1a branch_1.5:

git branch -m branch_1 branch_1.5

O, si ya ha realizado branch_1el check-out, puede cambiar el nombre de la rama actualmente retirada para que branch_1.5le guste esto:

git branch -m branch_1.5

6. Para crear una nueva rama de funciones ( feature2) basada en los últimos cambios ascendentes del mainmomento en que realizó feature1el check-out actualmente

Juntemos mucho de lo que aprendimos anteriormente para presentar un ejemplo muy común que debemos ejecutar cada vez que finalizamos una función y necesitamos iniciar otra.

# The beginner/intermediate way

git checkout main           # check out main branch
git pull                    # pull latest upstream changes down
git checkout -b feature2    # create branch `feature2` from `main`, and check
                                # it out, all in one step`

# The advanced way

# [this is what I do--I'll explain why, below]
git fetch origin main:main      # pull latest upstream changes down from the
                                    # remote `main` branch, to the
                                    # locally-stored remote-tracking **hidden**
                                    # branch named `origin/main`, **and** to
                                    # the local `main` branch
git checkout -b feature2 main   # create branch `feature2` from `main`, and
                                    # check it out, all in one step`

# OR (nearly the same thing)
git fetch origin main           # pull latest upstream changes down from the
                                    # remote `main` branch, to the
                                    # locally-stored remote-tracking **hidden**
                                    # branch named `origin/main`. This does NOT
                                    # update the local `main` branch though!
git checkout -b feature2 origin/main # create branch `feature2` from
                                        # `origin/main`, and check it out, all
                                        # in one step`

Entonces, cuando estoy en la rama feature1, acabo de terminarla y estoy listo para comenzar con una nueva feature2basada en la última mainrama, ¿por qué hago esto?

git fetch origin main:main
git checkout -b feature2 main

...¿en lugar de esto?:

git checkout main
git pull
git checkout -b feature2

La respuesta, sorprendentemente, es que git checkoutpuede ser una operación terriblemente lenta y pesada. —toma más de 3 horas en un repositorio mono masivo utilizando git lfsganchos posteriores al pago en el .git/hooks/post-checkoutarchivo del repositorio. Dejame explicar. El .git/hooks/post-checkoutarchivo es un archivo ejecutable que contiene un script que git ejecutará cada vez que ejecute git checkout. Si contiene una llamada a git lfs post-checkout "$@", entonces puede intentar descargar más de 20 GB de git lfsdatos (específicos del repositorio en el que trabajo; su escenario puede variar) después de ejecutar un archivo git checkout. ¡No quiero hacer eso! Entonces, me salto el git checkoutproceso para evitar esa molestia y comienzo con mi feature2sucursal inmediatamente sin descargar todas esas cosas que no necesito primero.

Ver también:

1. Enlaces rápidos a mis respuestas a las que hago referencia con frecuencia y que considero "fundamentos de git":
   1. Varias formas de crear una rama en git desde otra rama
   2. Todo sobre consultar archivos o directorios en git
   3. ¿Quiénes somos "nosotros" y quiénes son "ellos" según Git?
   4. Cómo utilizar git difffiltros a través de--diff-filter=
   5. Todo sobre buscar (vía grepo similar) en tus repositorios de git
   6. Cómo utilizarlo git lfscomo usuario básico: ¿Cuál es la diferencia entre git lfs fetch, git lfs fetch --ally git lfs pull?

Aug 14 '2020 18:08 Gabriel Staples

Crear una sucursal

• Crear rama cuando la rama maestra esté desprotegida. Aquí las confirmaciones en master se sincronizarán con la rama que creó.

  git branch branch1

• Crear rama cuando rama1 esté desprotegida. Aquí las confirmaciones en rama1 se sincronizarán con rama2 git branch branch2

Pagar una sucursal

comando git checkout cambiar ramas o restaurar archivos de árbol de trabajo

• git checkout branchname

Cambiar el nombre de una sucursal

• git branch -m branch1 newbranchname

Eliminar una sucursal

• git branch -d branch-to-delete
• git branch -D branch-to-delete ( forzar la eliminación sin verificar el estado combinado )

Crear y cambiar de rama

• git checkout -b branchname

Sucursales que están completamente incluidas

• git branch --merged

Diferencias de rama [ git diff rama1..branch2 ]

diferencia multilínea

• git diff master..branch1

diferencia de una sola línea

• git diff --color-words branch1..branch2

Dec 08 '2016 18:12 Gnanasekar S