Regresar a un commit anterior en Git

Muchas veces, nos damos cuenta de que necesitamos regresar en el tiempo  a un punto de nuestro proyecto, para ello el comando checkout nos permite  regresar a un commit anterior en Git,  de esta manera:

git checkout 766abcd

766abcd, es el identificador del commit al que deseamos regresar. Esta operación, si lo hacemos desde  una rama, no afectará a otras, de modo que puedes hacer diferentes commit a partir de ese punto, sin que se modifiquen otras ramas  del proyecto. 

Existen diferentes formas de retroceder en el tiempo a commits previos, checkout es una de ellas, pero tambien se utiliza reset con sus atributos soft o hard

Con una sintaxis como:

git reset—soft referencia del commit

Esto nos permitirá retroceder a un commit previo, manteniendo los cambios:

git reset—soft 568abcj

Si queremos deshacer solo el ultimo:

git reset—soft HEAD~

Si lo que se desea es eliminar permanentemente los cambios realizado después de un commit  específico, el comando a usar es:

git reset—hard 789abcd

Si queremos eliminar los cambios después del ultimo commit lo que hacemos es usar el atributo hard del comando reset, pero dirigiéndolo al apuntador especial HEAD. 

git reset—hard HEAD~

para descartar los cambios antes de retornar a un commit, se utiliza el comando stash

git commit stash

Debemos recordar siempre que poseemos una valiosa herramienta, para obtener información sobre el estado y la estructura del árbol del proyecto, que es el comando log.  

Ver mas sobre Git

Podemos ver la estructura de los últimos commit con este comando

git log --oneline 

Su salida, será algo como esto

8674e5f commit  test3
jº44568 commit segunda parte 
55df4c2 commit de inicio. 

El conocimieno y el uso de log con sus diferente posibilidades, nos permitirá manejar acertadamente, la creación de ramas, los movimientos entre ellas y los avances y retrocesos entre commits.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

Subir montañas hermana hombres……

Git, el concepto de branch

Sabemos que Git nos ofrece un sistema de ramas o  branchs,  que  al igual que otras herramientas de control de versiones, soporta la administración de ramificaciones en los proyectos.

Sin ánimo de ahondar demasiado, digamos que la diferencia básica que Git aporta, es que en vez de crear un directorio adicional para guardar una nueva rama, lo hace de forma inmediata sin crear nuevos directorios,  almacenando solo copias instantáneas, de como está el archivo en ese momento, junto a  los nodos padres, lo cual también es una gran ventaja, al momento de gestionar la fusión entre las ramas con que contamos.

¿Que son las ramas?

Podríamos decir, si queremos ser muy escuetos que:  una rama  en Git es solo  un apuntador en movimiento que redirige a su respectivo commit.

Lo explico así: al  iniciar un proyecto y hacer tu primer commit, estas creando una rama principal de trabajo, también llamada master.

A medida que creas tu código,  y vas avanzando buscando una solución, tal vez necesites caminos alternativos, que te lleven a determinado punto y hasta tanto  no lo alcances, no   querrás  incorporarlo a lo que has hecho en tu rama principal, incluso pudiera ser que nunca alcances ese punto, y simplemente necesites regresar adonde estabas antes.

Esto es posible hacerlo creando ramas de trabajo, o sea cada vez que creas una alternativa, podemos decir que estás trabajando en una rama, si a eso unimos, que sobre el propio proyecto, pueden estar trabajando diferentes integrantes de un equipo, tendremos varias ramificaciones, y al mismo tiempo  si cada uno de ellos quiere probar nuevas rutas para buscar un resultado  esperado, entonces crearán nuevas ramas, en un mismo árbol de proyecto.

Lo que hace a Git superior a otros,  es el modo rápido y eficaz en que maneja las ramificaciones, haciendo el avance o el retroceso entre distintas ramas, algo ágil , cómodo y sencillo, lo cual facilita   que durante el  desarrollo, las ramas puedan crearse y unirse entre si, tantas veces como necesitemos.

