Comandos básicos para sobrevivir con Git

Cuando desarrollamos aplicaciones de cualquier tipo y estas necesitan que se vayan solucionando errores e ir añadiendo nuevas funcionalidades, se hace indispensable la utilización de un control de versiones. Actualmente hay multitud de soluciones pero después de utilizar varios y por la buenas referencias que he leído sobre el yo me he decidido a utilizar Git.

Aunque ya existen diferentes clientes visuales para los distintos sistemas operativos, yo me voy a centrar en los comandos necesarios para poder manejarlo desde la consola de nuestro S.O.

Instalación

Evidentemente la instalación del cliente de git dependerá del sistema operativo donde lo instalemos, en mi caso ha sido en la distribución Ubuntu de Linux y se haría de la siguiente manera (más sencillo imposible):

[plain]
sudo apt-get install git-core
[/plain]

Configuración Mínima

Aunque no es necesario siempre es una buena practica configurar como mínimo el nombre del usuario y el mail de este, así se podrá ver esta información en los posteriores commits que hagan cada usuario, así pues ejecutamos estas dos líneas

[plain]
$ git config –global user.name “tuNombre”
$ git config –global user.email mimail@midominio.com
[/plain]

Obtener una copia local de un repositorio remoto

A la hora de empezar debemos conocer la dirección de donde está nuestro repositorio y esa información nos la suministrará el administrador del servidor de git, así que una vez que la sepamos tan solo tenemos que hacer un clone (por ejemplo el mio lo tengo por conexión ssh) y después un pull para traernos del servidor toda la versión:

[plain]
$ git clone ssh://username@0.0.0.0/home/username/miProyecto
$ git pull
[/plain]

También podemos crear un nuevo repositorio desde cero, para ello tan solo tienes que crear el directorio y una vez dentro ejecutar el comando init

[plain]
$ mkdir nuevoProyecto
$ cd nuevoProyecto
$ git init
[/plain]

Realizando cambios y subiéndolos al servidor

Ahora que ya tenemos en nuestro equipo una copia de todo el código fuente ya podemos empezar a realizar cambios. Podríamos decir que los cuatro comandos básicos para realizar cambios son status, add, commit y push:

  • status: Este comando nos devuelve una salida en pantalla por la cual nos informas si en nuestra copia de trabajo existe algún fichero modificado para que lo añadamos con el add o si existen ficheros que ya hemos añadido con el add pero no le hemos realizado aún el commit.

[plain]
$ git status

# On branch master
# Changes to be committed:
# (use “git reset HEAD <file>…” to unstage)
#
# modified: prueba1.txt
#
# Changes not staged for commit:
# (use “git add <file>…” to update what will be committed)
# (use “git checkout — <file>…” to discard changes in working directory)
#
# modified: prueba2.txt
#
[/plain]

  • add: El comando add sirve para decirle al git que ficheros de los que hemos modificado debe tener en cuenta para el próximo commit que realicemos. La sintaxis es muy sencilla, pudiendo añadir tanto ficheros sueltos como directorios enteros.

[plain]
$ git add prueba1.txt

$ git add miDirectorio/
[/plain]

  • commit: Una vez termines por ejemplo una nueva funcionalidad y queramos que todos los cambios que hemos realizado (y previamente añadidos con add) pasen a la revisión actual deberemos ejecutar el comando commit (si no le indicamos el parámetro -m y un comentario entre comillas dobles se nos abrirá un editor de texto para que escribamos lo que deseemos):

[plain]
$ git commit -m “Commit para ver el funcionamiento”
[/plain]

Si el comando se ejecuta correctamente nos mostrará en pantalla cuantos ficheros se han modificados, insertados y eliminados

  • push: Todo lo que hemos hecho hasta ahora solo se encuentra en nuestra máquina local y el servidor remoto ignora todos estos cambios. Esto es un punto que me encanta ya que si te das cuenta sin querer tenemos un control de versiones local ya que los commit que hemos ido realizando los podemos deshacer a nuestro antojo. Así pues cuando queramos pasar todas las modificaciones al servidor y que este accesible a los demás desarrolladores solo tenderemos que utilizar el comando push y obtendremos un resumen por pantalla como puedes ver a continuación:

[plain]
$ git push

Counting objects: 5, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 299 bytes, done.
Total 3 (delta 2), reused 0 (delta 0)
To git@github.com:ignaciogs/PruebaGit.git
9ee4007..df0c2dc master -> master
[/plain]

