← Volver a actividades
Autoevaluación

Autoevaluación: Rebase y buenas prácticas en Git

Rebase y buenas prácticas en Git · 15 min aprox.

Respondé todas las preguntas y presioná Calificar para ver tu puntaje.

1. Estás en feature/carrito y este es el grafo después de git fetch. Ejecutas git rebase origin/main y no hay conflictos. ¿Qué queda en tu rama?
$ git log --oneline --graph --all
* 780488a feat(envio): agrega envío gratis desde 10000
* a39a0ac feat(carrito): calcula el total
| * 7ac78ac fix(envio): actualiza el costo de envío
|/
* 10b4cc8 chore: agrega configuración inicial
Correcto Incorrecto Sin responder

Respuesta correcta: Dos commits nuevos, con los mismos cambios y mensajes pero con hashes nuevos, encima de 7ac78ac: un historial lineal.

¿Por qué? git rebase cambia la base de tu rama: aparta tus commits, mueve la rama a la punta de origin/main y los vuelve a aplicar uno por uno. Los commits reaplicados son commits nuevos, por eso tienen hashes nuevos. No crea un commit de merge ni toca origin/main.

2. Durante un git rebase origin/main con conflicto, lo que aparece entre <<<<<<< HEAD y ======= es la versión de tu commit.
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? Durante un rebase Git se para en la nueva base y trae tus commits, así que HEAD es origin/main (con tus commits ya reaplicados). Tu commit aparece entre ======= y >>>>>>>, identificado por su hash y su mensaje. Es la inversión de "ours" y "theirs" respecto de un merge.

3. El rebase se detuvo con este estado. Ya editaste config.js, borraste los marcadores y ejecutaste git add config.js. ¿Qué haces ahora?
$ git status
interactive rebase in progress; onto 7ac78ac
Last commands done (2 commands done):
   pick a39a0ac # feat(carrito): calcula el total
   pick 780488a # feat(envio): agrega envío gratis desde 10000
No commands remaining.
You are currently rebasing branch 'feature/carrito' on '7ac78ac'.
  (fix conflicts and then run "git rebase --continue")

Unmerged paths:
    both modified:   config.js
Correcto Incorrecto Sin responder

Respuesta correcta: git rebase --continue, sin hacer commit.

¿Por qué? En un rebase no ejecutas git commit: el commit que se está reaplicando ya tiene su mensaje, y git rebase --continue lo termina y sigue con los que queden. --skip descartaría tu commit. Si prefieres no seguir, git rebase --abort devuelve la rama al estado anterior al rebase.

4. Durante un git rebase origin/main, config.js tiene conflicto y quieres quedarte completa con la versión de tu commit. ¿Qué comando usas antes del git add?
Correcto Incorrecto Sin responder

Respuesta correcta: git restore --theirs config.js

¿Por qué? En un rebase, "ours" es origin/main (la nueva base) y "theirs" es tu commit que se está reaplicando. Por eso, para quedarte con tu versión usas --theirs. Después igual tienes que marcar el archivo como resuelto con git add.

5. Si confirmaste y subiste por error una llave de API, basta con borrarla en el commit siguiente para que deje de estar expuesta.
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? El secreto sigue en el historial y cualquiera con acceso al repositorio puede verlo; incluso reescribir el historial no garantiza nada porque otros pueden haberlo copiado. Lo único que realmente te protege es revocar o rotar el secreto de inmediato, y luego dejar de rastrear el archivo y agregarlo a .gitignore.

6. Ya habías subido feature/carrito, hiciste rebase sobre origin/main y ahora el push falla así. Nadie más trabaja en esa rama. ¿Qué haces?
$ git push
To github.com:tu-usuario/tienda.git
 ! [rejected]        feature/carrito -> feature/carrito (non-fast-forward)
error: failed to push some refs to 'github.com:tu-usuario/tienda.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
Correcto Incorrecto Sin responder

Respuesta correcta: git push --force-with-lease, para reemplazar la rama remota por la tuya solo si sigue donde la viste.

