Icono del sitio Ganda Software Factory

Comandos básicos de Git para tus proyectos

Pablo
Comandos básicos de Git (portada)

En un post anterior, ¿Cómo instalar Git en Linux, Mac y Windows?, vimos qué es Git (sistema de gestión de versiones). Pero Git es una herramienta formada por una gran cantidad de comandos con los que se pueden manejar todas las funcionalidades de la herramienta. En este post veremos algunos de los comandos básicos de Git más utilizados.

Toda la información sobre Git se puede consultar en su página oficial: https://git-scm.com/docs

También se pueden consultar diferentes hojas de referencia (cheat sheets) sobre los comandos básicos de git en los siguientes sitios web:

Toda la información también está disponible en español (y en otros muchos idiomas) aquí: https://git-scm.com/book/es/v2

Comandos básicos de Git

Se pueden agrupar los comandos básicos de Git en estas categorías:

Los comandos indicados en los ejemplos se han probado en Mac. También deberían funcionar perfectamente en Linux. En caso de utilizar Windows, algunos de los comandos a utilizar pueden ser diferentes.

Mostraremos los mensajes obtenidos en la ejecución de los comandos y el estado del repositorio a través de comandos y mediante la herramienta SourceTree. Lamentablemente, sólo existe versión de SourceTree para Mac y Windows, así que si usas una máquina con Linux, existen herramientas parecidas como GitKraken o SmartGit.

Comandos Git de configuración

Libro de Git (v2) – Comandos de Git: Configuración

git

Es el comando a través del cual se lanzan todas las operaciones de Git.

git --version
git --help

git config

Con este comando se realizan las configuraciones, ya sean sobre las preferencias a la hora de utilizar Git o configuraciones específicas para el repositorio o el proyecto.

Para establecer configuraciones globales (para todos los repositorios) se utilizará la opción --global:

git config --global ...

Estas configuraciones se escriben dentro del archivo ~/.gitconfig del usuario.

Para establecer configuraciones locales (sólo aplicables al repositorio) se utilizará la opción --local:

git config --local ...

Estas configuraciones se escriben dentro del archivo config del directorio .git del repositorio (.git/config).

Ejemplo:

Estableceremos la configuración con la información del usuario:

git config --global user.name "Pablo"
git config --global user.email "pablo@gandasf.com"

Si en vez de aplicar los cambios de forma global queremos aplicarlos de forma local al repositorio (--local), primero hay que crear primero el repositorio.

git help

Este comando permite obtener toda la información sobre Git y sus comandos.

Obtener información:

git help

Obtener información del comando init:

git help init

Comandos de Git para obtener y crear proyectos

Libro de Git (v2) – Comandos de Git: Obtener y crear proyectos

Para poder obtener un repositorio Git, se puede hacer de dos formas diferentes:

git init

Con este comando se crea un directorio vacío y se convierte en un nuevo repositorio de proyecto donde comenzar a gestionar sus versiones.

Crear un repositorio:

git init

Ejemplo:

Para crear un nuevo repositorio, primero crearemos un directorio vacío y luego crearemos el repositorio asociado. Basta con ejecutar los siguientes comandos:

mkdir my-project
cd my-project
git init

Esto creará el directorio .git dentro del directorio my-project que contendrá la información sobre el repositorio.

git clone

Este comando permite clonar el repositorio de un proyecto.

  1. Se crea un directorio vacío.
  2. Se conecta con el repositorio remoto mediante la URL indicada.
  3. Se descargan las ramas remotas.
  4. Se activa el último commit del repositorio en el directorio creado.

Clonar repositorio remoto:

git clone https://<username>@bitbucket.org/<team_name>/<repository_name>.git <destination_dir>

Ejemplo:

Si queremos clonar el repositorio my-dev-project que tenemos en BitBucket en el directorio my-project, basta con ejecutar el siguiente comando:

git clone https://gandalab@bitbucket.org/gandalab/my-dev-project.git my-project

Comandos de Git para seguimiento básico

Libro de Git (v2) – Comandos de Git – Obtener y Crear Proyectos

Dentro de esta sección veremos comando para gestionar el flujo de trabajo básico para la preparación de contenido y su confirmación para incorporarlo al historial de cambios.