Es fácil entender entonces, que este enorme potencial es de gran ayuda, para agilizar y fortalecer el modo en que creamos código.  

El valor  del Commit

Al escribir git add . estas indicando a git que pase tus archivos a la zona conocida como stage, pero  lo que sucede realmente es que  se ejecuta una suma de control de ellos, en 40 caracteres (un resumen SHA-1), y se  almacena un blob (copia) de cada uno en el repositorio,  guardando cada suma de control, en el área de preparación (staging area):

Al crear una orden de confirmación  commit, estamos diciéndole a Git  que aceptamos  que los cambios añadidos previamente con el add al  área stage,  sean procesados,  y lo que hará el sistema es crear  y almacenar una impresión  del código de ese momento, con un grupo de metadatos explicativos como los que recoge la opción –m.

Nuestro commit, también creará un apuntador hacia esta impresión instantánea (piensa en una foto de ese momento), que permitirá identificarla, retornarla, o unirla a otra; o los apuntadores podrían ser varios, si lo que hay detrás de nuestro commit, es un merge que une varias ramas.

Suponiendo que estuvieras  trabajando con 5 subdirectorios, lo que sucederá al hacer commit es que Git realizará  sumas de cada uno, que  guardará  como objetos árbol en el repositorio Git y creará un objeto de confirmación con los metadatos y  además un apuntador al objeto árbol de la raíz del proyecto.

Hecho esto,  ahora  habría 7 objetos en el repositorio de tu proyecto, los 5 blobs, un árbol que no es más que la lista estructurada de lo  que contiene el repositorio, y la confirmación  de los cambios que el commit procesó  y que apunta directamente  a la raíz del árbol.

Entonces, si decides hacer más cambios y confirmarlos, el siguiente commit también tendrá un apuntador que se dirige al commit previo, de esa manera queda encadenado a la versión anterior y así sucesivamente.

 Por tanto, la  rama se mantiene en movimiento avanzando en cada commit, ese desplazamiento comienza al crear  la rama principal master, con el primer commit.

 ¿Cómo se crea una rama?

El comando utilizado para crear una rama es :

git branch nombre de la rama

Este comando lo que hará será crear un nuevo apuntador, disponible para que dirija al ultimo commit que has realizado.

Para crear la rama nuevo_test, escribe:  

$ git branch nuevo_test

El nuevo apuntador, dirigirá  al commit en el que estés. 

Aunque pueda parecer complicado, no lo es.

En este punto, habrá dos ramas, cada una con su apuntador que refieren al mismo commit, sin embargo la magia está en que existe un apuntador llamado HEAD, con una labor especial que es la de apuntar a la rama local en la que te encuentres, en este caso master, pues aunque se creó la rama nuevo_test, con el comando branch, aun no se ha entrado a ella.

El comando que maneja los logs, y que debemos tener siempre a mano para saber cómo vamos, y entre otras cosas, la estructura de nuestro árbol de proyecto:   git log , en su opción --decorate nos mostrará la estructura

Por ejemplo nos devolverá algo como esto

$ git log --oneline --decorate
g40ac (HEAD, master, nuevo_test) add feature ………. 

Donde g40ac  será el commit al que apuntan ambas ramas. 

Moviendose entre ramas

Para moverse de una rama a la otra el comando a usar es :

git checkout 

y la sintaxis si queremos ir a la rama nuevo_test es :

$ git checkout nuevo_test

Ahora el apuntador se apuntará a la rama nuevo_test

Si hacemos ahora un commit

$ git commit -a -m 'primer cambio'

Y corremos nuevamente log --decorate veremos que la rama nuevo_test apunta al  nuevo commit junto al apuntado HEAD.

 Si queremos regresar a la rama master, utilizaremos igualmente checkout, al hacerlo, se moverá nuevamente el apuntador HEAD a la rama master, y restituirá los archivos  dejándolos tal y como estaban en el último commit de esa rama principal.