¿Por qué? Después de un rebase tus commits tienen hashes nuevos y el remoto todavía tiene los viejos. git pull volvería a traer los commits viejos y los mezclaría con los nuevos. --force a secas borraría sin avisar un commit que alguien hubiera subido; --force-with-lease rechaza el push en ese caso.

7. Puedes hacer rebase de main sin problemas siempre que después lo subas con git push --force-with-lease.
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? La regla de oro dice que nunca hagas rebase de una rama sobre la que otras personas construyen, como main. El rebase reemplaza commits por commits nuevos, y quien ya tenía los viejos tendría que rehacer su trabajo o podría volver a subirlos duplicados. --force-with-lease no evita ese problema.

8. Ejecutaste git rebase -i HEAD~3 y Git abrió esta lista de tareas. Quieres corregir el mensaje del primer commit y absorber "corrige typo" en el segundo, descartando su mensaje. ¿Qué palabras pones al principio de las tres líneas, en orden?
pick fdd62ee # feat(perfil): agrega pagina de perfil
pick 92f548a # feat(perfil): muestra el nombre
pick aa007a1 # corrige typo
Correcto Incorrecto Sin responder

Respuesta correcta: reword, pick, fixup

¿Por qué? reword deja el cambio y te deja editar el mensaje; fixup une el commit al anterior y descarta su mensaje. squash también une, pero te hace combinar los dos mensajes, y drop eliminaría el commit junto con su cambio. La lista va del commit más viejo al más nuevo.

9. Eliminas el endpoint /v1/pedidos y quienes usan tu API deben cambiar su código. ¿Qué mensaje sigue Conventional Commits?
Correcto Incorrecto Sin responder

Respuesta correcta: feat(api)!: elimina el endpoint /v1/pedidos, con un pie BREAKING CHANGE: que explica qué usar en su lugar.

¿Por qué? Un cambio que rompe compatibilidad se marca con ! después del tipo o del alcance y se explica en un pie BREAKING CHANGE:. La descripción va en imperativo o presente, corta y sin punto final. chore es para tareas que no tocan el código de la aplicación, y "varios arreglos" no describe un cambio.

10. git bisect terminó con esta salida. ¿Qué te dice y qué haces a continuación?
$ git bisect bad
001853450c60781a09890b331a08c319a204d843 is the first bad commit
commit 001853450c60781a09890b331a08c319a204d843
Author: Ana <ana@example.com>

    feat(descuentos): agrega descuentos

 config.js   | 2 +-
 discount.js | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
Correcto Incorrecto Sin responder

Respuesta correcta: Que 0018534 es el primer commit con el error, y que además de "descuentos" tocó config.js; ejecutas git bisect reset para volver a tu rama.

¿Por qué? git bisect hace una búsqueda binaria y te informa el primer commit que está mal. Siempre terminas con git bisect reset, que te devuelve a la rama donde estabas. El culpable es un commit no atómico: tocó config.js aunque su mensaje habla de descuentos, y eso escondía el error.

11. El archivo .env ya estaba en un commit. Lo agregas a .gitignore y Git sigue mostrándolo modificado. ¿Qué pasa y qué haces?
$ echo ".env" >> .gitignore
$ git status --short
 M .env
?? .gitignore
Correcto Incorrecto Sin responder

Respuesta correcta: .gitignore solo afecta a archivos sin rastrear; ejecutas git rm --cached .env, que lo saca del índice sin borrarlo de tu disco.

¿Por qué? Ignorar no deja de rastrear: si un archivo ya está en un commit, Git sigue viendo sus cambios. git rm --cached .env lo quita del staging (aparece como D ) y el archivo sigue en tu carpeta; luego confirmas ese cambio junto con .gitignore.

12. Si ya agregaste todos tus cambios con git add, git diff no muestra nada aunque haya cambios listos para confirmar; para verlos usas git diff --staged.
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? git diff compara el working tree contra el staging, no contra el último commit. git diff --staged compara el staging contra el último commit: es lo que va a entrar en el próximo commit. Creer que git diff compara contra el último commit es un error común.