Capítulo 2. Trucos Básicos

Estás a punto de intentar algo drástico? Antes de hacerlo, toma una instantánea de todos los archivos en el directorio actual con:

$ git init
$ git add .
$ git commit -m "Mi primer respaldo"

Ahora, si tu edición se vuelve irrecuperable, ejecuta:

$ git reset --hard

para volver a donde estabas. Para volver a salvar el estado:

$ git commit -a -m "Otro respaldo"

$ git add ARCHIVOSNUEVOS...

$ git rm ARCHIVOSVIEJOS...

$ git mv ARCHIVOVIEJO ARCHIVONUEVO

Algunas veces solo quieres ir hacia atrás y olvidarte de todos los cambios a partir de cierto punto, porque estaban todos mal. Entonces:

$ git log

te muestra una lista de commits recientes, y sus hashes SHA1. A continuación, escribe:

$ git reset --hard SHA1_HASH

para recuperar el estado de un commit dado, y borrar para siempre cualquier recuerdo de commits más nuevos.

Otras veces, quieres saltar a un estado anterior temporalmente. En ese caso escribe:

$ git checkout SHA1_HASH

Esto te lleva atrás en el tiempo, sin tocar los commits más nuevos. Sin embargo, como en los viajes en el tiempo de las películas de ciencia ficción, estarás en una realidad alternativa, porque tus acciones fueron diferentes a las de la primera vez.

Esta realidad alternativa se llama branch (rama), y tendremos más cosas para decir al respecto luego. Por ahora solo recuerda que

$ git checkout master

te llevará al presente. También, para que Git no se queje, siempre haz un commit o resetea tus cambios antes de ejecutar checkout.

Para retomar la analogía de los videojuegos:

Puedes elegir el restaurar solo archivos o directorios en particular, al agregarlos al final del comando:

$ git checkout SHA1_HASH algun.archivo otro.archivo

Ten cuidado, esta forma de checkout puede sobreescribir archivos sin avisar. Para prevenir accidentes, haz commit antes de ejecutar cualquier comando de checkout, especialmente cuando estás aprendiendo a usar Git. En general, cuando te sientas inseguro del resultado de una operación, sea o no de Git, ejecuta antes git commit -a.

¿No te gusta cortar y pegar hashes? Entonces usa:

$ git checkout :/"Mi primer r"

para saltar al commit que comienza con el mensaje dado.

También puedes pedir el 5to estado hacia atrás:

$ git checkout master~5

$ git commit -a
$ git revert SHA1_HASH

Obtén una copia de un proyecto administrado por git escribiendo:

$ git clone git://servidor/ruta/a/los/archivos

Por ejemplo, para bajar todos los archivos que usé para crear este sitio:

$ git clone git://git.or.cz/gitmagic.git

Pronto tendremos más para decir acerca del comando clone.

Si ya descargaste una copia de un proyecto usando git clone, puedes actualizarte a la última versión con:

$ git pull

Imagina que has escrito un script que te gustaría compartir con otros. Puedes decirles que simplemente lo bajen de tu computadora, pero si lo hacen mientras estás haciendo una modificación, pueden terminar en problemas. Es por esto que existen los ciclos de desarrollo. Los programadores pueden trabajar en un proyecto de manera frecuente, pero solo hacen público el código cuando consideran que es presentable.

Para hacer esto con Git, en el directorio donde guardas tu script:

$ git init
$ git add .
$ git commit -m "Primer lanzamiento"

Entonces puedes decirle a tus usuarios que ejecuten:

$ git clone tu.maquina:/ruta/al/script

para descargar tu script. Esto asume que tienen acceso por ssh. Si no es así, ejecuta git daemon y dile a tus usuarios que usen:

$ git clone git://tu.maquina/ruta/al/script

De ahora en más, cada vez que tu script esté listo para el lanzamiento, escribe:

$ git commit -a -m "Siguiente lanzamiento"

y tus usuarios puede actualizar su versión yendo al directorio que tiene tu script y ejecutando:

$ git pull

Tus usuarios nunca terminarán usando una versión de tu script que no quieres que vean. Obviamente este truco funciona para lo que sea, no solo scripts.

Averigua que cambios hiciste desde el último commit con:

$ git diff

O desde ayer:

$ git diff "@{yesterday}"

O entre una versión en particular y 2 versiones hacia atrás:

$ git diff SHA1_HASH "master~2"

En cada caso la salida es un patch (parche) que puede ser aplicado con git apply Para ver cambios desde hace 2 semanas, puedes intentar:

$ git whatchanged --since="2 weeks ago"

Usualmente recorro la historia con qgit , dada su interfaz pulida y fotogénica, o tig, una interfaz en modo texto que funciona bien a través conexiones lentas. Como alternativa, puedes instalar un servidor web, ejecutar git instaweb y utilizar cualquier navegador web.

Siendo A, B, C, y D cuatro commits sucesivos, donde B es el mismo que A pero con algunos archivos eliminados. Queremos volver a agregar los archivos en D pero no en B. ¿Cómo podemos hacer esto?

Hay por lo menos tres soluciones. Asumiendo que estamos en D:

¿Cuál alternativa es la mejor? Cualquiera que prefieras. Es fácil obtener lo que quieres con Git, y normalmente hay varias formas de hacerlo.