Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • Ramas en Git

    Cargado por

    Jorge Sepulveda
    1 vistas8 páginas
    Continuacion con ramas en git y guthub

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    DOCX, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Denunciar este documento
    Continuacion con ramas en git y guthub

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    1 vistas8 páginas

    Ramas en Git

    Cargado por

    Jorge Sepulveda
    Continuacion con ramas en git y guthub

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    de 8

    Las ramificaciones pueden ser descritas como versiones aisladas de tu

    página web donde puedes hacer commits que no serán vistos en otro
    lugar. Es muy útil cuando hay varias personas desarrollando una página
    web: cada uno puede trabajar en su propia rama sin molestar a los
    demás.
    Las ramificaciones son útiles incluso si trabajas solo. Antes de programar
    una nueva función, debes crear una nueva rama. Cuando termines de
    trabajar en esta rama, puedes fusionarla con la rama main. Así te
    aseguras de tener siempre una versión estable independiente de tu
    proyecto.
    La rama principal de desarrollo se llama main. Suele utilizarse para
    almacenar la versión final de un código, y es la misma rama que ven los
    usuarios.

    La rama main
    La rama main se crea automáticamente cuando se inicia un repositorio de
    Git y se hace el primer commit.
    Creemos un proyecto de prueba y llamémoslo learn_branches. Crea los
    archivos index.html y style.css en él, y luego confirma el proyecto:
    Copiar códigoBASH
    # vamos a crear un proyecto nuevo e inicializarlo en Git
    mkdir learn_branches && cd learn_branches && git init && touch index.html style.css

    git add . # agrega todos los archivos, puedes llamar a "git add -A" en su lugar
    git commit -m "Commit inicial agregado"
    Notarás que escribimos git add .. El . realiza la misma tarea
    que tendría -A,
    pero envia al área de staging solamente los cambios realizados en la
    carpeta en la que te encuentras y sus subcarpetas
    Después de añadir el commit, aparece la rama main. Introduce este
    comando para comprobarlo:
    Copiar códigoBASH
    git branch # comando para enumerar las ramificaciones
    * main # tu rama principal, el asterisco resalta la rama en la que estás actualmente
    Recuerda que puedes salir de la lista de ramificaciones pulsando Q.
    Ahora añade este sencillo código HTML en index.html:
    Copiar códigoHTML
    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <title>Git</title>
    </head>
    <body>

    </body>
    </html>
    Después haz otro commit:
    Copiar códigoBASH
    git add . && git commit -m "Marcado básico agregado"
    Creación de una nueva ramificación con git branch.
    Empecemos a programar el encabezado del proyecto de prueba. Crea
    una rama separada para trabajar en la nueva función. Para ello, ejecuta
    un comando escribiendo git branch seguido del nombre que quieras darle a
    tu nueva ramificación. Elige el nombre de la rama para que refleje lo que
    ocurre en ella. El nombre de la ramificación no debe contener espacios,
    de lo contrario, mostrará un error. Al final de la lección hablaremos de los
    nombres con más detalle.
    Estamos trabajando en una nueva característica, que es un encabezado,
    por lo que llamar a la nueva rama feature/header será una buena opción:
    Copiar códigoBASH
    pwd # imprimir el directorio de trabajo
    /Users/practicum-student/dev/learn_branches

    git branch feature/header # creada una nueva rama


    git branch # comprobada la rama actual
    feature/header # la nueva rama ha aparecido
    * main # pero, como muestra el asterisco, seguimos trabajando en la rama principal
    Utilizar git switch y git restore frente a git checkout

    Aunque hemos creado la rama feature/header, seguimos trabajando dentro


    de main. Para cambiar a la rama feature/header, introduzce el comando git
    switch feature/header:
    Copiar códigoBASH
    git switch feature/header # cambio a la rama feature/header
    git branch # comprobada la rama actual
    * feature/header # como puedes ver, ¡el asterisco se ha movido! Ahora estamos en feature/header
    main
    También puedes ver este comando escrito como git checkout. Aunque este
    comando sigue funcionando, recientemente ha sido sustituido por dos
    comandos: git switch y git restore.

     git switch <branchname> es para cambiar de rama, y se utiliza de la


    misma manera que git checkout <branchname>.
     git restore <filepath> es para restaurar los archivos a los contenidos del
    último commit (sobreescribiendo tus cambios no confirmados en
    ese archivo). git restore ./file.js es equivalente al antiguo git checkout --
    ./file.js.

    Probablemente observes que tener estos dos comportamientos


    en checkout puede ser confuso, por ello recomendamos utilizar los
    comandos más modernos switch y restore en su lugar.
    Consulta el manual de git checkout(materiales en inglés), git
    switch(materiales en inglés) y git restore(materiales en inglés) para
    conocer detalles más avanzados sobre el uso de estos comandos.
    Git también permite crear una ramificación y cambiar inmediatamente a
    ella. Se hace con este comando:
    Copiar códigoBASH
    git switch -c feature/header # creada la rama feature/header y cambiando inmediatamente a ella
    # o de la manera antigua: git checkout -b feature/header
    Hemos cambiado a la rama feature/header. Añadamos el encabezado y
    hagamos un commit:
    Copiar códigoHTML
    <!-- index.html -->

    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <title>Git</title>
    <link rel="stylesheet" href="./style.css">
    </head>
    <body>
    <header class="header"></header>
    </body>
    </html>
    Copiar códigoCSS
    /* style.css */

    body {
    margin: 0;
    }

    .header {
    height: 100px;
    background-color: #000;
    }
    Copiar códigoBASH
    git branch
    # Muestra:
    # * feature/header
    # main

    git add . && git commit -m "Encabezado añadido"

    En resumen
    Has creado con éxito las ramificaciones main y feature/header. Practica
    moviéndote hacia adelante y hacia atrás usando git switch y git branch;
    observa que el código en tu editor de código cambia mientras lo haces.
    Puedes crear una rama y cambiarte a ella con un solo comando
    utilizando git switch con la flag -c:
    Copiar códigoBASH
    git switch -c branch_name # Git creará una nueva ramificación y cambiará a ella
    Hay diferentes enfoques para nombrar las ramificaciones; además, cada
    equipo elige el suyo. Hay un principio general: los nombres de las
    ramificaciones siempre deben dejar claro a los demás desarrolladores lo
    que ocurre dentro de ellas.
    Si una ramificación tiene una nueva característica, empieza su nombre
    con la palabra feature:
    Copiar códigoBASH
    git switch -c feature/header
    Si vas a corregir un bug en una rama, empieza el nombre con bugfix:
    Copiar códigoBASH
    git switch -c bugfix/horizontal-scroll
    Cuando termines de trabajar en una rama (por ejemplo, has terminado el
    encabezado), tienes que añadir el resultado de tu trabajo a la rama main.
    ¿Cómo hacerlo? Lo veremos en la próxima lección.

    git branch => comprueba en que rama estoy

    Utilizar git switch y git restore frente a git checkout

    git switch -c feature/header # creada la rama feature/header y cambiando inmediatamente a ella

    # o de la manera antigua: git checkout -b feature/header

    git switch -c branch_name # Git creará una nueva ramificación y cambiará a ella

    git switch -c feature/header

    Si vas a corregir un bug en una rama, empieza el nombre con bugfix:

    git switch -c bugfix/horizontal-scroll

    Fusionar ramas

    El encabezado de la web está listo, y nosotros también.

    Vamos a unir la rama que contiene nuestra modificación del encabezado a la rama main.

    Antes de fusionar las ramas, hay que cambiarse primero a la rama destino (a la que se quieren
    trasladar los cambios).

    En nuestro caso, es la rama main:

    git switch main # cambiaste a main

    Ahora estamos en la rama main, y tenemos que mover todos los commits allí.

    Utiliza el comando git merge feature/header:

    git merge feature/header


    Updating ffd42e2..fe581f6

    Fast-forward

    index.html | 4 ++--

    style.css | 8 ++++++++

    2 files changed, 10 insertions(+), 2 deletions(-)

    Borrar una rama


    Has fusionado los cambios en main, y ya no necesitarás la rama en la que
    trabajaste en la nueva característica, así que ahora puedes eliminarla.
    Para ello, cambia primero a la rama que quieres eliminar ejecutando el
    comando git switch main. A continuación, introduce git branch seguido de la
    tecla D y el nombre de la rama.

    # comprobando la rama actual

    git branch

    # Muestra "* feature/header"

    git switch main

    # eliminando la rama feature/header

    git branch -D feature/header

    # Muestra "Deleted branch feature/header (was fe581f6)."

    También podría gustarte