Introducción

Preparé este documento como guía para un grupo de personas con quienes iba a trabajar. Íbamos a desarrollar una aplicación web y decidimos usar Git. Algunos en el grupo eran nuevos en Git, así que este artículo está pensado como guía para ellos.

¿Qué es Git?

En pocas palabras: Git es una herramienta de control de versiones. Registra los cambios que haces en tus documentos para que puedas revisarlos y volver a cualquier estado anterior cuando quieras. Es como una máquina del tiempo para tu proyecto.

Git es mucho más que eso y es muy potente, pero por simplicidad dejamos la definición ahí por ahora.

Primeros pasos

Hay dos formas principales de empezar con Git.

Estás iniciando el proyecto

Cuando eres tú quien inicia el proyecto, lo primero que debes hacer es inicializar el repositorio Git.

Creemos la carpeta donde trabajaremos:

mkdir ~/mi-proyecto
cd ~/mi-proyecto

Ahora iniciamos Git:

git init

Esto crea una nueva carpeta ~/mi-proyecto/.git que contiene toda la información que Git necesita para registrar tus cambios. Nunca debes editar nada en esa carpeta manualmente, y si la borras perderás el historial del proyecto.

Digamos que creas dos archivos dentro:

emacs app-principal.c
emacs sub-rutinas.c

Una vez hecho eso, debes agregar la información a Git. Si revisas el estado del proyecto, verás que hay archivos que Git no está rastreando:

git status

La salida será:

# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
app-principal.c
sub-rutinas.c
nothing added to commit but untracked files present (use "git add" to track)

Git dice que hay dos documentos nuevos en la carpeta que monitorea, pero que no han sido agregados explícitamente para su seguimiento. Hay que agregarlos:

git add app-principal.c
git add sub-rutinas.c

Si hay muchos archivos y quieres agregarlos todos de una vez:

git add -A

Revisemos el estado de nuevo:

git status

La salida es:

# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
new file:   app-principal.c
new file:   sub-rutinas.c

Los archivos están agregados pero aún no confirmados. Si quisieras dejar de rastrear alguno, podrías usar git rm [archivo]. Hagamos nuestro primer commit:

git commit -m 'Mi primer commit. Agrego app-principal.c con el código principal y sub-rutinas.c con las sub-rutinas.'

Si revisamos el estado nuevamente:

# On branch master
nothing to commit (working directory clean)

El proyecto ya existe en algún lugar, lo estás clonando

Lo bueno de Git es que no hay una autoridad central. Clonas un proyecto y puedes trabajar en él desde tu PC sin necesidad de estar conectado al repositorio clonado, a menos que quieras compartir tus cambios.

Clonemos un proyecto:

cd ~/
git clone git://servidor.com/mi-proyecto.git

También puedes clonar desde tu propio disco o una unidad de red: git clone /compartido/red/proyecto.git

Una vez que tienes el proyecto, puedes trabajar en él y enviar tus cambios al repositorio "central".

Resumen

Ya sabes cómo:

Trabajar con repositorios remotos

Para compartir el trabajo entre dos desarrolladores se necesita un repositorio bare. Un repositorio bare es uno sin árbol de trabajo, compuesto solo por la carpeta .git.

Creemos ese repositorio bare:

mkdir -p ~/tmp/mi-proyecto.git
cd ~/tmp/mi-proyecto.git
git init --bare

Ahora vamos al segundo proyecto y apuntamos su origen al repositorio bare:

cd ~/segundo-proyecto/mi-proyecto/
git remote rm origin
git remote add origin ~/tmp/mi-proyecto.git

Verificamos el remoto:

git remote -v

Ahora podemos enviar nuestros cambios:

git push origin master

Y el otro desarrollador puede obtener esos cambios:

cd ~/mi-proyecto/
git remote add origin ~/tmp/mi-proyecto.git
git pull origin master

Resumen

Ya sabes cómo:

Trabajar con ramas

Una de las características más potentes de Git es trabajar con ramas. Una rama es como un segundo conjunto de carpetas para trabajar sin afectar el proyecto principal. Por defecto estás trabajando en la rama master, y puedes crear tantas ramas como quieras para probar localmente antes de tocar la rama principal.

Creemos una rama llamada testing:

cd ~/mi-proyecto/
git checkout -b testing

La salida es:

Switched to a new branch 'testing'

Git creó la nueva rama y cambió a ella. Después de hacer cambios y confirmarlos en esa rama, podemos compartirla:

git push origin testing

El otro desarrollador puede obtener esa rama:

cd ~/segundo-proyecto/mi-proyecto/
git checkout -b testing
git pull origin testing

Fusionar ramas en Git

Una vez que los cambios están listos para producción, se fusionan con la rama master:

git checkout master
git merge testing

Notas adicionales

Puedes crear tantas ramas locales como quieras sin necesidad de compartirlas todas. Para eliminar una rama del remoto:

git push origin :testing

Resumen

Ya sabes cómo:

Conclusión

Git es mucho más que esto, pero estos comandos son suficientes para proyectos simples y con pocos colaboradores.

Última edición: mayo de 2013