Una guía rápida con ejemplos y práctica

Este artículo recopila los comandos de Git para diversas tareas: desde la configuración de un repositorio local hasta el trabajo con ramas y la interacción con GitHub.

Si ya manejas Git, puedes ir directamente a la sección que te interese. Si eres principiante, te recomendamos leerlo de forma secuencial: aprender los comandos básicos de Git y practicar viendo la grabación del webinar (enlace al final del artículo).

Instalación y configuración

Git no viene incluido en Windows ni macOS. En Linux sí está presente, pero no en todas las distribuciones. Para verificar si está instalado, introduce este comando en la «Terminal»:

git --version

Si Git está instalado, verás el número de versión. De lo contrario, verás un mensaje como «Unsupported command: git«. En ese caso, deberás instalarlo y configurarlo.

Instalación

Existen diferentes métodos de instalación, uno para cada sistema operativo. Elige el que prefieras.

Windows: Descarga el instalador desde git-scm.com. El sitio web ofrece tres versiones:

  • Versión estándar de 32 bits con la última compilación.
  • Versión independiente para instalar Git sin conexión a internet.
  • Instalador portátil para cargar en una memoria USB.

Durante la instalación, sigue los pasos y mantén la configuración predeterminada. Asegúrate de marcar estas opciones:

  • ✔️ Use Git Bash as default shell — selecciona Git Bash.
  • ✔️ Integrate Git with the Windows Shell — acepta trabajar con Git a través de la línea de comandos.

También puedes instalar Git en Windows a través del gestor de paquetes winget de Microsoft. Para ello, abre PowerShell e introduce este comando:

winget install --id Git.Git -e --source winget

macOS: En la aplicación «Terminal», instala Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Luego ejecuta este comando:

brew install git

En git-scm.com encontrarás otros métodos de instalación para macOS.

Linux: Visita git-scm.com y copia el comando para el gestor de paquetes de tu distribución Linux en la «Terminal». Algunos ejemplos:

# Para Debian/Ubuntu
apt-get install git

# Para Fedora
yum install git

# Para OpenSUSE
zypper install git

Configuración

Si usas macOS o Linux, después de instalar Git, abre la «Terminal». Si usas Windows, abre Git Bash. En estas aplicaciones ejecutarás todos los comandos.

En la línea de comandos, indica tu nombre y correo electrónico. Esta información permitirá a otros desarrolladores contactarte para discutir los commits. Cada commit estará firmado con tu nombre de usuario y dirección de correo electrónico.

Escribe tu nombre y apellido en latín, separados por un espacio y entre comillas:

git config --global  user.name "Nombre Apellido"

Escribe tu correo electrónico entre comillas:

git config --global  user.email "tu_correo@ejemplo.com"

Opcionalmente, puedes configurar el soporte automático de colores. Esto hará que los diferentes tipos de archivos se distingan por colores en el repositorio:

git config --global color.ui auto

Finalmente, verifica que los datos se hayan agregado y se muestren correctamente:

git config --list

La línea de comandos mostrará la configuración de tu perfil.

Creación de un repositorio

Dirígete a la carpeta de tu proyecto y conecta Git:

git init

Verás un mensaje indicando que se ha inicializado el repositorio. Esto significa que Git ha comenzado a rastrear los archivos del proyecto y registrará los cambios en una carpeta oculta .git. Si necesitas inicializar un nuevo repositorio, repite el proceso. En un mismo ordenador, Git puede gestionar simultáneamente un número ilimitado de repositorios.

La línea de comandos es útil no solo para trabajar con Git, sino también para navegar por el proyecto. Aquí tienes algunos comandos básicos:

  • pwd: muestra tu ubicación actual.
  • ls: lista las carpetas y archivos en el directorio actual.
  • ls -a: lista las carpetas y archivos visibles y ocultos en el directorio actual.
  • cd ~: cambia al directorio de inicio del usuario actual.
  • cd ..: sube un nivel en la jerarquía del sistema de archivos.
  • cd nombre_de_carpeta: cambia a la carpeta especificada.
  • mkdir nombre_de_carpeta: crea una carpeta con el nombre especificado.

Flujo de trabajo

Al trabajar con Git, agregarás archivos al índice, verificarás el estado del repositorio, crearás commits, verás el historial y desharás cambios.

git add: agregar archivos al índice

Si creas un archivo en el proyecto, Git lo considerará «no rastreado» (untracked). Estos archivos no se pueden transferir al repositorio sin prepararse para su guardado. El índice es una zona intermedia antes del repositorio. Puedes mover los archivos al índice con el comando git add.