git status

Este comando muestra el estado actual de los archivos de la rama actual. Muestra aquellos archivos que tienen diferencias con el índice y respecto a los últimos cambios incorporados al historial de cambios.

Mostrar estado:

git status

Ejemplo:

Inicialmente, al ejecutar este comando no nos mostrará nada, pero a medida que vayamos creando o modificando archivos, este comando nos irá indicando qué archivos no hemos incluido en el control de cambios.

git add

Este comando añade archivos al índice. Actualiza el índice con los archivos nuevos o modificados, preparándolos para su confirmación (commit) e incorporarlos al historial de cambios.

Añadir archivos:

git add .

Ejemplo:

Si queremos crear varios archivos y marcarlos como archivos que queremos incluir al control de cambios, basta con ejecutar estos comandos:

touch archivo1.txt
touch archivo2.txt
touch archivo3.txt
git add .

Esto creará los archivos vacíos archivo1.txt, archivo2.txt y archivo3.txt y los incluirá a los archivos marcados para incluir al control de cambios.

git rm

Este comando se utiliza para eliminar del índice archivos marcados para la próxima confirmación.

Eliminar archivos:

git rm <nombre_archivo>

Ejemplo:

Si queremos excluir el archivo2.txt de los archivos marcados para incluir al control de cambios, ejecutaremos el comando:

git rm archivo2.txt

git commit

Este comando registra los cambios en el repositorio. Confirma los cambios y los incorpora al historial de cambios, indicando un mensaje que describe dichos cambios.

Confirmar cambios:

git commit -m <descripcion_commit>

Ejemplo:

Como queremos incluir los archivos anteriores (archivo1.txt y archivo3.txt) al historial de cambios, ejecutamos este comando:

git commit -m "Este es mi primer commit"

Recuerda que el archivo2.txt lo hemos quitado y por tanto no queda incluido en el historial de cambios.

Comandos de Git para crear y fusionar ramas

Libro de Git (v2) – Comandos de Git: Ramificar y fusionar

Uno de los grandes características de Git son las ramas (branches), y por tanto gran parte del trabajo es la gestión de las ramas.

git branch

Este comando sirve para listar, crear o eliminar ramas dentro del repositorio.

Listar ramas:

git branch -l
git branch --list

Crear rama:

git branch <nombre_de_la_rama_origen> <nombre_de_la_nueva_rama>

Eliminar rama:

git branch -d <nombre_de_la_rama>

Ejemplo:

Si listamos las ramas, veremos que sólo tenemos la rama master:

git branch -l

Como veremos más adelante en la Metodología Git Flow, no se recomienda hacer uso directamente de la rama master. Es conveniente ir creando una rama para cada funcionalidad del desarrollo. Por eso, vamos a crear dos ramas feature a partir de la rama master con los siguientes comandos:

git branch master feature/una-rama
git branch master feature/mi-primera-rama

A continuación vamos a eliminar la primera de las dos ramas, porque con una es suficiente. Para ello, ejecutamos el siguiente comando:

git branch -d feature/una-rama

Si ya hubiéramos subido esta rama al repositorio remoto y quisiéramos eliminarla, el comando sería así:

git branch -D feature/una-rama

git checkout

Con este comando se cambia de una rama a otra.

Cambiar rama:

git checkout <nombre_rama>

Cambiar a rama nueva:

git checkout -b <nombre_nueva_rama>

Ejemplo:

Para volver a la rama master con este comando:

git checkout master

Ahora cambiamos a una nueva rama feature:

git checkout -b feature/mi-segunda-rama

Y vamos a crear un nuevo archivo y lo vamos a incluir en el control de cambios:

touch archivo4.txt
git add .
git commit -m "Añadido un nuevo archivo"

git merge

Este comando fusiona dos ramas.

Este comando es muy útil cuando, por ejemplo, estamos trabajando en una rama feature y queremos incorporar los cambios que haya habido en la rama master.

Fusionar rama master:

git merge master

Ejemplo:

Como ya hemos terminado con la rama feature/mi-segunda-rama, vamos a fusionarla con master y luego actualizar la rama feature/mi-primera-rama con los cambios de la rama master:

