Tutorial Git: Comandos avanzados

Los comandos avanzados de Git permiten tener un control más preciso y detallado sobre el historial de cambios, las ramas y otras funcionalidades del sistema de control de versiones.

A continuación, se describen algunos de los comandos avanzados de Git:

1. git cherry-pick

El comando git cherry-pick permite aplicar un único commit de una rama a otra rama.

Esto puede ser útil cuando se necesita incorporar un cambio específico sin fusionar toda la rama.

Ejemplo de uso

Supongamos que se encuentra en la rama 'master' y desea aplicar un commit de la rama 'feature' llamado 'abc123':

1. Cambiar a la rama 'master':

   git checkout master
   

2. Usar git cherry-pick para aplicar el commit deseado:

   git cherry-pick abc123
   

2. git rebase

El comando git rebase se utiliza para reorganizar y combinar commits en la historia de una rama.

Puede ayudar a mantener una historia de cambios más limpia y ordenada.

Ejemplo de uso

Supongamos que se desea reorganizar los últimos 3 commits en la rama 'feature' antes de fusionarlos en 'master':

1. Cambiar a la rama 'feature':

   git checkout feature
   

2. Usar git rebase interactivo para reorganizar los commits:

   git rebase -i HEAD~3
   

   La opción -i indica que se utilizará el modo interactivo, y HEAD~3 indica que se reorganizarán los últimos 3 commits antes del commit actual en la rama 'feature'.

3. En el editor que se abre, reordenar los commits o elegir las acciones que se desean realizar.

4. Continuar con el proceso de rebase:

   git rebase --continue
   

5. Finalmente, cambiar a la rama 'master' y fusionar los cambios:

   git checkout master
   git merge feature
   

3. git stash

El comando git stash se utiliza para almacenar temporalmente cambios sin comprometerlos (commit).

Puede ser útil cuando se necesita cambiar de rama o resolver conflictos antes de volver a aplicar los cambios.

Ejemplo de uso

Supongamos que está trabajando en una rama 'bugfix' y necesita cambiar a 'develop' para resolver un conflicto:

1. Almacenar los cambios sin comprometerlos (commit):

   git stash save "Cambios temporales en bugfix"
   

2. Cambiar a la rama 'develop' y resolver el conflicto.

3. Volver a la rama 'bugfix' y aplicar los cambios almacenados:

   git checkout bugfix
   git stash pop
   

4. git revert

El comando git revert se utiliza para deshacer cambios en Git al crear un nuevo commit que deshace los cambios introducidos por un commit específico.

Esto es útil cuando se necesita corregir un error o retroceder en la historia sin eliminar la existencia del commit original.

Ejemplo de uso

Supongamos que se desea deshacer los cambios introducidos por el commit 'xyz789':

1. Utilizar git revert para crear un nuevo commit que deshace los cambios:

   git revert xyz789
   

2. Git creará un nuevo commit que deshace los cambios introducidos por 'xyz789'.

3. El historial de cambios reflejará la reversión sin eliminar el commit original.

5. git fetch

El comando git fetch se utiliza para descargar cambios desde un repositorio remoto sin fusionarlos con la rama actual.

Actualiza las referencias locales a las ramas remotas, lo que permite ver los cambios antes de fusionarlos.

Ejemplo de uso

Supongamos que se desea verificar los cambios en la rama remota 'origin/main' antes de fusionarlos en la rama local 'main':

1. Ejecutar git fetch para descargar los cambios del repositorio remoto:

   git fetch origin
   

2. Los cambios de 'origin/main' ahora están disponibles localmente, pero aún no se han fusionado.

3. Para ver los cambios sin fusionar, se puede comparar 'main' con 'origin/main' usando git diff o revisar el historial de cambios con git log.

4. Si se decide fusionar los cambios, se puede realizar mediante git merge o git pull.

6. git bisect

El comando git bisect se utiliza para encontrar el commit que introdujo un error, realizando una búsqueda binaria en el historial de commits.

Ejemplo de uso

Supongamos que se encontró un error en el proyecto y se desea encontrar el commit que lo introdujo:

1. Iniciar el proceso de búsqueda binaria con git bisect:

   git bisect start
   

2. Marcar el commit actual como "bueno" o "malo" según corresponda:

   git bisect good <commit-hash>
   git bisect bad <commit-hash>
   

3. Git seleccionará automáticamente el próximo commit para verificar.

4. Repetir los pasos 2 y 3 hasta que se encuentre el commit problemático.

5. Finalizar el proceso de búsqueda binaria:

    git bisect reset
   

7. git reflog

El comando git reflog muestra un registro detallado de todas las operaciones que se han realizado en un repositorio, incluyendo cambios de rama y acciones de rebase.

Puede ser útil para recuperar commits perdidos o deshacer cambios.

Para ver el registro de reflog:

1. Ejecutar el comando git reflog:

   git reflog
   

2. Este comando muestra una lista de registros con las operaciones realizadas junto con los identificadores de los commits asociados.

3. Se puede usar esta información para recuperar commits perdidos o realizar otras acciones según sea necesario.

8. git filter-branch

El comando git filter-branch permite reescribir la historia de un repositorio, filtrando commits o realizando otras modificaciones en el historial.

Esto es útil cuando necesita realizar cambios significativos en el historial de un proyecto.

Ejemplo de uso

Supongamos que necesita eliminar un archivo en todos los commits de la rama 'master':

1. Utilizar git filter-branch para realizar la operación deseada:

   git filter-branch --tree-filter 'rm -f path/to/file' master
   

   En el comando anterior git filter-branch permite realizar operaciones personalizadas en cada commit de una rama. tree-filter indica que se realizará una operación en el árbol de trabajo. rm es el comando para eliminar archivos, y -f indica que se eliminará el archivo especificado. path/to/file es la ruta del archivo que se eliminará, y master es la rama en la que se realizará la operación.

2. Esto eliminará el archivo en cada commit de la rama 'master'.

3. Se debe tener en cuenta que este comando reescribirá la historia, por lo que se debe tener cuidado al usarlo en repositorios compartidos.

9. git submodule

El comando git submodule se utiliza para administrar submódulos en un repositorio Git. Los submódulos son repositorios Git independientes que se pueden incluir dentro de otro repositorio.

Para agregar un submódulo a un repositorio existente:

1. Ejecutar el comando git submodule add con la URL del repositorio del submódulo y la ruta donde se almacenará:

   git submodule add https://github.com/ejemplo/repo-submodulo path/to/submodule
   

2. Confirmar los cambios en el repositorio principal.

3. Otros colaboradores pueden inicializar y actualizar los submódulos con:

   git submodule init
   git submodule update
   

4. Para clonar un repositorio con submódulos, se debe usar el comando --recurse-submodules:

   git clone --recurse-submodules https://github.com/ejemplo/repo-principal
   

Conclusión

Estos son algunos comandos avanzados de Git que permiten a los desarrolladores tener un mayor control sobre su historial de cambios y su flujo de trabajo. Es importante comprender bien estos comandos y su impacto en el repositorio antes de utilizarlos en proyectos reales.