Esto, no es otra cosa que rebobinar el proyecto, dando marcha atrás en el tiempo, por tanto  los cambios que hagas en adelante, serán diferentes de la versión anterior  del proyecto.  

Otro aspecto importante de Git,  es que si no es capaz de realizar este rebobinado de un modo limpio, o sea si no puede recuperar la impresión exacta del ultimo commit, no permitirá hacer el checkout.

En definitiva para moverte entre ramas los comando son tres, branch que crea la rama, commit que la confirma y checkout que te permite saltar de una a otra

Por supuesto al saltar entre ramas, cada  rama  tendrá diferencias en tu labor, para ver las diferencias podemos usar el comando log de este modo:

 git log --oneline --decorate --graph –all

Esto mostrará el historial de los commit, indicando dónde están los apuntadores de cada ramas y como ha variado el historial.

Si ahora analizamos lo que dijimos al inicio, sobre el modo en que se compone una rama, desde el punto de vista estructural, comprenderemos porque una rama Git es un simple archivo, con  los 40 caracteres de una suma de control SHA-1,  vinculado a un commit específico.

De ahí su simpleza,  velocidad y  eficiencia.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

 ….un sueño es casi todo  y más que  nada;  más que todo al soñarlo, casi nada después……

Git, comandos mas importantes

Los comandos  más  importantes de Git, son aquellos que nos ayudan a crear nuestro repositorio, actualizarlo y publicarlo, permitiéndonos su total control, seamos freelance o un equipo de trabajo.

Resumiendo como trabaja git, diré que :

Git controla versiones  en un repositorio local, siguiendo una estructura de edición, preparación y confirmación de acciones sobre el.

Cuando estas programando y estas listo para añadir cambios los preparas con git add . que los coloca en estado stage, o sea  como una copia instantánea lista, la cual solo valdrá si la confirmas con git commit, o será rechazada si la deshaces con git reset. Esta confirmación se guardará  en el historial de proyecto y será entonces si tienes un repositorio remoto cuando usaras git push para enviarlo allí.

No voy a ahondar mucho mas en el tema teorico de que  es git, ni porque se necesitas, o no.

Lo cierto es que si trabajas  en proyectos cortos, tu solo, y manejas bien las versiones de lo que haces con las carpetas en tu ordenador,  bien documentadas,  no lo necesitas obligatoriamente, sin embargo si desarrollas junto a un grupo de desarrolladores, con muchos cambios y participación en el código, manejos de variantes,  etc , git es una excelente opción.

Los comandos que muestro aquí son solo unos pocos, pero que te permitirán saber como funciona git  de modo básico y espero que útil.

Asumo que has instalado git que no tiene mayores complicaciones y estás en la consola.

Git init

Ve hastas la carpeta  donde esta tu código y escribe

git  init 

Te creará un repositorio creará un repositorio local vacio,  dentro de la carpeta donde tenemos el proyecto, con un mensaje como este

 Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra
 $ git init 
 Initialized empty Git repository in H:/desarrollo/sierra_maestra/.git/ 

Al mismo tiempo se habrá creado una  carpeta oculta llamada .git, que  es la encargada de gestionar el repositorio que acabamos de crear. Si quieres dejar de utilizar git, borra esa carpeta y listo, si quieres volver a utilizarlo vuelve a crear el repositorio con : git init

Para ver las carpetas ocultas utiliza el comando:  ls -a.

 Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ ls -a
  ./.git/js/'plantilla sierra maestra V1.html' 
 ../css/'Plantilla pag web 1.psd'   plantilla-sierra-maestra-1.jpg 

Para conocer el estado del repositorio, los commit realizados , escribe

git status

