Como trabajar con varias versiones de un mismo archivo con Git

A todos nos ha pasado que queremos recuperar algo que hemos borrado o corregido de un trabajo que estamos haciendo, le pasa al programador que esta desarrollando un Sistema, al diseñador gráfico que esta creando un nuevo logo o a la secretaria que esta redactando un documento, nos pasa a todos, pero, con el sistema de control de versiones Git, lo podemos solucionar.

Un método que suele utilizar mucha gente es copiar los archivos a otro directorio (quizás indicando la fecha y hora en que lo hicieron, si son avispados). Este enfoque es muy común porque es muy simple, pero también tremendamente propenso a errores. Es fácil olvidar en qué directorio te encuentras, y guardar accidentalmente en el archivo equivocado o sobrescribir archivos que no querías.

¿Qué es el control de versiones, y por qué debería importarte? El control de versiones es un sistema que registra los cambios realizados sobre un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante. A pesar de ser muy usado por los programadores, cualquier tipo de archivo que encuentres en un ordenador puede ponerse bajo control de versiones.

Explicaremos paso a paso como implementar el control de versiones en nuestro ordenador para guardar un registros de los cambios de los trabajos que estemos realizando.

Instalar Git

Git (pronunciado «guit»² ) es un software de control de versiones diseñado por Linus Torvalds, creador del del kernel de linux. Instalar en Windows es muy fácil, descarga el archivo exe del instalador y ejecútalo:

https://git-for-windows.github.io/

Una vez instalado, tendrás tanto la versión de línea de comandos (incluido un cliente SSH) como la interfaz gráfica de usuario estándar. Nosotros trabajaremos con la versión Git Bash como se indica en la imagen.

Configurar Git por primera vez

Ahora que tienes Git en tu sistema, querrás hacer algunas cosas para personalizar tu entorno de Git. Sólo es necesario hacer estas cosas una vez; se mantendrán entre actualizaciones. También puedes cambiarlas en cualquier momento volviendo a ejecutar los comandos correspondientes.

Tu identidad

Lo primero que deberías hacer cuando instalas Git es establecer tu nombre de usuario y dirección de correo electrónico. Esto es importante porque las confirmaciones de cambios (commits) en Git usan esta información, y es introducida de manera inmutable en los commits que envías:

$ git config --global user.name "Marcos Sarmiento"
 $ git config --global user.email marcossarmiento@example.com

Comprobando tu configuración

Si quieres comprobar tu configuración, puedes usar el comando git config --list para listar todas las propiedades que Git ha configurado:

$ git config –list

user.name=Scott Chacon
user.email=schacon@gmail.com 
color.status=auto
color.branch=auto
color.interactive=auto
color.diff=auto 
...

También puedes comprobar qué valor cree Git que tiene una clave específica ejecutando git config {clave}:

$ git config user.name
Marcos Sarmiento

Obteniendo un repositorio Git

1. Si estás empezando el seguimiento en Git de un proyecto o un archivo existente, necesitas ir al directorio donde se encuentra el proyecto o el archivo y escribir:

$ git init

Esto crea un nuevo subdirectorio llamado .git que contiene todos los archivos necesarios del repositorio (si estamos iniciando, lo hara en el directorio master)

2. Empezar a controlar versiones de archivos existentes

1. Especificar el o los archivos que queremos realizar el seguimiento (podemos usar comodines)

$ git add <nombre de archivo>
           *.c
           . <todos los archivos>

2. Confirmar los cambios

$ git commit -m "versión inicio del proyecto"           

3. Crear una nueva rama (git crea la rama master por defecto al inicializar el repositorio)

$ git branch gitdocument1

4. Pasar de una rama a otra. Hagamos una prueba pasando a la rama gitdocument1 recién creada.

$ git checkout gitdocument1

5. Al abrir el documento de word en la nueva rama veremos el misma información. Agregamos una linea más a nuestro documento y guardamos los cambios.

6. Volvemos a la rama master donde se encuentra nuestro documento original y revisamos la información.

$ git checkout master

Al revisar el documento en la rama master, podemos confirmar que tiene la información orginal sin la ultima linea que hemos agregado

7. Regresamos a la rama que recién creamos gitdocument1

$ git checkout gitdocument

Podemos confirmar que la linea que agregamos sigue ahi

8. Fusionamos las dos ramas incorporando las cambios de la rama gitdocument1

$ git checkout master
 $ git merge gitdocument1

9. Después de fusionar la información de las dos ramas, eliminamos la rama que creamos porque ya no la necesitamos, ahora todo se encuentra en la rama master.

$ git branch -d gitdocument1

Siguiendo estos nueve pasos podremos guardar un registro de los cambios que estemos realizando nuestro archivo y no perder lo ya avanzando, el próximo paso a seguir seria alojar estos cambios en un repositorio en la web y en nuestros próximos artículos hablaremos de las opciones con las que contamos actualmente.