¿Qué es GIT?
Aprende a usar el software de control de versiones más famoso.
¿Quién lo creó?
Fue creado por Linus Torvalds, el mismo que creó Linux.
Git: guía completa de comandos con ejemplos
Git es uno de los sistemas de control de versiones más utilizados en el desarrollo de software. Permite guardar el historial de cambios de un proyecto, trabajar con diferentes versiones del código y colaborar con otros desarrolladores.
Fue creado por el ingeniero de software finlandés Linus Torvalds en el año 2005, sí, el mismo que creó Linux.
En esta guía vamos a recorrer los principales comandos de Git, desde los más básicos hasta algunos comandos avanzados, utilizando ejemplos prácticos.
1. ¿Qué es Git?
Git es un sistema de control de versiones distribuido. Esto significa que cada desarrollador tiene una copia completa del historial del proyecto en su ordenador.
Con Git podemos:
Guardar versiones de nuestro código.
Saber quién realizó cada cambio.
Crear ramas para desarrollar nuevas funcionalidades.
Fusionar cambios de diferentes desarrolladores.
Recuperar versiones anteriores.
Trabajar con repositorios remotos como GitHub, GitLab o Bitbucket.
Un flujo de trabajo habitual sería:
Modificar archivos
↓
git add
↓
git commit
↓
git push
↓
Repositorio remoto
2. Configuración inicial de Git
Antes de empezar a trabajar con Git, normalmente configuraremos nuestro nombre y correo electrónico.
git config
Permite configurar diferentes opciones de Git.
Configurar nuestro nombre:
git config --global user.name "Juan Pérez"
Configurar nuestro correo:
git config --global user.email "juan@example.com"
Podemos comprobar la configuración:
git config --list
También podemos consultar una configuración concreta:
git config user.name
La opción --global hace que la configuración se aplique a todos los repositorios del usuario.
3. Crear un repositorio
git init
Convierte una carpeta existente en un repositorio Git.
Por ejemplo:
mkdir mi-proyecto
cd mi-proyecto
git init
Git creará una carpeta oculta llamada .git donde almacenará toda la información necesaria para controlar las versiones.
Podemos comprobar el estado del repositorio con:
git status
4. Clonar un repositorio
git clone
Permite descargar un repositorio existente.
Por ejemplo:
git clone https://github.com/usuario/mi-proyecto.git
Git creará una carpeta con el proyecto y descargará su historial.
También podemos especificar el nombre de la carpeta:
git clone https://github.com/usuario/mi-proyecto.git proyecto-local
5. Comprobar el estado del proyecto
git status
Es probablemente uno de los comandos que más utilizaremos.
Muestra información sobre:
Archivos modificados.
Archivos preparados para commit.
Archivos nuevos.
La rama actual.
Cambios que todavía no hemos añadido al staging.
Ejemplo:
git status
Podríamos obtener algo parecido a:
On branch main
Changes not staged for commit:
modified: README.md
Esto significa que README.md ha cambiado, pero todavía no hemos preparado el cambio para realizar un commit.
6. Añadir cambios al staging
git add
git add añade cambios al área de preparación (staging area).
Por ejemplo:
git add README.md
Podemos añadir varios archivos:
git add README.md index.html styles.css
O todos los cambios:
git add .
Después podemos comprobar el estado:
git status
Ahora el archivo aparecerá como preparado para realizar un commit.
7. Crear un commit
git commit
Un commit representa un conjunto de cambios guardados en el historial del repositorio.
Por ejemplo:
git commit -m "Añadir página de inicio"
Es recomendable utilizar mensajes descriptivos.
Un buen mensaje:
git commit -m "Corregir validación del formulario de registro"
Un mensaje poco útil:
git commit -m "Cambios"
Podemos crear un commit y añadir automáticamente determinados cambios con:
git commit -am "Corregir formulario"
Importante: -a no incluye archivos nuevos que todavía no estén siendo seguidos por Git. Para esos archivos tendremos que utilizar git add.
8. Consultar diferencias
git diff
Muestra los cambios que todavía no hemos añadido al staging.
git diff
Por ejemplo, si hemos cambiado:
Hola mundo
por:
Hola mundo!
Git mostrará la diferencia.
Para consultar los cambios que ya están preparados para el próximo commit:
git diff --staged
También podemos comparar dos commits:
git diff abc123 def456
9. Consultar el historial
git log
Muestra el historial de commits.
git log
Una versión más compacta:
git log --oneline
Por ejemplo:
a82f31a Corregir formulario
7c21d91 Añadir página de contacto
51ab832 Crear proyecto
Podemos visualizar el historial de forma gráfica:
git log --oneline --graph --all
Una combinación muy útil:
git log --oneline --graph --decorate --all
10. Consultar un commit
git show
Permite consultar los detalles de un commit.
git show a82f31a
Si queremos consultar el último commit:
git show HEAD
HEAD representa normalmente el commit en el que estamos situados actualmente.
11. Trabajar con ramas
Las ramas permiten desarrollar funcionalidades de forma independiente sin modificar directamente la rama principal.
Por ejemplo:
main
|
A---B---C
\
D---E feature-login
Podemos crear una rama para implementar un nuevo sistema de login.
git branch
Para listar las ramas:
git branch
Crear una rama:
git branch feature-login
Cambiar a ella:
git switch feature-login
También podemos crear y cambiar a la rama en un solo comando:
git switch -c feature-login
12. git checkout
git checkout es un comando tradicional que puede utilizarse para cambiar de rama.
Por ejemplo:
git checkout feature-login
También permite crear una rama:
git checkout -b feature-login
En versiones modernas de Git se recomienda utilizar git switch para trabajar con ramas y git restore para restaurar archivos, ya que separan responsabilidades que históricamente estaban agrupadas en git checkout.
13. Fusionar ramas
git merge
Supongamos que hemos terminado nuestra funcionalidad:
main
|
A---B
\
C---D feature-login
Primero volvemos a main:
git switch main
Después fusionamos la rama:
git merge feature-login
El resultado será algo parecido a:
A---B-------E main
\ /
C---D
Dependiendo del historial, Git puede realizar un fast-forward o crear un commit de merge.
14. Resolver conflictos
Los conflictos aparecen cuando Git no puede decidir automáticamente cómo combinar dos cambios.
Por ejemplo, dos ramas pueden haber modificado las mismas líneas de un archivo.
Git puede mostrar:
<<<<<<< HEAD
Hola desde main
=======
Hola desde feature
>>>>>>> feature
Debemos editar manualmente el archivo y decidir qué contenido queremos conservar.
Después:
git add archivo.txt
Y finalmente:
git commit
En un conflicto producido durante un merge también podemos cancelar la operación:
git merge --abort
15. git rebase
git rebase permite colocar nuestros commits encima de otra rama.
Por ejemplo:
A---B---C main
\
D---E feature
Podemos hacer:
git switch feature
git rebase main
El historial quedaría conceptualmente:
A---B---C---D'---E' feature
Los commits D y E han sido recreados encima de C.
El rebase puede producir un historial más lineal, pero hay que tener cuidado al utilizarlo con ramas que otras personas ya están utilizando.
Una regla práctica:
Evita hacer rebase de commits que ya hayas publicado y que otros desarrolladores estén utilizando, salvo que sepas exactamente cómo manejar las consecuencias.
16. Repositorios remotos
git remote
Permite gestionar repositorios remotos.
Para consultar los remotos:
git remote -v
Normalmente veremos algo parecido a:
origin https://github.com/usuario/proyecto.git (fetch)
origin https://github.com/usuario/proyecto.git (push)
Añadir un remoto:
git remote add origin https://github.com/usuario/proyecto.git
Eliminarlo:
git remote remove origin
Cambiar su URL:
git remote set-url origin https://github.com/usuario/nuevo-proyecto.git
17. Descargar cambios del repositorio remoto
git fetch
Descarga información y cambios del repositorio remoto, pero no modifica nuestra rama de trabajo.
git fetch
También podemos indicar el remoto:
git fetch origin
Una ventaja importante de fetch es que nos permite revisar los cambios antes de integrarlos.
18. Descargar e integrar cambios
git pull
git pull descarga cambios y los integra en nuestra rama actual.
git pull
Conceptualmente, suele equivaler a una combinación de:
git fetch
git merge
También podemos utilizar:
git pull --rebase
que descarga los cambios y realiza un rebase en lugar de un merge.
19. Subir cambios
git push
Envía nuestros commits al repositorio remoto.
git push
La primera vez que subimos una rama podemos establecer su rama remota:
git push -u origin feature-login
Después normalmente bastará con:
git push
Para subir la rama main:
git push origin main
20. Restaurar cambios
git restore
Permite descartar cambios en archivos.
Por ejemplo:
git restore archivo.txt
Esto restaura el archivo al estado del último commit.
Para sacar un archivo del staging:
git restore --staged archivo.txt
Esto no elimina los cambios del archivo; simplemente lo devuelve fuera del staging.
21. git reset
git reset permite mover HEAD y modificar el estado del staging y/o del directorio de trabajo dependiendo de la opción utilizada.
--soft
git reset --soft HEAD~1
Elimina el último commit del historial, pero mantiene sus cambios preparados en staging.
--mixed
git reset HEAD~1
Elimina el commit y mantiene los cambios en los archivos, pero fuera del staging.
--hard
git reset --hard HEAD~1
Elimina el commit y también los cambios asociados del directorio de trabajo.
Cuidado con --hard: los cambios que no estén guardados en otro sitio pueden perderse.
22. Deshacer un commit publicado
git revert
Si un commit ya ha sido compartido con otras personas, normalmente es preferible utilizar git revert.
Por ejemplo:
git revert a82f31a
Git creará un nuevo commit que revierte los cambios del commit indicado.
Esto es diferente de git reset.
Una forma sencilla de recordarlo:
reset → modifica el historial
revert → crea un nuevo commit que deshace otro
23. Guardar cambios temporalmente
git stash
Imaginemos que estamos trabajando en una funcionalidad, pero necesitamos cambiar rápidamente de rama.
Tenemos cambios sin terminar y no queremos hacer un commit todavía.
Podemos utilizar:
git stash
Git guardará temporalmente nuestros cambios.
Después podemos cambiar de rama:
git switch main
Cuando queramos recuperar los cambios:
git stash pop
Podemos consultar los cambios guardados:
git stash list
Guardar un stash con un mensaje:
git stash push -m "Trabajo en login"
24. Eliminar archivos
git rm
Elimina un archivo y registra su eliminación para el próximo commit.
git rm archivo.txt
Después:
git commit -m "Eliminar archivo innecesario"
Si queremos eliminar un archivo del control de versiones pero conservarlo físicamente:
git rm --cached archivo.txt
Esto resulta especialmente útil cuando hemos añadido por error un archivo que posteriormente queremos ignorar.
25. .gitignore
El archivo .gitignore permite indicar a Git qué archivos o carpetas no queremos incluir en el repositorio.
Por ejemplo:
node_modules/
.env
dist/
*.log
.DS_Store
Después podemos comprobar el estado:
git status
Los archivos ignorados no aparecerán como archivos sin seguimiento.
Es especialmente importante no subir archivos que contengan contraseñas, tokens o claves privadas.
26. Etiquetas con git tag
Las etiquetas (tags) permiten marcar puntos concretos del historial.
Son muy utilizadas para identificar versiones:
v1.0.0
v1.1.0
v2.0.0
Crear una etiqueta:
git tag v1.0.0
Listar etiquetas:
git tag
Crear una etiqueta anotada:
git tag -a v1.0.0 -m "Primera versión estable"
Enviar una etiqueta al repositorio remoto:
git push origin v1.0.0
Enviar todas las etiquetas:
git push origin --tags
27. git cherry-pick
Permite aplicar los cambios de un commit concreto sobre nuestra rama actual.
Por ejemplo:
git cherry-pick a82f31a
Es útil cuando necesitamos un cambio específico sin fusionar toda una rama.
Un caso típico sería tener una corrección en una rama de desarrollo y necesitar llevar únicamente esa corrección a otra rama.
28. git reflog
git reflog guarda un registro de movimientos de HEAD.
git reflog
Puede resultar extremadamente útil cuando hemos realizado un reset, un rebase u otra operación y queremos localizar un commit que aparentemente hemos perdido.
Por ejemplo:
a82f31a HEAD@{0}: reset: moving to HEAD~1
7c21d91 HEAD@{1}: commit: Añadir login
Podríamos recuperar el estado anterior utilizando el identificador correspondiente.
29. git blame
Permite saber quién modificó cada línea de un archivo y en qué commit.
git blame archivo.txt
Por ejemplo:
a82f31a (Juan Pérez 2026-08-20) const port = 3000;
7c21d91 (Ana García 2026-08-21) app.listen(port);
Es muy útil para investigar cuándo y por qué se introdujo un cambio.
30. git bisect
git bisect ayuda a encontrar qué commit introdujo un error.
Git utiliza una búsqueda binaria para localizar el commit problemático.
Comenzamos:
git bisect start
Indicamos que el estado actual es incorrecto:
git bisect bad
Después indicamos un commit que sabemos que funcionaba:
git bisect good v1.0.0
Git irá seleccionando commits intermedios.
Después de probar cada uno:
git bisect good
o:
git bisect bad
Cuando encuentre el commit culpable, terminamos:
git bisect reset
31. Limpiar archivos no controlados
git clean
Permite eliminar archivos que Git no está siguiendo.
Primero es recomendable comprobar qué eliminaría:
git clean -n
Después podemos realizar la limpieza:
git clean -f
Para incluir directorios:
git clean -fd
Cuidado: estos archivos pueden eliminarse de forma permanente.
32. Crear alias
Git permite crear alias para comandos que utilizamos frecuentemente.
Por ejemplo:
git config --global alias.co checkout
Ahora podemos utilizar:
git co main
Otro ejemplo:
git config --global alias.lg "log --oneline --graph --decorate --all"
Y después:
git lg
33. Un flujo de trabajo completo
Veamos ahora un ejemplo que combine varios de los comandos anteriores.
Creamos un proyecto:
mkdir tienda
cd tienda
git init
Creamos un archivo:
echo "# Tienda" > README.md
Comprobamos el estado:
git status
Añadimos el archivo:
git add README.md
Creamos el primer commit:
git commit -m "Crear proyecto"
Creamos una rama para una nueva funcionalidad:
git switch -c feature-productos
Modificamos el proyecto y comprobamos los cambios:
git status
git diff
Añadimos los cambios:
git add .
Creamos el commit:
git commit -m "Añadir gestión de productos"
Volvemos a main:
git switch main
Fusionamos la funcionalidad:
git merge feature-productos
Finalmente podemos subir los cambios:
git push origin main
34. Los comandos Git que más utilizarás
Aunque Git tiene muchísimos comandos y opciones, en el día a día probablemente utilizarás una parte relativamente pequeña.
| Comando | Utilidad |
|---|---|
git init | Crear un repositorio |
git clone | Clonar un repositorio |
git status | Consultar el estado |
git add | Añadir cambios al staging |
git commit | Crear un commit |
git log | Consultar el historial |
git diff | Ver diferencias |
git branch | Gestionar ramas |
git switch | Cambiar de rama |
git merge | Fusionar ramas |
git rebase | Reorganizar commits |
git fetch | Descargar información remota |
git pull | Descargar e integrar cambios |
git push | Subir cambios |
git restore | Restaurar cambios |
git reset | Mover/reorganizar el historial |
git revert | Revertir un commit |
git stash | Guardar cambios temporalmente |
git tag | Crear etiquetas |
git cherry-pick | Aplicar un commit concreto |
git reflog | Consultar movimientos de HEAD |
git blame | Consultar quién modificó cada línea |
git bisect | Encontrar el commit que introdujo un error |
git clean | Eliminar archivos no controlados |
35. reset, restore y revert: ¿cuál utilizar?
Estos tres comandos suelen generar bastante confusión.
Una forma sencilla de diferenciarlos es:
Quiero quitar un archivo del staging
git restore --staged archivo.txt
Quiero descartar cambios de un archivo
git restore archivo.txt
Quiero modificar el historial local
git reset HEAD~1
Quiero deshacer un commit que ya he compartido
git revert <commit>
En equipos de trabajo, git revert suele ser la opción más segura para deshacer cambios que ya han sido publicados.
36. Buenas prácticas con Git
Git es una herramienta muy potente, pero algunos hábitos hacen que el historial sea mucho más fácil de mantener.
Haz commits pequeños
Es mejor:
Añadir formulario de login
Corregir validación del email
Añadir mensaje de error
que un único commit:
Cambios del proyecto
Utiliza mensajes descriptivos
Mejor:
git commit -m "Corregir validación del formulario"
que:
git commit -m "fix"
Actualiza tu rama antes de trabajar
En un proyecto colaborativo puede ser útil comenzar sincronizando los cambios:
git pull
No subas secretos
Nunca deberíamos incluir directamente en Git:
.env
passwords.txt
private-key.pem
Utiliza .gitignore y mecanismos adecuados de gestión de secretos.
Revisa antes de hacer commit
Antes de confirmar cambios:
git status
git diff
git diff --staged
Así evitaremos subir accidentalmente archivos o modificaciones que no queríamos incluir.
37. Chuleta rápida de Git
Para terminar, aquí tienes una pequeña referencia que puedes guardar:
# Configuración
git config --global user.name "Nombre"
git config --global user.email "email@example.com"
# Crear / clonar
git init
git clone <url>
# Estado y cambios
git status
git diff
git add .
git commit -m "Mensaje"
# Historial
git log
git log --oneline
git show <commit>
# Ramas
git branch
git switch <rama>
git switch -c <rama>
git merge <rama>
git rebase <rama>
# Remotos
git remote -v
git fetch
git pull
git push
# Deshacer cambios
git restore <archivo>
git restore --staged <archivo>
git reset HEAD~1
git revert <commit>
# Trabajo temporal
git stash
git stash list
git stash pop
# Versiones
git tag
git tag v1.0.0
git push origin --tags
# Comandos avanzados
git cherry-pick <commit>
git reflog
git blame <archivo>
git bisect
git clean -n
Conclusión
Git puede parecer complicado al principio porque tiene una gran cantidad de comandos y conceptos, pero el flujo básico es bastante sencillo:
┌─────────────┐
│ Modificar │
│ archivos │
└──────┬──────┘
↓
┌─────────────┐
│ git add │
│ Staging │
└──────┬──────┘
↓
┌─────────────┐
│ git commit │
│ Historial │
└──────┬──────┘
↓
┌─────────────┐
│ git push │
│ Remoto │
└─────────────┘
Si estás empezando, céntrate primero en dominar:
git status
git add
git commit
git log
git branch
git switch
git merge
git pull
git push
Una vez tengas claro este flujo, comandos como rebase, cherry-pick, reflog o bisect serán mucho más fáciles de entender.
Git no consiste en memorizar cientos de comandos, sino en entender cómo se mueve un cambio desde tu directorio de trabajo hasta el historial y, finalmente, hasta el repositorio remoto.
Repasemos los comandos esenciales con ejemplos y gráficos que nos ayudarán a entender su lógica.
El mapa mental de Git
La mayor parte del trabajo consiste en mover cambios desde tu carpeta, al área de preparación, al historial local y finalmente al remoto.
Configuración inicial: git config
Identifica los cambios con tu nombre y correo. La opción --global guarda la preferencia para todos los repositorios.
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
git config --list1. Crear, descargar y revisar
# Crear un repositorio en la carpeta actual
git init
# Descargar un repositorio remoto
git clone https://github.com/usuario/mi-proyecto.git
cd mi-proyecto
# Consultar el estado y las líneas modificadas
git status
git diff
git diff --staged2. Preparar y guardar cambios
git add selecciona cambios para el siguiente hito. git commit crea ese hito en tu historial local.
# Añadir un archivo concreto o todos los cambios
git add articulo-git.html
git add .
# Crear el commit
git commit -m "Añade guía básica de comandos Git"
# Historial compacto y visual
git log --oneline --graph --all3. Trabajar con ramas y fusionarlas
Una rama es una línea de trabajo independiente: permite construir una mejora sin alterar main hasta que esté lista.
# Crear y cambiar a una rama nueva
git switch -c mejora-menu
# Ver ramas y volver a la principal
git branch
git switch main
# Integrar la mejora y borrar la rama terminada
git merge mejora-menu
git branch -d mejora-menu4. Colaborar: git push, git pull y git fetch
| Comando | Qué hace | Cuándo usarlo |
|---|---|---|
git push | Envía tus commits al remoto. | Al terminar un bloque listo para compartir. |
git pull | Descarga e integra cambios remotos. | Antes de empezar y antes de subir cambios. |
git fetch | Descarga referencias sin cambiar tus archivos. | Para revisar novedades con seguridad. |
git push -u origin mejora-menu
git pull
git fetch origin
# Ver y modificar la dirección del remoto
git remote -v
git remote set-url origin https://github.com/usuario/nuevo-proyecto.git5. Guardar trabajo a medias: git stash
Cuando debes cambiar de rama sin hacer un commit incompleto, el stash aparta los cambios no confirmados y deja la carpeta limpia.
git stash push -m "Borrador de contacto"
git stash list
git stash pop # Recupera y elimina el último stash
git stash apply # Recupera, pero lo conserva en la lista6. Comparar, buscar y atribuir cambios
# Comparar dos ramas
git diff main...mejora-menu
# Commits de la rama actual que no están en main
git log main..HEAD --oneline
# Quién modificó cada línea de un archivo
git blame articulo-git.html
# Buscar texto en los archivos versionados
git grep "git push"7. Etiquetar versiones: git tag
Una etiqueta marca un commit importante, como una versión publicada, y normalmente no se mueve con nuevos commits.
git tag -a v1.0.0 -m "Primera versión pública"
git tag
git push origin v1.0.0
git push origin --tags8. Deshacer y recuperar con cuidado
# Quitar un archivo del staging area sin perder sus cambios
git restore --staged articulo-git.html
# Descartar cambios sin commit: acción irreversible
git restore articulo-git.html
# Crear un commit que revierte otro ya publicado
git revert <hash-del-commit>
# Localizar movimientos recientes y recuperar un commit
git reflog
git switch -c recuperar-trabajo <hash>git reset --hard si no entiendes exactamente qué perderás. En trabajo compartido, git revert suele ser más seguro porque conserva el historial.Chuleta de comandos esenciales
| Objetivo | Comando |
|---|---|
| Ver estado | git status |
| Revisar cambios | git diff |
| Preparar cambios | git add . |
| Crear un hito | git commit -m "mensaje" |
| Guardar trabajo temporal | git stash |
| Ver historial | git log --oneline |
| Recuperar referencias locales | git reflog |
| Crear rama | git switch -c nombre-rama |
| Fusionar rama | git merge nombre-rama |
| Etiquetar una versión | git tag -a v1.0.0 -m "mensaje" |
| Compartir cambios | git push |
| Actualizarte | git pull |
Un flujo diario recomendado
git pull # Ponte al día
git status # Revisa el estado
# ... edita archivos ...
git diff # Comprueba tus cambios
git add . # Prepara los cambios deseados
git commit -m "Describe el cambio"
git push # CompártelosCon esta secuencia, Git deja de ser una colección de comandos y pasa a ser una red de seguridad: cada cambio queda documentado, recuperable y listo para colaborar.
0 comentarios