Tengo dos ramas: maestro y dev

Quiero crear una «rama» de la dev rama.

Actualmente en la rama dev, que debo hacer:

$ git checkout -b myfeature dev

… (algún trabajo)

$ git commit -am "blablabla"
$ git push origin myfeature

Pero, después de ver mis ramas, me dieron:

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

Me refiero a que la rama se parece ff fusionado, y no entiendo por qué…

Lo que estoy haciendo mal?

Puede usted explicar por favor cómo se ramifican desde el otro brazo y empujar de nuevo al repositorio remoto para la rama de característica?

Todos los que en una ramificación de la modelo como la que se describe aquí.

InformationsquelleAutor revohsalf | 2010-12-17

7 Comentarios

  1. 1177

    Si te gusta el método en el enlace que has publicado, eche un vistazo a Git Flow.

    Es un conjunto de scripts que él creó para que el flujo de trabajo.

    Pero para responder a tu pregunta:

    $ git checkout -b myFeature dev
    

    Crea MyFeature rama dev. Hacer su trabajo y, a continuación,

    $ git commit -am "Your message"
    

    Ahora combinar los cambios a dev, sin un avance rápido

    $ git checkout dev
    $ git merge --no-ff myFeature
    

    Ahora empujan a los cambios en el servidor

    $ git push origin dev
    $ git push origin myFeature
    

    Y verás cómo quieras.

    • Gracias por tu respuesta 😉 yo hice lo mismo (sin combinar con todo) Después de mirar Git Flujo de código fuente es aproximadamente la misma… no entiendo por qué cuando creo mi rama, commit y push a él (y a distancia), la rama parece fusionado cuando visualizo todos mis ramas
    • Debido a que usted está empujando la myFeature rama para el servidor, y se muestra que se ha salido de la rama de dev. No hay combinaciones. Mi ejemplo combina a la rama de dev y empuja a que rama fusionada con el servidor.
    • ¿cuál es la importancia de impulsar myFeature después de que se ha fusionado ingenio dev?
    • Si myFeature rama se inserta en el servidor, antes de la fusión, y luego nada. Pero si myFeature aún no está inserta en el servidor y desea que aparezca en el servidor, debe empujar appart.
    • es git checkout -b myFeature dev la misma como estos 3 comandos: git checkout dev, entonces git branch myFeature y, a continuación,git checkout myFeature?
    • Es, o debería ser. Estás viendo algo diferente?
    • La forma en que leí su secuencia es: 1) de la rama, hacer su trabajo y compromiso 2) volver a dev y combinar con la característica de 3) empuje dev 4) empuje la función de Mi pregunta: ¿por Qué push por tanto dev & feature? no sólo tiene que empujar después del paso 3 y hacerse? No tienen todos el nuevo código de la función que usted necesita combinan?
    • ¿Cómo podría hacer esto con una ya existente de la «característica» de la rama? Como en el OP pregunta?
    • una vez que ha obtenido dev y se fusionó la rama de característica en él, sólo empujando dev sería suficiente – estoy de acuerdo
    • Lo que si quiero empujar myFeature en el servidor remoto antes de que termine de trabajar en esta función? Puede omitir la combinación con dev? (La función no existe en el servidor remoto todavía)
    • Es allí una manera de definir dev como el valor predeterminado de la rama de donde quiero crear a los otros, la eliminación de la necesidad de la última param en git checkout -b newBranch dev, lo que es git checkout -b newBranch?
    • Aclarar para otros novatos, esto es lo que un --no-ff combinación parece
    • Esto sólo funciona para mí, si yo rama de origin/dev, no fuera de dev.

  2. 327

    Si quieres crear una nueva rama de cualquiera de las sucursales existentes en Git, sólo tienes que seguir las opciones.

    Primer cambio/checkout en la rama de la que desea crear una nueva rama. Por ejemplo, si usted tiene los siguientes ramas como:

    • maestro
    • dev
    • branch1

    Así que si usted desea crear una nueva rama llamada «subbranch_of_b1» por debajo de la rama denominada «branch1» siga los pasos:

    1. El proceso de pago o cambio en «branch1»

      git checkout branch1
      
    2. Ahora crear una nueva rama llamada «subbranch_of_b1» bajo el «branch1» mediante el siguiente comando.

      git checkout -b subbranch_of_b1 branch1
      

      El de arriba va a crear una nueva rama llamada subbranch_of_b1 por debajo de la rama branch1 (tenga en cuenta que branch1 en el comando anterior no es obligatorio ya que la CABEZA está apuntando, usted puede precisar si usted está en una rama diferente, aunque).

    3. Ahora después de trabajar con el subbranch_of_b1 puede commit y push o combinar de forma local o de forma remota.

    Crear una sucursal en el Git de otra rama

    empuje el subbranch_of_b1 remoto

     git push origin subbranch_of_b1 
    
    • cómo empujar el subbranch_of_b1 remoto ??
    • git push origin subbranch_of_b1 » va a hacer este trabajo para usted.
    • Ahora , Si me empuje cambios maestro , ocurrirá en branch1 automáticamente ?
    • tenga en cuenta que branch1 en el comando anterior no es obligatorio ya que la CABEZA está apuntando, usted puede precisar si usted está en una rama diferente a pesar de que que es lo que estaba buscando
    • Vine aquí preguntándome si git checkout -b some-branch es la abreviatura de git checkout -b some-branch master. Resulta que git checkout -b some-branch es la abreviatura de git checkout -b some-branch <current_active_branch>
    • git push origin subbranch_of_b1 es exactamente lo que el OP dijo que ya hizo. Esta respuesta es incompleta, ya que no abordan cómo empujar sin ff fusión.
    • El valor predeterminado de «<current_active_branch>» se ha metido en problemas a veces, por lo tanto, mi preferencia personal es explicar el origen de la rama ! Aka, mis suposiciones de mi parte fueron mal a veces.

  3. 35

    La creación de una Rama

    • Crear rama cuando la rama principal está desprotegido. Aquí comete en el master se sincronizarán con la rama que usted ha creado.

      $ git branch branch1

    • Crear rama cuando branch1 está desprotegido . Aquí comete en branch1 se sincronizarán con branch2

      $ git branch branch2


    Checkout una Rama

    git checkout modificador de comando ramas o restaurar el árbol de trabajo de archivos de

    • $ git checkout branchname

    Cambiar el nombre de una Rama

    • $ git branch -m branch1 newbranchname

    Eliminar una Rama

    • $ git branch -d branch-to-delete
    • $ git branch -D branch-to-delete
      ( forzar la eliminación sin la comprobación de la fusión de estado )

    Crear y Cambiar de Rama

    • $ git checkout -b branchname

    Ramas que son completamente incluido

    • $ git branch --merged


    ************************** Rama Diferencias [ git diff branch1..branch2 ] ************************

    Multilínea diferencia

    • $ git diff master..branch1

    Singleline diferencia

    • $ git diff --color-words branch1..branch2
    • También después de cambiar el nombre de la rama de uso git push origin :old-name new-name para eliminar el antiguo nombre de la rama remota y empuje el nuevo nombre-sucursal local.
  4. 13

    Hacer trabajar de forma simultánea en la dev rama. Lo que pasa es que en el escenario de la rama de característica se mueve hacia adelante de la punta de la rama de dev, pero la rama de dev no cambia. Es más fácil para dibujar una línea recta, porque puede ser pensado como el movimiento hacia adelante. Lo hizo en el punto a de dev, y a partir de ahí simplemente siguió una ruta paralela. Las dos ramas en realidad no han divergido.

    Ahora, si usted hace un commit en dev, antes de la fusión, en el que volverá a comenzar en la misma confirmación, Una, pero ahora cuenta va a ir a la C y a dev a B. Esto mostrará la división que están tratando de visualizar, como las ramas ahora se han ido distanciando.

    *-----*Dev-------*Feature
    

    Frente a

           /----*DevB
    *-----*DevA
           \----*FeatureC
    
  5. 3

    Git 2.23 presenta git interruptor y git restauración a dividir las responsabilidades de git checkout

    La creación de una nueva rama de una rama existente como de git 2.23:

    git switch -c my-new-branch

    Cambiado a una nueva rama ‘mi-nuevo-rama’

    • -c es corto para –crear y reemplaza al conocido git checkout -b

    Echa un vistazo a este Github blog explicando los cambios con mayor detalle:

    Git 2.23 trae un nuevo par de experimental de comandos para el conjunto de las existentes
    queridos: git interruptor y git restaurar. Estos dos son para finalmente
    proporcionar una mejor interfaz para el conocido git checkout. El nuevo
    los comandos de la intención de cada una separación nítida, perfectamente repartir
    lo de las muchas responsabilidades de git checkout

  6. 1

    Si quieres hacer una rama de alguna otra rama, a continuación, siga fuelle pasos:

    Supuestos:

    1. Usted está actualmente en la rama master.
    2. Usted no tiene cambios a cometer. (Si usted tiene cualquier cambio a cometer, guárdalos!).
    3. BranchExisting es el nombre de la rama de la que usted necesita para hacer una nueva sucursal con el nombre de BranchMyNew.

    Pasos:

    1. Buscar a la sucursal a su máquina local.

      $ git fetch origin BranchExisting : BranchExisting
      

    Este comando crea una nueva rama en su local con el mismo nombre de la sucursal.

    1. Ahora, desde la rama principal de la compra para que el recién recuperado de la rama

      $ git checkout BranchExisting
      
    2. Ahora estás en BranchExisting. Ahora crea una nueva rama de esta rama existente.

      $ git checkout -b BranchMyNew
      

    Aquí tienes!

  7. 0

    Para la creación de una rama de otra se puede utilizar esta sintaxis así:

    git push origin refs/heads/<sourceBranch>:refs/heads/<targetBranch>
    

    Es un poco más corto que el «git checkout -b» + «git push origin «

Dejar respuesta

Please enter your comment!
Please enter your name here