Puedes agregar un archivo, varios o todos a la vez. Una vez en el índice, los archivos estarán preparados para el commit (staged):

# Agrega un archivo al índice
git add nombre_de_archivo

# Agrega varios archivos al índice
git add nombre_de_archivo_1 nombre_de_archivo_2 nombre_de_archivo_3

# Agrega todos los archivos modificados al índice
git add .

git add tiene muchas variantes. Por ejemplo, git add *.js moverá al índice todos los archivos con extensión .js de la carpeta actual. Para obtener documentación detallada de un comando, utiliza la ayuda:

git help nombre_de_comando

git status: verificar el estado del repositorio

El comando git status muestra el estado actual del repositorio. Indica qué archivos no rastreados se han añadido al proyecto, qué archivos están en el índice y qué archivos guardados has modificado en el repositorio.

$ git status   # Solicita el estado actual del repositorio

git commit: agregar archivos al repositorio

Cuando todos los archivos estén preparados para guardarse, puedes moverlos del índice al repositorio. Para ello, necesitas el comando git commit con la opción -m y un mensaje de commit. El mensaje se escribe entre comillas y normalmente en latín:

git commit -m "Mensaje del commit"

Los mensajes son obligatorios; los desarrolladores se guían por ellos en el proyecto. Incluso existe un documento especial: «Commits Convencionales«. En él, los desarrolladores acuerdan cómo agregar comentarios correctamente. La idea es que el mensaje del commit explique los cambios realizados. Ejemplos:

  • ❌ Añadí mi primer commit.
  • ✅ Corregí el error nºXXXXX.
  • ❌ Trabajé en el archivo index.html.
  • ✅ Maqueté el encabezado para la página principal.

Si se quita la opción -m, al presionar Enter se abrirá un editor de texto. Allí deberás escribir el mensaje, guardarlo y salir.

Si has hecho commit de un archivo y luego lo modificas, puedes hacer un nuevo commit sin pasar por el índice. Para ello, necesitas la opción -a:

git commit -am "Mensaje del commit"

Si te has apresurado y has cometido un error en el mensaje del commit, puedes usar la opción --amend para sobrescribir el mensaje del último commit:

git commit --amend -m "Nuevo mensaje del commit"

git log: ver el historial de commits

El comando git log muestra el historial de commits en orden cronológico inverso. Puedes ver el hash, el mensaje, la fecha y el nombre del autor del commit.

git log   # Solicita ver el historial de commits
# Información del tercer commit realizado
commit 3f6f9e1f58e30e0d3a0d0ab764c0b30a5b621d4a   # Hash del tercer commit
Author: Juan Pérez <juan.perez@ejemplo.com>   # Autor del tercer commit
Date:   Jue Abr 21 10:26:52 2025 +0300   # Fecha del tercer commit
    Update README.md   # Mensaje del tercer commit

# Información del segundo commit realizado
commit acd1e81729dc2ee2dc107ba345fa1ab7e6cfbff9
Author: Ana García <ana.garcia@ejemplo.com>
Date:   Mié Abr 20 16:45:39 2025 +0300
    Add new feature

# Información del primer commit realizado
commit 7df1e8c33b0a617b3a72c785a67e45d0d932a180
Author: Juan Pérez <juan.perez@ejemplo.com>
Date:   Lun Abr 18 09:12:21 2025 +0300
    Initial commit

Puedes usar varias opciones para modificar la visualización del historial. Por ejemplo, puedes mostrar la información de cada commit en una sola línea. Para ello, elimina la fecha, el nombre del autor y acorta el tamaño del hash:

git log --oneline   # Solicita mostrar el historial de commits en una sola línea
3f6f9e1 Update README.md
acd2e91 Add new feature
7df1e9c Initial commit

git show: ver un commit

El comando git show muestra la información de un commit. El mensaje se divide en dos bloques: la parte con los metadatos y la lista de cambios realizados en el commit.

git show abc12345  # Solicita ver el commit con el hash abc12345

Si introduces git show sin el hash, se mostrará el contenido del último commit.

git diff: ver los cambios antes de un commit

El comando git diff muestra la diferencia entre el último commit y el estado actual del repositorio. Es decir, el último commit se compara con todos los archivos no rastreados que aún no se han transferido al índice.

Puedes añadir el nombre de un archivo para comparar su contenido con el último commit. También puedes usar el hash de un commit en lugar del nombre del archivo. Puedes añadir la opción --staged para comparar la versión del código después del último commit con el estado rastreado del repositorio: todos los archivos que están en el índice.

