PDF de programación - Guía de referencia rápida a GIT

Guía de referencia rápida a Git

George Vega Yon

26 de marzo de 2012

Resumen

Git es un sistema de control de versiones que permite administrar de manera eficiente y
rápida grandes proyectos, en particular, de software manteniendo una historia y registro de
modificaciones a los archivos que permite estar al tanto de la evolución del proyecto y, a su
vez, rescatar versiones anteriores si la circunstancia así lo requiere. Este documento trata de
introducir al usuario que entra por primera vez al mundo de los sistemas de control de versión.

1.

Introducción

Si bien Git es mayormente utilizado en el desarrollo de software, la academia podría gozar am-
pliamente de sus capacidades tales como reestablecimiento de versiones anteriores– lo que evitaría
manejar múltiples archivos tratando de resguardar versiones estables–, administración de proyectos
de investigación simultáneamente en varios equipos y/o personas, etc..

En esta guía revisaremos las funciones básicas que un usuario de Git debería manejar día a
día. En nuestro caso utilizaremos como ejemplo la gestión del desarrollo de este mismo documento
que está guardado en la carpeta de nombre git.

Los comandos que aparecen aquí son los que se introducirían en una ventana de UNIX o Linux,

por esto, si es la guía se ve así

[gvega@nehuel ~]$ cd ..

en Git bash de windows se vería así

gvega@nehuel ~
$ cd ..

Así, independientemente que esta guía esté escrita en base a usuarios de Unix, es válida también
para usuarios de MS Windows.

http://progit.org/

2. Comandos básicos

2.1. Configuración inicial

En el caso de que no cuenten con usuarios por defecto, Git permite configurar el nombre de
usuario y correo electrónico de forma tal de registrar el autor de los cambios al proyecto. En este
caso

[gvega@nehuel git]$ git config --global user.name "George Vega"
[gvega@nehuel git]$ git config --global user.email "[email protected]"

luego verificamos si está todo ok

[gvega@nehuel git]$ git config --list

1

2.2.

Ir a la carpeta donde se encuentra el proyecto

Para comenzar con Git debemos posicionarnos en la carpeta que contiene el proyecto. En

unix/linux sería algo así

[gvega@nehuel ~]$ cd ..
[gvega@nehuel estudios]$ cd investigacion/george/git
[gvega@nehuel git]$

2.3.

Iniciar el proyecto

Una vez dentro de la carpeta del proyecto, el proyecto se inicia con el comando git init

[gvega@nehuel git]$ git init
Initialized empty Git repository in /users/estudios/investigacion/george/git/.git/

2.4. Listar extensiones de archivos a ignorar

Indistíntamente del tipo de archivos con que se esté trabajando, Git genera un respaldo au-
tomático de cualquier archivo que se encuentre en el proyecto con excepción de los que se ha decidido
explícitamente ignorar. En ese sentido Git permite realizar listas de archivos y/o extensiones de
archivos que se deberían ignorar. Para eso debemos crear un archivo con nombre .gitignore que
quede guardado en la carpeta del proyecto.

Para crear el archivo .gitignore debemos utilizar el editor de texto de unix (gedit), ya que
windows no nos permite guardar archivos que de nombre sólo tengan la extensión. El comando
para hacer esto

[gvega@nehuel git]$ gedit .gitignore

y aparecerá una ventana de gedit en blanco (si es que el archivo no existe). En ella podrán especificar
que, por ejemplo, Git no considere el archivo misetdedatosmuuuygrande.txt y cualquier archivo
con extensión .dta, .ppt, .pptx, xls, xlsx de la siguiente forma

# Las lineas que comiencen con signo gato son ignoradas, ie son
# lineas de comentarios
misetdedatosmuuuygrande.txt
*.dta
*.ppt
*.pptx
*.xls
*.xlsx

A modo de sugerencia, se recomienda utilizar el siguiente listado de archivos a ignorar

# Stata y R
*.dta
*.mmat
*.RData
*.Rproject

# MS Office binarios
*.xls
*.xlsx
*.doc
*.docx
*.ppt

2

*.pptx

# Otros
*.7z
*.zip
*.rar
*.pdf
*~

2.5. Revisar el status del proyecto

Una vez iniciado el proyecto, creado el archivo .gitignore y copiado algunos archivos relativos
al proyecto (opcional), revisamos la situación en la que se encuentra el índice de Git con el comando
git status. Se vería así

[gvega@nehuel git]$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
#
#
#
#
nothing added to commit but untracked files present (use "git add" to track)

(use "git add <file>..." to include in what will be committed)

.gitignore
guia_de_referencia_rapida/

Luego de ingresar el comando se despliega un resumen de la situación en la que se encuentra el
repositorio. Antes de revisar el concepto branch, fíjese que en pantalla se muestran un listado de
archivos que no están siendo seguidos (Untracked files), cuales en otras palabras corresponderían
a archivos que no están en el índice de archivos a respaldar, por lo que no es posible seguir su
historia.

2.6. Agregar objetos al índice

Para comenzar a hacer seguimiento de aquellos archivos, debemos agregarlos (add) al índice

[gvega@nehuel git]$ git add .gitignore
[gvega@nehuel git]$ git add guida_de_referencia_rapida/.

