Git ofrece una serie de comandos avanzados que son extremadamente útiles para manejar situaciones más complejas, como rastrear errores, identificar qué desarrollador realizó un cambio específico, trabajar con subproyectos y recuperar commits perdidos. A continuación, desarrollaremos algunos de estos comandos avanzados y su aplicación práctica.

Uso de `git bisect` para encontrar errores

El comando git bisect es una herramienta poderosa que te ayuda a encontrar cuándo se introdujo un error en el historial del proyecto. Utiliza un algoritmo de búsqueda binaria para identificar el commit que introdujo el problema al revisar de manera eficiente el historial de commits.

Cómo funciona:

Inicia la búsqueda binaria con git bisect:
```
1git bisect start
```
Marca el commit actual como malo (donde el error está presente):
```
1git bisect bad
```

Marca un commit conocido como bueno (donde el código funcionaba correctamente):

1git bisect good <commit-id>

Git cambiará el proyecto a un commit intermedio. En este punto, debes probar si el error está presente en ese commit.
Si el error está presente, marca el commit como malo:
```
1git bisect bad
```
Si el error no está presente, marca el commit como bueno:
```
1git bisect good
```
Git continuará dividiendo el rango de commits hasta encontrar el commit exacto que introdujo el error.
Una vez identificado el commit, puedes finalizar el proceso con:
```
1git bisect reset
```

Ventajas de git bisect:

Acelera el proceso de encontrar errores en un historial largo de commits.
Reduce la cantidad de commits que necesitas revisar manualmente.

`git blame`: Rastrear cambios por autor

El comando git blame se utiliza para identificar quién hizo cada cambio en un archivo específico. Muestra la información línea por línea, indicando qué commit y autor modificaron cada línea del archivo.

Uso:

Para ver quién modificó cada línea de un archivo:

1git blame <archivo>

¿Qué muestra?

El comando muestra la siguiente información para cada línea:

El hash del commit que introdujo el cambio.
El autor que hizo el cambio.
La fecha y hora del cambio.
El contenido de esa línea.

Ejemplo:

1git blame archivo.txt

El resultado será algo similar a esto:

f56a4f20 (Juan Perez  2023-05-12 10:13:42 +0200  1)   Línea de código 1
a8f4c872 (María Gomez 2023-04-20 14:25:18 +0200  2)   Línea de código 2

Esto te permite identificar rápidamente quién realizó cambios en un archivo y cuándo se hicieron, lo que es útil para entender el historial de modificaciones y para encontrar posibles causas de errores.

Submódulos de Git: Qué son y cómo usarlos

Los submódulos de Git permiten incluir un repositorio de Git dentro de otro repositorio. Son útiles cuando deseas mantener un proyecto separado dentro de otro, pero seguir actualizando y controlando versiones del subproyecto de forma independiente.

¿Cuándo usar submódulos?

Cuando tienes dependencias entre proyectos que deseas mantener separadas pero vinculadas.
Para reutilizar un repositorio dentro de varios proyectos sin duplicar el código.

Agregar un submódulo

Para añadir un submódulo en tu repositorio principal, usa:

1git submodule add <url-del-repositorio>

Git creará un directorio dentro de tu proyecto que contendrá el contenido del submódulo.

Clonar un repositorio con submódulos

Cuando clonas un repositorio que contiene submódulos, debes ejecutar el siguiente comando para inicializar y clonar los submódulos:

1git submodule update --init

Actualizar submódulos

Para actualizar un submódulo a su última versión, entra en el directorio del submódulo y ejecuta:

1git pull

`git cherry-pick`: Aplicar commits específicos

El comando git cherry-pick se utiliza para aplicar un commit específico de una rama a otra. Es útil cuando quieres llevar un cambio particular de una rama a otra sin fusionar toda la rama.

Uso:

Para aplicar un commit específico a tu rama actual:

1git cherry-pick <commit-hash>

Ejemplo:

Supón que quieres aplicar un commit de la rama feature-x a tu rama main. Encuentra el hash del commit que deseas y luego ejecútalo en main:

1git checkout main
2git cherry-pick f56a4f20

Git aplicará el commit identificado por f56a4f20 en main. Esto te permite elegir selectivamente qué cambios llevar de una rama a otra sin hacer una fusión completa.

Resolución de conflictos en `cherry-pick`

Si el commit que estás aplicando entra en conflicto con los cambios en la rama actual, Git te pedirá que resuelvas los conflictos de manera similar a una fusión (merge). Una vez resueltos, puedes continuar con el cherry-pick:

1git cherry-pick --continue

`git reflog`: Recuperar commits perdidos

El comando git reflog registra todas las acciones que cambian el puntero HEAD, incluyendo commits, resets, checkouts y fusiones. Esto te permite recuperar commits que parecen haber sido "perdidos" (por ejemplo, después de un reset o un merge conflict mal resuelto).

Ver el historial de `HEAD`

Para ver el historial de todas las acciones realizadas en el repositorio, usa:

1git reflog

Ejemplo de uso:

1git reflog

El resultado será algo como:

a8f4c872 HEAD@{0}: commit: Añadir nueva funcionalidad
f56a4f20 HEAD@{1}: reset: moving to HEAD^
1d3a56f2 HEAD@{2}: commit: Solucionar error en página principal

Cada entrada en reflog muestra una referencia al commit anterior con un índice (HEAD@{n}). Si accidentalmente eliminaste un commit o hiciste un reset incorrecto, puedes usar el hash del commit anterior para recuperarlo.

Recuperar un commit perdido:

Si quieres volver a un commit perdido, puedes hacer un checkout a un commit específico del reflog:

1git checkout <commit-hash>

O bien, si quieres mover HEAD de vuelta a ese commit:

1git reset --hard <commit-hash>

Resumen

Git proporciona una serie de comandos avanzados para manejar situaciones complejas y mejorar el control sobre el historial de commits. Con git bisect, puedes encontrar rápidamente el commit que introdujo un error, mientras que git blame te permite rastrear qué desarrollador realizó cambios específicos en un archivo. Los submódulos permiten incluir repositorios dentro de otros proyectos, y git cherry-pick te permite aplicar commits específicos a otra rama sin realizar una fusión completa. Finalmente, git reflog es una herramienta crucial para recuperar commits que parecen haber sido perdidos.

Curso git nivel medio