# Ver la diferencia entre el último commit y el estado actual del repositorio
git diff

# Diferencia entre el último commit y el estado actual de un archivo
git diff nombre_de_archivo

# Diferencia entre el último commit y un commit con un hash especificado
git diff hash_de_commit

# Diferencia entre el último commit y el estado rastreado del repositorio
git diff --staged

git difftool: iniciar una herramienta externa de comparación de archivos

El comando git difftool funciona de forma similar a git diff: compara archivos y encuentra diferencias. La diferencia es que git diff muestra el resultado en formato de texto, mientras que git difftool lo hace en formato gráfico: el comando inicia programas externos con herramientas visuales de comparación de archivos. Si quieres probarlo, instala Beyond Compare, vimdiff, Meld u otra aplicación similar. Después, lee la documentación de git difftool y practica la visualización de datos.

git restore: deshacer cambios

El comando git restore devuelve un archivo al estado del último commit. Deshace todos los cambios si el archivo no se ha transferido al índice. Si el archivo está en el índice, debes usar la opción --staged junto con el nombre del comando.

# Devolver un archivo no rastreado al estado del último commit
git restore nombre_de_archivo

# Devolver todos los archivos del índice al estado del último commit
git restore --staged

# Devolver un archivo específico del índice al estado del último commit
git restore --staged nombre_de_archivo

git rm: eliminar archivos del índice

El comando git rm permite eliminar un archivo que se ha añadido al índice por error. Después de ejecutar el comando, el archivo desaparecerá del índice y de la carpeta de tu ordenador donde se almacena el proyecto. Si solo quieres eliminar el archivo del índice, usa git rm con la opción --cached.

# Eliminar un archivo del índice y del directorio de trabajo
git rm nombre_de_archivo

# Eliminar un archivo del índice y dejarlo en la carpeta del ordenador
git rm --cached nombre_de_archivo

git reset: deshacer un commit

El comando git reset permite deshacer cualquier cantidad de commits realizados y devolver el proyecto a un estado anterior. Este comando debe utilizarse con precaución, ya que puede sobrescribir permanentemente el historial del proyecto.

Puedes usar tres modos: --soft, --mixed y --hard.

En modo --soft, el proyecto se revierte al commit especificado y todos los commits posteriores se mueven al índice. Puedes hacer un nuevo commit inmediatamente y sobrescribir el historial del proyecto, dejando los archivos originales sin cambios.

En modo --mixed, los archivos revertidos pasan a la zona no rastreada. Puedes modificar, eliminar o devolver estos archivos al índice.

En modo --hard, el proyecto se revierte al commit especificado y elimina todos los commits posteriores sin posibilidad de recuperación.

# Revierte y mueve los commits posteriores al índice
git reset --soft hash_de_commit

# Revierte y mueve los commits posteriores a la zona no rastreada
git reset --mixed hash_de_commit

# Revierte y elimina todos los commits posteriores
git reset --hard hash_de_commit

Antes de ejecutar git reset, te recomendamos hacer siempre una copia de seguridad del proyecto, en caso de que se eliminen archivos inesperadamente.

Ramificación

Todo el desarrollo en Git se realiza en ramas. Estas almacenan los commits y los organizan en una cadena: al moverse por una rama de un commit a otro, se pueden rastrear los cambios en el proyecto. Al trabajar con ramas, las crearás, visualizarás, renombrarás, cambiarás, fusionarás y eliminarás con frecuencia.

git branch <nombre_de_rama>: crear una nueva rama

Después del primer commit, Git crea automáticamente la primera rama. Normalmente, en ella se almacena una versión estable del proyecto para los usuarios del producto. Para otras tareas, los desarrolladores crean ramas separadas con el comando git branch:

git branch nombre_de_rama

El nombre de la rama debe indicar lo que ocurre en ella. Por ejemplo, si el nombre menciona la palabra bugfix, la rama está destinada a corregir errores. La palabra feature indica el desarrollo de alguna función. Un nombre aleatorio como test10.24 no significa nada, y es mejor evitar estos nombres.

Puedes renombrar una rama con un nombre incorrecto:

git branch -m nombre_de_rama_anterior nombre_de_rama_nuevo

# nombre_de_rama_anterior: nombre antiguo de la rama
# nombre_de_rama_nuevo: nuevo nombre de la rama

git branch: ver las ramas

El comando git branch permite obtener una lista de todas las ramas disponibles en el proyecto. También coloca un asterisco a la izquierda de la rama activa actual:

