Summary  
This chapter explains how to replay a series of commits onto a different base to keep history linear, perform a fast-forward merge, and then clean up by deleting now-unneeded branches.

General domain of usage  
Version control

## Rebase de cambios en la rama main

Antes de poder hacer rebase de nuestros cambios, primero necesitamos cambiar a la rama `main` y obtener los cambios más recientes:

```
git checkout main
```

```
git pull
```

Ahora veamos el árbol de commits:

```
git log --graph --oneline --all
```

Actualmente, tanto las ramas `main` como `feature/payment` tienen commits posteriores al ancestro común más reciente. Esto indica que no se puede realizar una **fusión fast-forward**.

Si fusionáramos estas ramas, se produciría una **fusión de tres vías**. Sin embargo, queremos mantener un historial lineal, por lo que realizaremos un rebase de la rama `feature/payment` **sobre** la rama `main`. Esto se puede hacer cambiando a la rama `feature/payment` y ejecutando el comando `git rebase`:

```
git checkout feature/payment
```

```
git rebase main
```

## Fusión fast-forward

Dado que el rebase fue exitoso, volvamos a observar nuestro árbol de commits:

```
git log --graph --oneline
```

Como se esperaba, el historial de commits ahora es **lineal** y el último commit está en la rama `feature/payment`. Ahora, se puede realizar una **fusión fast-forward** sencilla en la rama `main`:

```
git checkout main
```

```
git merge feature/payment
```

Verificación de que ambas ramas apuntan al mismo commit mediante la revisión del commit más reciente:

```
git log -n 1
```

## Eliminación de la rama de características

La rama `main` ahora contiene el **commit más reciente** con la implementación del sistema de pagos, por lo que se puede eliminar de forma segura tanto la rama local como la remota `feature/payment`. El siguiente comando elimina la **rama remota**:

```
git push --delete origin feature/payment
```

Ahora, se puede eliminar la rama **local**:

```
git branch -d feature/payment
```

Finalmente, todos los cambios realizados pueden ser enviados de vuelta al **repositorio remoto**:

```
git push
```

Para verificar que la rama **feature** fue eliminada tanto localmente como remotamente, puedes ejecutar el siguiente comando, que lista **todas** (`-a` significa todas) las ramas locales y remotas:

```
git branch -a
```

Como puedes ver, la rama `feature/payment` fue **eliminada** exitosamente, y ahora solo hay dos ramas: `main` y `john/test` junto con sus **contrapartes remotas**.

En general, el rebase funciona bien para **cambios locales** que aún no se han compartido, pero puede causar problemas significativos para **cambios que ya se han publicado en un repositorio remoto** y posiblemente descargados por otros colaboradores. Hacer rebase de commits que otros están utilizando puede crear confusión y conflictos debido a la reescritura del historial de commits.

Como regla general, evita hacer rebase de cambios que hayan sido **enviados a repositorios remotos** para prevenir estos problemas.

Después de hacer rebase de `feature/payment` sobre `main`, ¿por qué `git merge feature/payment` realiza un merge fast-forward?

Explora los aspectos esenciales de GitHub, comenzando por comprender qué es GitHub. Aprende a crear tus propios repositorios y gestionar ramas remotas. Descubre cómo sincronizar cambios entre diferentes entornos. Profundiza en flujos de trabajo más avanzados, incluyendo la extracción, el envío y la rebase de cambios. Domina los comandos necesarios para colaborar de manera eficiente con tu equipo.

Aprenda los conceptos básicos de GitHub, incluyendo qué es GitHub y cómo funcionan los repositorios remotos. Creación de una cuenta de GitHub, configuración y gestión de repositorios, clonación de repositorios remotos en la máquina local y envío de cambios para mantener los proyectos actualizados y sincronizados.

Domina los fundamentos de la interacción con repositorios remotos aprendiendo a trabajar con ramas remotas, obtener y fusionar cambios remotos, y extraer actualizaciones de repositorios remotos.
Adquiere las habilidades esenciales necesarias para gestionar y sincronizar tu trabajo de manera efectiva con equipos remotos.


Profundiza en los flujos de trabajo avanzados de Git dominando las técnicas de extracción y envío de cambios, envío de ramas locales y rebase de cambios. Perfecciona tus habilidades de control de versiones para gestionar escenarios de desarrollo más complejos y mantener un historial de proyecto limpio y eficiente.

Realización de una Operación de Rebase

Rebase de cambios en la rama main

Fusión fast-forward

Eliminación de la rama de características