es/basic.txt

   1 == Trucos Básicos ==
   2
   3 En lugar de sumergirte en un mar de comandos de Git, usa estos ejemplos elementales para mojarte los pies. A pesar de sus simplicidad, todos son útiles.
   4 De hecho, en mis primeros meses con Git nunca fui más allá del material en este capítulo.
   5
   6 === Guardando Estados ===
   7
   8 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:
   9
  10  $ git init
  11  $ git add .
  12  $ git commit -m "My first backup"
  13
  14 Ahora, si tu edición se vuelve irrecuperable, ejecuta:
  15
  16  $ git reset --hard
  17
  18 para volver a donde estabas. Para volver a salvar el estado:
  19
  20  $ git commit -a -m "Otro respaldo"
  21
  22 ==== Agrega, Elimina, Renombra ====
  23
  24 El comando anterior solo seguirá la pista de los archivos que estaban presentes la primera vez que ejecutaste *git add*. Si añades nuevos archivos o subdirectorios, deberás decirle a Git:
  25
  26  $ git add ARCHIVOSNUEVOS...
  27
  28 De manera similar, si quieres que Git se olvide de determinados archivos, porque (por ejemplo) los borraste:
  29
  30  $ git rm ARCHIVOSVIEJOS...
  31
  32 Renombrar un archivo es lo mismo que eliminar el nombre anterior y agregar el nuevo. También puedes usar *git mv* que tiene la misma sintaxis que el comando *mv*. Por ejemplo:
  33
  34  $ git mv ARCHIVOVIEJO ARCHIVONUEVO
  35
  36 === Deshacer/Rehacer Avanzado ===
  37
  38 Algunas veces solo quieres ir hacia atrás y olvidarte de todos los cambios a partir de cierto punto, porque estaban todos mal. Entonces:
  39
  40  $ git log
  41
  42 te muestra una lista de commits recientes, y sus hashes SHA1. A continuación, escribe:
  43
  44  $ git reset --hard SHA1_HASH
  45
  46 para recuperar el estado de un commit dado, y borrar para siempre cualquier recuerdo de commits más nuevos.
  47
  48 Otras veces, quieres saltar a un estado anterior temporalmente. En ese caso escribe:
  49
  50  $ git checkout SHA1_HASH
  51
  52 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.
  53
  54 Esta realidad alternativa se llama 'branch' (rama), y <<branch,tendremos más cosas para decir al respecto luego>>. Por ahora solo recuerda que
  55
  56  $ git checkout master
  57
  58 te llevará al presente. También, para que Git no se queje, siempre haz un commit o resetea tus cambios antes de ejecutar checkout.
  59
  60 Para retomar la analogía de los videojuegos:
  61
  62 - *`git reset \--hard`*: carga un juego viejo y borra todos los que son mas nuevos que el que acabas de cargar.
  63
  64 - *`git checkout`*: carga un juego viejo, pero si continúas jugando, el estado del juego se desviará de los juegos que salvaste la primera vez. Cualquierpartido nuevo que guardes, terminará en una branch separada, representando la realidad alternativa a la que entraste. <<branch,Luego nos encargaremos de esto>>
  65
  66 Puedes elegir el restaurar solo archivos o directorios en particular, al agregarlos al final del comando:
  67
  68
  69  $ git checkout SHA1_HASH algun.archivo otro.archivo
  70
  71 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*.
  72
  73 ¿No te gusta cortar y pegar hashes? Entonces usa:
  74
  75  $ git checkout :/"Mi primer r"
  76
  77 para saltar al commit que comienza con el mensaje dado.
  78
  79 También puedes pedir el 5to estado hacia atrás:
  80
  81  $ git checkout master~5
  82
  83 ==== Revirtiendo  ====
  84
  85 En una corte, los eventos pueden ser eliminados del registro. Igualmente, puedes elegir commits específicos para deshacer.
  86
  87  $ git commit -a
  88  $ git revert SHA1_HASH
  89
  90 va a deshacer solo el commit con el hash dado. Ejecutar *git log* revela que el revert es registrado como un nuevo commit.
  91
  92 === Descargando Archivos ===
  93
  94 Obtén una copia de un proyecto administrado por git escribiendo:
  95
  96  $ git clone git://servidor/ruta/a/los/archivos
  97
  98 Por ejemplo, para bajar todos los archivos que usé para crear este sitio:
  99
 100  $ git clone git://git.or.cz/gitmagic.git
 101
 102 Pronto tendremos más para decir acerca del comando *clone*.
 103
 104 === Lo Más Nuevo ===
 105
 106 Si ya descargaste una copia de un proyecto usando *git clone*, puedes actualizarte a la última versión con:
 107
 108  $ git pull
 109
 110 === Publicación Al Instante ===
 111
 112 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.
 113
 114 Para hacer esto con Git, en el directorio donde guardas tu script:
 115
 116  $ git init
 117  $ git add .
 118  $ git commit -m "Primer lanzamiento"
 119
 120 Entonces puedes decirle a tus usuarios que ejecuten:
 121
 122  $ git clone tu.maquina:/ruta/al/script
 123
 124 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:
 125
 126  $ git clone git://tu.maquina/ruta/al/script
 127
 128 De ahora en más, cada vez que tu script esté listo para el lanzamiento, escribe:
 129
 130  $ git commit -a -m "Siguiente lanzamiento"
 131
 132 y tus usuarios puede actualizar su versión yendo al directorio que tiene tu script y ejecutando:
 133
 134  $ git pull
 135
 136 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.
 137
 138 === Que es lo que hice? ===
 139
 140 Averigua que cambios hiciste desde el último commit con:
 141
 142  $ git diff
 143
 144 O desde ayer:
 145
 146  $ git diff "@{yesterday}"
 147
 148 O entre una versión en particular y 2 versiones hacia atrás:
 149
 150  $ git diff SHA1_HASH "master~2"
 151
 152 En cado caso la salida es un patch (parche) que puede ser aplicado con *git apply*
 153 Para ver cambios desde hace 2 semanas, puedes intentar:
 154
 155  $ git whatchanged --since="2 weeks ago"
 156
 157 Usualmente recorro la historia con http://sourceforge.net/projects/qgit[qgit]
 158 , dada su interfaz pulida y fotogénica, o http://jonas.nitro.dk/tig/[tig], una interfaz en modo texto
 159 que funciona bien a través conexiones lentas. Como alternativa, puedes instalar un servidor web,
 160 ejecutar *git instaweb* y utilizar cualquier navegador web.
 161
 162 === Ejercicio ===
 163
 164 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?
 165
 166 Hay por lo menos tres soluciones. Asumiendo que estamos en D:
 167
 168   1. La diferencia entre A y B son los archivos eliminados. Podemos crear un patch representando esta diferencia y aplicarlo:
 169
 170    $ git diff B A | git apply
 171
 172   2. Como en A tenemos los archivos guardados, podemos recuperarlos :
 173
 174    $ git checkout A ARCHIVOS...
 175
 176   3. Podemos ver el pasaje de A a B como un cambio que queremos deshacer:
 177
 178    $ git revert B
 179
 180 ¿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.