git checkout master
git merge feature/mi-segunda-rama
git checkout feature/mi-primera-rama
git merge master

git stash

Este comando sirve para almacenar temporalmente el trabajo no confirmado con el fin de limpiar el directorio de trabajo sin tener que confirmar el trabajo no acabado en una rama.

Uso:

git stash

git tag

Con este comando se listan, crean y eliminan etiquetas (tags) de las ramas. De esta forma se puede añadir, por ejemplo, versionado de código. También se pueden utilizar para marcar las ramas en función del estado en le que se encuentran.

Listar etiquetas:

git tag -l

Crear etiqueta:

git tag -a <nombre_etiqueta> -m <descripcion_etiqueta>

Comandos de Git para compartir y actualizar proyectos

Libro de Git (v2) – Comandos de Git: Compartir y actualizar proyectos

Cuando estás listo para compartir tu trabajo u obtener cambios de otros lugares, existen comandos para interactuar con los repositorios remotos.

git fetch

Este comando descarga todos los objetos y referencias de un repositorio remoto.

Descargar repositorio remoto:

git fetch <options>

Existen algunas opciones muy útiles para este comando:

Ejemplo:

Es recomendable ejecutar este comando cada cierto tiempo, de manera que así tengamos sincronizado nuestro repositorio con todos los cambios y actualizaciones que se estén produciendo en el repositorio remoto. Lo habitual es ejecutar este comando:

git fetch --all --prune

Si también queremos descargar todas las etiquetas del repositorio remoto, ejecutaremos el siguiente comando:

git fetch --tags

git pull

Este comando incorpora los cambios remotos dentro de la rama actual del repositorio local.

Actualizar rama actual:

git pull

Actualizar una rama:

git pull origin <nombre_rama>

git push

Con este comando, se actualiza el repositorio remoto con los cambios realizados en el repositorio local.

Actualizar repositorio remoto:

git push

Ejemplo:

Puesto que de momento sólo tenemos el repositorio en local, es buen momento para sincronizarlo con un repositorio remoto. Empezaremos subiendo la rama master al repositorio remoto:

git push

Inspección y comparación de repositorios

Libro de Git (v2) – Comandos de Git: Inspección y comparación

git show

Este comando se utiliza para mostrar el detalle de algunos objetos, como etiquetas (tags) o commits.

Ver detalle de una etiqueta:

git show <nombre_etiqueta>

Ejemplo:

Si alguien se descarga el proyecto y quiere ver el detalle de la etiqueta que hemos creado nosotros, bastaría con ejecutar este comando:

git show 0.0.1

git log

Con este comando se muestran los distintos commits que se han realizado.

Ver commits:

git log

Ejemplo:

Si quisiéramos ver el detalle de algún commit, primero deberíamos saber cuales son los commits que se han hecho:

git log

Ahora ya podemos ver el detalle del commit … :

git show ...

git diff

Este comando muestra los cambios que se han producido entre commits, en archivos aún no confirmados, etc.

Ver cambios:

git diff

Ver cambios en un archivo:

git diff <nombre_archivo>

Ejemplo:

Vamos a pasarnos a la rama feature/mi-primera-rama y añadir algo de texto en los archivos archivo1.txt y archivo3.txt:

git checkout feature/mi-primera-rama
echo "Hola Mundo!" > archivo1.txt
echo "Adiós Mundo!" > archivo2.txt

Y veamos que diferencias hay en la rama:

git diff

Y ahora en cada uno de los archivos modificados:

git diff archivo1.txt
git diff archivo3.txt

Conclusiones

Aunque hemos hecho un repaso de los comandos básicos de git, existen muchos otros comandos y más opciones para muchos de los que hemos visto.

A medida que se va utilizando git, se van descubriendo otros comandos que nos resultan útiles y que pasan a formar parte de nuestros comandos básicos de git.

Si estáis varias personas trabajando sobre el mismo repositorio, es posible que comandos como git rebase, git revert o git cherry-pick os resulten familiares.

Recomendamos tener a mano la documentación oficial de git para poder consultar los comandos de git siempre que sea necesario.

Salir de la versión móvil