El resultado como no has hecho nada aun en el repositorio será:

  Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ git status
 On branch master
  
 No commits yet
  
 Untracked files:
   (use "git add <file>..." to include in what will be committed)
         Plantilla pag web 1.psd
         css/
         js/
         plantilla sierra maestra V1.html
         plantilla-sierra-maestra-1.jpg
  
 nothing added to commit but untracked files present (use "git add" to track) 

Lo primero que vemos es “On branch master” esto significa que estamos en la rama principal, es la rama por defecto cuando creamos un repositorio.Git tiene dos procesos para gestionar nuestros archivos. Primero los tenemos que añadir a una zona intermedia conocida como stage y después tenemos que confirmar el paso  definitivo de los archivos al repositorio.

Nota:

Branch : rama de proyecto, puedes crear tantas como desees, y después desecharlas o llevarlas  al proyecto

Master: rama original  y principal del proyecto y la que ese establece por defecto.

git add

git add .

Importante: Hay que dejar un espacio entre add y el punto”

Con este comando le decimos a git que pase todos los archivos que estén sin pasar al estado stage.

 Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ git add .
 warning: LF will be replaced by CRLF in css/bootstrap-grid.css. The file will have its original line endings in your working directory
 warning: LF will be replaced by CRLF in css/bootstrap-grid.min.css.
 The file will have its original line endings in your working directory
 warning: LF will be replaced by CRLF in css/bootstrap-reboot.css.
 The file will have its original line endings in your working directory
 warning: LF will be replaced by CRLF in css/bootstrap-reboot.min.css. ...........

Si ahora volvemos ejecutar el comando git status obtendremos algo como esto:

  Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ git status
 On branch master
  
 No commits yet
  
 Changes to be committed:
   (use "git rm --cached <file>..." to unstage)
         new file:   Plantilla pag web 1.psd
         new file:   css/bootstrap-grid.css
         new file:   css/bootstrap-grid.css.map
         new file:   css/bootstrap-grid.min.css
         new file:   css/bootstrap-grid.min.css.map
         new file:   css/bootstrap-reboot.css
         new file:   css/bootstrap-reboot.css.map
      .............

git commit  

Para confirmar estos archivos y que pasen  definitivamente al  repositorio,  utilizamos como ya dijimos  commit .

Utilizamos el parámetro -m para indicarle una descripción del commit que vamos a hacer, en este caso le decimos que es el commit inicial del proyecto.

 Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ git commit -m "Commit inicial del proyecto"
 [master (root-commit) 9e33f1e] Commit inicial del proyecto
  25 files changed, 36210 insertions(+)
  create mode 100644 Plantilla pag web 1.psd
  create mode 100644 css/bootstrap-grid.css
  create mode 100644 css/bootstrap-grid.css.map
  create mode 100644 css/bootstrap-grid.min.css
  create mode 100644 css/bootstrap-grid.min.css.map
  create mode 100644 css/bootstrap-reboot.css
  create mode 100644 css/bootstrap-reboot.css.map
  create mode 100644 css/bootstrap-reboot.min.css
  create mode 100644 css/bootstrap-reboot.min.css.map
  create mode 100644 css/bootstrap.css
  create mode 100644 css/bootstrap.css.map
.............

Si no indicamos el parámetro -m se abrirá un editor de código de terminal  que hayamos definido como editor por defecto puede ser Vim u otro, deberemos escribir  el mensaje Si volvemos a ejecutar el comando git status obtendremos este mensaje:

 Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master)
 $ git status
 On branch master
 nothing to commit, working tree clean 

Esto significa que no hay nada para confirmar, es decir que todos los archivos se encuentran ya en el repositorio.

En resumen

git  add: Añade modificaciones al codigo

commit:  Confirma las modificaciones en el código.

Usa: git commit -m”comentarios sobre el commit”  como buena practica

Push:  añadir un proyecto, código o modificación al repositorio externo, por ejemplo github

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…., si avanzo sígueme, si me detengo empújame, si retrocedo mátame…….