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:
- GitHub Cheat Sheet – https://training.github.com/training-kit/downloads/github-git-cheat-sheet.pdf (PDF)
- Bitbucket Cheat Sheet – https://www.atlassian.com/git/tutorials/atlassian-git-cheatsheet
- Visual Git Cheat Sheet – https://ndpsoftware.com/git-cheatsheet.html
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 de Git para configuración
- Comandos de Git para obtener y crear proyecto
- Comandos de Git para seguimiento básico
- Comandos de Git para crear y fusionar ramas
- Comandos de Git para compartir y actualizar proyectos
- Comandos de Git para inspección y comparación de repositorios
Comandos básicos de Git
Se pueden agrupar los comandos básicos de Git en estas categorías:
- Comandos de configuración
- Comandos para obtener y crear proyecto
- Comandos para seguimiento básico
- Comandos para crear y fusionar ramas
- Comandos para compartir y actualizar proyectos
- Comandos para inspección y comparación de repositorios
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 --helpgit 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 helpObtener 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:
- Crear un repositorio nuevo.
- Copiar un repositorio existente.
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 initEjemplo:
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 initEsto 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.
- Se crea un directorio vacío.
- Se conecta con el repositorio remoto mediante la URL indicada.
- Se descargan las ramas remotas.
- 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-projectComandos 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 statusEjemplo:
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 --listCrear 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 -lComo 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-ramaSi ya hubiéramos subido esta rama al repositorio remoto y quisiéramos eliminarla, el comando sería así:
git branch -D feature/una-ramagit 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 masterAhora 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 masterEjemplo:
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 stashgit 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 -lCrear 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:
--all– Descarga todos los objetos remotos.--prune– Elimina todas las referencias locales que ya no existan en el repositorio remoto.--tags– Descarga todas las etiquetas remotas.
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 --pruneSi también queremos descargar todas las etiquetas del repositorio remoto, ejecutaremos el siguiente comando:
git fetch --tagsgit pull
Este comando incorpora los cambios remotos dentro de la rama actual del repositorio local.
Actualizar rama actual:
git pullActualizar 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 pushEjemplo:
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 pushInspecció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.1git log
Con este comando se muestran los distintos commits que se han realizado.
Ver commits:
git logEjemplo:
Si quisiéramos ver el detalle de algún commit, primero deberíamos saber cuales son los commits que se han hecho:
git logAhora 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 diffVer 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.txtY veamos que diferencias hay en la rama:
git diffY ahora en cada uno de los archivos modificados:
git diff archivo1.txt
git diff archivo3.txtConclusiones
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.