Creando Tags

Si en algún momento de la vida de nuestro código queremos realizar un tag para a posteriori tener la posibilidad de volver a ese punto tan solo tenemos que utilizar este comando.
[plain]
git tag nombreTag
[/plain]
También es posible realizar un tag sobre un determinado commit que ya se ha realizado
[plain]
git tag nombreTag idTag
[/plain]
el id del commit lo podemos obtener con el comando log como os muestro a continuación
[plain]
$ git log

commit df0c2dcab85666aa1c14775e08f90c0fedcc86ff
Author: Ignacio
Date: Sat Aug 27 19:11:06 2011 +0200

Commit para ver el funcionamiento
[/plain]

Para movernos entre los diferentes tags que existan en nuestro repositorios debemos utilizar el comando checkout con el nombre del tag

[plain]
git checkout nombreTag
[/plain]

Y si queremos saber la lista de tags que tenemos lo podemos consultar de la siguiente manera:

[plain]
git tag
[/plain]

Es importante destacar que por defecto los tags no se suben al servidor cuando utilizamos el comando push, así que se lo tenemos que indicar con el parámetro tags:

[plain]
git push –tags
[/plain]

Creando Branch (Ramas)

Otra parte fundamental en un control de versiones es la gestión de las diferentes ramas (branch) y en git es realmente sencillo. Por defecto la rama principal en git se llama master, que digamos va a ser en nuestro ejemplo nuestra versión de producción, pero vamos a suponer que paralelamente nos interesa tener una versión de desarrollo, así que para ello nos creamos una nueva branch llamada desarrollo y nos colocamos en ella con el comando checkout (el mismo que para movernos por los tags):

[plain]
$ git branch desarrollo
$ git checkout desarrollo
[/plain]

Estos dos comandos los podemos simplificar con el comando checkout y el parámetro -b, que nos creará una nueva rama y nos posicionará en ella:
[plain]
git checkout -b desarrollo
[/plain]

Desde ahora todo lo que hagamos serán cambios que solo estarán en la rama de desarrollo y en el momento que hagamos push pasara esta nueva rama a la máquina remota.

Cuando queramos cambiar de una rama a otra será igual que con los tags, con el comando checkout, así con los siguientes dos lineas cambiamos a la master y después a la de desarrollo:

[plain]
$ git checkout master
$ git checkout desarrollo
[/plain]

También podemos ver la lista de ramas (brach) que tenemos en nuestro repositorio:

[plain]
$ git branch

master
*desarrollo
[/plain]

Fijate que git nos indica en que rama estamos con un asterisco delante de esta.

Y por último una vez que terminemos de desarrollar la nueva versión podemos unificar la rama de master con la de desarrollo, para ello nos colocamos en el master, hacemos el merge y eliminamos la rama desarrollo:

[plain]
$ git checkout master
$ git merge desarrollo
$ git branch -d desarrollo
[/plain]

Otros comandos de interés

  • Aunque ya lo hemos utilizado al principio recuerda que para actualizar tu copia local con los cambios que existan en el servidor debes ejecutar un pull

[plain]
$ git pull
[/plain]

  • Para volver a la versión anterior de un fichero utilizamos checkout

[plain]
$ git checkout nombreFichero
[/plain]

  • Para volver a la versión de un determinado commit de un determinado fichero, primero consultamos el log del fichero para sacar el id del commit y después realizamos el checkout de ese id

[plain]
$ git log nombreFichero
$ git checkout idCommit nombreFichero
[/plain]

  • Si quieres ver que usuarios y cuando han modificado un determinado fichero lo hacemos con blame

[plain]
$ git blame nombreFichero
[/plain]

Terminamos

Por supuesto Git tiene muchísimas cosas más que lo hacen un potentísimo control de versiones pero creo que esto es lo básico para empezar a funcionar con el. Espero que os sirva de ayuda 🙂

 

Anuncios

4 pensamientos en “Comandos básicos para sobrevivir con Git

    • Para acortar comandos necesitas crear alias en tu ~/.gitconfig

      Ejemplo:

      [alias]
      co = checkout
      ci = commit
      st = status
      br = branch
      hist = log –pretty=format:”%h %ad | %s%d [%an]” –graph –date=short
      type = cat-file -t
      dump = cat-file -p

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s