La primera línea de comando agrega el archivo .gitignore, mientras que la segunda agrega
la carpeta add guida de referencia rapida completa 1. Una manera alternativa habría sido
agregar todos los archivos que se encuentran como Untracked

[gvega@nehuel git]$ git add .

En este caso sólo hizo falta especificar un “.” para decirle al sistema que indexara todos los

archivos. Cabe enfatizar que tiene el mismo resultado que los comandos entrados anteriormente.

1Fijarse en el punto que se agrega al final. De no haber agregado aquel el sistema habría arrojado error

3

2.7. Comprometer los cambios

En Git , cuando hablamos de comprometer los cambios, lo que estamos diciendo metafórica-
mente es que queremos guardar una fotografía del proyecto en ese momento del tiempo (snapshot)
cual se convertirá en un punto de control al cual podríamos eventualmente volver en el caso de
que algo salga mal con nuestro proyecto (he aquí la gracia de Git ). Antes de revisar el comando
en sí volvamos a ver el status del proyecto

(use "git rm --cached <file>..." to unstage)

.gitignore
guia_de_referencia_rapida/guia_de_referencia_rapida.aux
guia_de_referencia_rapida/guia_de_referencia_rapida.log
guia_de_referencia_rapida/guia_de_referencia_rapida.synctex.gz
guia_de_referencia_rapida/guia_de_referencia_rapida.tex

[gvega@nehuel git]$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#
#
#
#
#
#
#
#
# Changes not staged for commit:
#
#
#
#
#

new file:
new file:
new file:
new file:
new file:

(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)

modified:

guia_de_referencia_rapida/guia_de_referencia_rapida.tex

lo que tenemos aquí es un listado de nuevos archivos agregados al sistema (new file) marcados
como Cambios a comprometer (Changes to be committed) y un archivo que, ya indexado, ha
sido modificado y por lo tanto hay que volver a agregar para el snapshot. Por lo tanto, en este caso
realizaremos los siguientes pasos:

1. Comprometeremos los cambios que están listos para ser comprometidos

2. Agregaremos el archivo modificado y comprometeremos el cambio de manera simultánea.

[gvega@nehuel git]$ git commit -m "Archivos nuevos para el proyecto"
[master (root-commit) a533440] Archivos nuevos para el proyecto

Committer: George Vega <[email protected]>
5 files changed, 264 insertions(+), 0 deletions(-)
create mode 100644 .gitignore
create mode 100644 guia_de_referencia_rapida/guia_de_referencia_rapida.aux
create mode 100644 guia_de_referencia_rapida/guia_de_referencia_rapida.log
create mode 100644 guia_de_referencia_rapida/guia_de_referencia_rapida.synctex.gz

así queda registrado que el usuario (Committer: George Vega [email protected] ha
registrado cambios en 5 archivos con 264 inserciones de líneas nuevas y 0 eliminaciones. Nos faltaría
agregar el archivo modificado.

En el caso de archivos que están siendo seguidos y ha sido modificados no es necesario ingresar el
comando git add para agregarlo al compromiso. Una manera rápida es agregarlo y comprometerlo
al mismo tiempo poniendo la opción -a en el comando git commit

[gvega@nehuel git]$ git -a -m "Trabajando en la guia de referencia rapida GIT"
[master fb61efb] Trabajando en la guia de referencia rapida GIT

1 files changed, 69 insertions(+), 1 deletions(-)

4

que nos estaría indicando que hemos comprometido el cambio exitósamente.

2.8. Eliminar archivos del índice (no del directorio)

A pesar de ser cuidadosos con el listado de archivos a ignorar, nos puede pasar que en alguna
ocasión no hayamos incluido alguna extensión (por ejemplo .png) o que algún archivo fue agregado
cuando no debería haber sido así. En ese caso está el comando git rm. Por ejemplo, imaginemos
que hay un archivo muy grande que no queremos seguir llamado guia de referencia rapida.log
y, por otro lado, olvidamos excluir archivos con extensión .gz. Para dejar de seguirlos

[gvega@nehuel git]$ git rm --cached \*/guia_de_referencia_rapida.log
rm ’guia_de_referencia_rapida/guia_de_referencia_rapida.log’
[gvega@nehuel git]$ git rm --cached \*.gz
rm ’guia_de_referencia_rapida/guia_de_referencia_rapida.synctex.gz’

si revisamos el estatus del repositorio

[gvega@nehuel git]$ git status
# On branch master
# Changes to be committed:
#
#
#
#
#

deleted:
deleted:

(use "git reset HEAD <file>..." to unstage)

guia_de_referencia_rapida/guia_de_referencia_rapida.log
guia_de_referencia_rapida/guia_de_referencia_rapida.synctex.gz

sólo faltaría comprometer los cambios

[gvega@nehuel git]$ git commit -m "Eliminando archivos del indice"
[master 4d6472c] Eliminando archivos del indice

2 files changed, 0 insertions(+), 170 deletions(-)
delete mode 100644 guia_de_referencia_rapida/guia_de_referencia_rapida.log
delete mode 100644 guia_de_referencia_rapida/guia_de_referencia_rapida.synctex.gz

2.9. Revisando el hi