# Solicita la lista de todas las ramas disponibles
git branch

git checkout: cambiar entre ramas

El comando git checkout permite cambiar de una rama a otra:

git checkout nombre_de_rama

También puedes crear una nueva rama y cambiar a ella con un solo comando:

git checkout -b nombre_de_rama

git checkout tiene una alternativa más moderna:

git switch nombre_de_rama

git switch es más seguro y adecuado para principiantes. Antes de cada cambio, verifica automáticamente el directorio de trabajo y no funciona si el cambio a la rama seleccionada puede provocar la pérdida de datos.

git merge: fusionar repositorios

El comando git merge permite añadir cambios de una rama a otra. Este proceso se llama fusión y termina con la aparición de un commit común para las ramas fusionadas. A través de este commit, se puede rastrear el historial de cada rama.

# Cambia a la rama principal que recibirá los cambios
git checkout rama_principal

# Fusiona los cambios de la rama secundaria a la principal
git merge rama_secundaria

git branch -d <nombre_de_rama>: eliminar una rama

Después de la fusión, la rama secundaria ya no es necesaria y podemos eliminarla.

# Verifica la rama actual
git branch

# Cambia a la rama principal
git checkout rama_principal

# Elimina la rama secundaria
git branch -d rama_secundaria

Repositorio remoto

En las secciones anteriores, hemos usado Git localmente en el ordenador. Ahora necesitamos una versión remota del repositorio que podamos compartir con otros desarrolladores o usar como copia de seguridad del proyecto. Puedes crear un repositorio remoto en diferentes plataformas, entre las que destacan GitHub y GitLab. Trabajaremos con GitHub.

Para trabajar con GitHub, debes registrarte y configurar las claves SSH para una conexión segura. Después, puedes acceder al repositorio remoto.

git remote add origin url: vincular el repositorio local y remoto

En la línea de comandos, dirígete a la carpeta del proyecto en tu ordenador. Ahora puedes ejecutar el comando git remote add, que establecerá la conexión entre tu repositorio local y el repositorio remoto en GitHub.

Debes añadir dos parámetros al comando: el nombre de tu repositorio remoto y su dirección. Encontrarás la dirección en la página de tu perfil, en la pestaña SSH.

# Cambiar a la carpeta del proyecto
cd ruta/a/la/carpeta/del/proyecto

# Vincular el repositorio local al repositorio remoto de GitHub
git remote add origin git@github.com:tu_perfil/tu_repositorio.git

git remote: ver los repositorios remotos

Si interactúas con frecuencia con GitHub, tu repositorio local puede estar vinculado a muchos repositorios remotos. Si introduces el comando git remote, puedes ver los nombres de estos repositorios y eliminar los innecesarios.

# Consulta para ver los repositorios remotos vinculados al local
git remote

# Ejemplo de salida: dos repositorios remotos vinculados a nuestro repositorio local
  origin
  upstream

git remote -v: ver las URL remotas

El comando git remote solo muestra los nombres de los repositorios remotos vinculados al tuyo. Puedes añadir la opción -v para ver las URL remotas. Las URL mostrarán los cambios que has realizado.

# Consulta de la lista de repositorios remotos con sus URLs
git remote -v

# Ejemplo de salida con las URLs
  origin  https://github.com/JuanPerezDev/MiProyecto.git (fetch)
  origin  https://github.com/JuanPerezDev/MiProyecto.git (push)
  upstream  https://github.com/AnaGarciaCode/ProyectoColaborativo.git (fetch)
  upstream  https://github.com/AnaGarciaCode/ProyectoColaborativo.git (push)

git push: enviar cambios al repositorio remoto

El comando git push carga los cambios del repositorio local al remoto.

Durante la primera carga, debes usar el comando con la opción -u. Esto vinculará las ramas local y remota y las sincronizará para operaciones posteriores. Para la segunda y siguientes cargas, la opción -u no será necesaria para las ramas vinculadas.

# Comando para la primera carga de cambios al repositorio remoto: la rama actual se vinculará con la rama main en el repositorio remoto origin
git push -u origin main

# Comando para la segunda y siguientes cargas de cambios al repositorio remoto
git push

git pull: obtener cambios del repositorio remoto

El comando git pull descarga los cambios del repositorio remoto al local.

# Descarga los cambios del repositorio remoto y los añade a la rama local
git pull

¿Necesita más ayuda visual con los pasos? Recomendamos ver el siguiente video:

Categorizado en:

Programación,