Rama Git

Trabajar con ramas de Git

En Git, a branches una versión nueva/separada del repositorio principal.

Supongamos que tiene un proyecto grande y necesita actualizar el diseño.

¿Cómo funcionaría eso sin y con Git?

Sin Git:

• Haga copias de todos los archivos relevantes para evitar afectar la versión en vivo
• Comience a trabajar con el diseño y descubra que el código depende del código en otros archivos, ¡eso también debe cambiarse!
• Haga copias de los archivos dependientes también. Asegurarse de que cada dependencia de archivo haga referencia al nombre de archivo correcto
• ¡EMERGENCIA! ¡Hay un error no relacionado en otra parte del proyecto que debe corregirse lo antes posible!
• Guarde todos sus archivos, tomando nota de los nombres de las copias en las que estaba trabajando
• Trabaje en el error no relacionado y actualice el código para solucionarlo
• Vuelva al diseño y termine el trabajo allí.
• Copie el código o cambie el nombre de los archivos, para que el diseño actualizado esté en la versión en vivo
• (2 semanas después, se da cuenta de que el error no relacionado no se solucionó en la nueva versión de diseño porque copió los archivos antes de la corrección)

Con Git:

• Con una nueva rama llamada nuevo diseño, edite el código directamente sin afectar la rama principal
• ¡EMERGENCIA! ¡Hay un error no relacionado en otra parte del proyecto que debe corregirse lo antes posible!
• Cree una nueva rama del proyecto principal llamada corrección de errores pequeños
• Solucione el error no relacionado y fusione la rama de corrección de errores pequeños con la rama principal
• Vuelve a la sucursal de nuevo diseño y termina el trabajo allí.
• Fusionar la rama de nuevo diseño con la principal (recibir alertas sobre la corrección del pequeño error que faltaba)

Las ramas le permiten trabajar en diferentes partes de un proyecto sin afectar la rama principal.

Cuando el trabajo está completo, una rama se puede fusionar con el proyecto principal.

Incluso puede cambiar entre sucursales y trabajar en diferentes proyectos sin que interfieran entre sí.

¡La ramificación en Git es muy ligera y rápida!

Nueva rama de Git

Vamos a agregar algunas características nuevas a nuestra index.htmlpágina.

Estamos trabajando en nuestro repositorio local y no queremos perturbar o arruinar el proyecto principal.

Entonces creamos un nuevo branch:

git branch hello-world-images

Ahora creamos una nueva branchllamada " hello-world-images"

Confirmemos que hemos creado un nuevo branch:

git branch
  hello-world-images
* master

Podemos ver la nueva rama con el nombre "hello-world-images", pero al *lado masterespecifica que estamos actualmente en eso branch.

checkoutes el comando utilizado para verificar un archivo branch. Moviéndonos del actual branch, al especificado al final del comando:

git checkout hello-world-images
Switched to branch 'hello-world-images'

Ahora hemos movido nuestro espacio de trabajo actual de la rama maestra, a la nueva branch

Abre tu editor favorito y haz algunos cambios.

Para este ejemplo, agregamos una imagen (img_hello_world.jpg) a la carpeta de trabajo y una línea de código en el index.htmlarchivo:

Hicimos cambios en un archivo y agregamos un nuevo archivo en el directorio de trabajo (el mismo directorio que el main branch).

Ahora verifique el estado de la corriente branch:

git status
On branch hello-world-images
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   index.html

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        img_hello_world.jpg

no changes added to commit (use "git add" and/or "git commit -a")

Entonces, veamos lo que sucede aquí:

• Hay cambios en nuestro index.html, pero el archivo no está preparado para commit
• img_hello_world.jpgno es tracked

Entonces, necesitamos agregar ambos archivos al Entorno de ensayo para esto branch:

git add --all

El uso --allen lugar de nombres de archivo individuales organizará todos los archivos modificados (nuevos, modificados y eliminados).

Compruebe el statusde branch:

git status
On branch hello-world-images
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
    new file: img_hello_world.jpg
    modified: index.html

Estamos contentos con nuestros cambios. Así que los cometeremos con branch:

git commit -m "Added image to Hello World"
[hello-world-images 0312c55] Added image to Hello World
2 files changed, 1 insertion(+)
create mode 100644 img_hello_world.jpg

Ahora tenemos uno nuevo branch, que es diferente al maestro branch.

Cambio entre sucursales

Ahora veamos qué tan rápido y fácil es trabajar con diferentes ramas y qué tan bien funciona.

Actualmente estamos en la sucursal hello-world-images. Agregamos una imagen a esta rama, así que enumeremos los archivos en el directorio actual:

ls
README.md  bluestyle.css  img_hello_world.jpg  index.html

Podemos ver el nuevo archivo img_hello_world.jpg, y si abrimos el archivo html, podemos ver que el código ha sido alterado. Todo es como debe ser.

Ahora, veamos qué sucede cuando cambiamos de rama amaster

git checkout master
Switched to branch 'master'

La nueva imagen no es parte de esta rama. Enumere los archivos en el directorio actual nuevamente:

ls
README.md  bluestyle.css  index.html

img_hello_world.jpgya no esta! Y si abrimos el archivo html, podemos ver el código revertido a lo que era antes de la alteración.

¿Ves lo fácil que es trabajar con sucursales? ¿Y cómo esto te permite trabajar en cosas diferentes?

Rama de emergencia

Ahora imagine que aún no hemos terminado con las imágenes de hola-mundo, pero necesitamos corregir un error en el maestro.

No quiero meterme con master directamente, y no quiero meterme con hello-world-images, ya que aún no está hecho.

Por lo que creamos una nueva sucursal para atender la emergencia:

git checkout -b emergency-fix
Switched to a new branch 'emergency-fix'

Ahora hemos creado una nueva rama desde el maestro y la hemos cambiado. Podemos corregir el error de forma segura sin molestar a las otras ramas.

Arreglemos nuestro error imaginario:

Hemos realizado cambios en este archivo y necesitamos obtener esos cambios en la rama principal.

Compruebe el estado:

git status
On branch emergency-fix
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")

preparar el archivo y confirmar:

git add index.html
git commit -m "updated index.html with emergency fix"
[emergency-fix dfa79db] updated index.html with emergency fix
 1 file changed, 1 insertion(+), 1 deletion(-)

Ahora tenemos una solución lista para el maestro y necesitamos fusionar las dos ramas.

git