Git
Tutorial Git: Comandos básicos
Git comandos básicos: primeros pasos. Aprende los comandos básicos de Git y da tus primeros pasos con ejemplos prácticos y detallados.
Aprende Git y certifícateInicializar y clonar: git init
, git clone
Para comenzar a trabajar con Git, es esencial saber cómo inicializar un repositorio y cómo clonar uno existente. Estos comandos permiten crear un nuevo historial de versiones o obtener una copia local de un proyecto remoto.
El comando git init
se utiliza para crear un nuevo repositorio de Git en el directorio actual. Al ejecutarlo, se crea un subdirectorio oculto llamado .git
que contiene todos los archivos necesarios para controlar las versiones:
git init
Este comando inicializa un repositorio vacío, listo para comenzar a rastrear cambios. Es importante entender que no añade automáticamente los archivos existentes; así que será necesario usar git add
para incluirlos en el seguimiento.
Por otro lado, git clone
permite crear una copia local de un repositorio remoto. Es muy útil cuando se desea colaborar en proyectos ya existentes alojados en plataformas como GitHub o GitLab:
git clone <url_del_repositorio>
Por ejemplo:
git clone https://github.com/usuario/proyecto.git
Este comando descarga todo el historial del repositorio y crea una carpeta llamada proyecto
en el directorio actual. Dentro de esta carpeta se encuentra el contenido del repositorio listo para ser modificado.
Es posible especificar un nombre diferente para el directorio de destino añadiéndolo al final del comando:
git clone https://github.com/usuario/proyecto.git mi_carpeta_personalizada
De esta manera, el repositorio se clonará en mi_carpeta_personalizada
en lugar de proyecto
.
Además, git clone
ofrece opciones avanzadas como clonar una rama específica o establecer la profundidad del historial. Para clonar solo la rama desarrollo
, se puede utilizar:
git clone -b desarrollo https://github.com/usuario/proyecto.git
Para hacer un clon superficial con una profundidad de un único commit:
git clone --depth 1 https://github.com/usuario/proyecto.git
Esto es útil cuando se necesita reducir el tamaño de la descarga en repositorios muy grandes.
Comandos esenciales: git add
, git commit
, git status
, git diff
Al trabajar con Git, es fundamental entender los comandos esenciales que permiten gestionar y controlar los cambios en el repositorio. Entre ellos, git add
, git commit
, git status
y git diff
son de los más usados para el flujo de trabajo diario.
El comando git add
se utiliza para añadir cambios al área de preparación (staging area). Esto implica seleccionar qué modificaciones se incluirán en el próximo commit. Por ejemplo, para agregar un archivo específico:
git add archivo.txt
Para añadir todos los cambios en el directorio actual y sus subdirectorios, se puede utilizar:
git add .
Es importante notar que git add
no solo agrega nuevos archivos, sino también modificaciones y eliminaciones. Si manejas la preparación de los cambios de manera selectiva se pueden crear commits más específicos.
Una vez que los cambios se han añadido al área de preparación, se utiliza git commit
para confirmar esas modificaciones en el historial del repositorio. Un commit debe ir acompañado de un mensaje descriptivo que explique el propósito de los cambios:
git commit -m "Implementa función de autenticación de usuarios"
Si se omite la opción -m
, Git abrirá el editor de texto predeterminado para que se pueda escribir el mensaje del commit. Es una buena práctica redactar mensajes claros y concisos para hacer más fácil la comprensión del historial por otros desarrolladores.
El comando git status
proporciona información sobre el estado actual del repositorio. Muestra los archivos modificados, añadidos y eliminados, y si están en el área de preparación o no. Este comando sirve para verificar qué cambios están listos para ser confirmados:
git status
La salida de git status
muestra los cambios sin seguimiento, modificados y preparados. Esto ayuda a tener controlados los archivos en los que se está trabajando y evitar cometer errores al hacer commits.
Para analizar las diferencias entre versiones de archivos, se usa git diff
. Este comando muestra las diferencias entre el directorio de trabajo y el área de preparación, o entre diferentes commits. Por ejemplo, para ver los cambios no preparados aún:
git diff
Para ver los cambios que ya están en el área de preparación y que serán incluidos en el próximo commit:
git diff --staged
Además, es posible comparar dos commits específicos utilizando sus identificadores:
git diff commit1 commit2
Con git diff
, se pueden inspeccionar las modificaciones en detalle, útil para la revisión y depuración del código antes de confirmar los cambios.
Exploración de historial: git log
, git show
Para explorar el historial de cambios se utilizan los comandos git log
y git show
, que permiten examinar en detalle los commits realizados, para poder tener un seguimiento de la evolución del proyecto e identificar de modificaciones.
El comando git log
muestra una lista de los commits realizados en el repositorio, ordenados cronológicamente del más reciente al más antiguo. Al ejecutar:
git log
Se obtiene información detallada de cada commit, incluyendo el identificador (hash), el autor, la fecha y el mensaje asociado. Esta salida puede ser muy grande en proyectos grandes, por lo que hay opciones para personalizarla.
Para una visualización más resumida, se puede utilizar:
git log --oneline
Este formato muestra cada commit en una sola línea, presentando únicamente el hash abreviado y el mensaje del commit. Sirve para obtener una vista general del historial sin agobiarse con detalles.
Es posible filtrar los commits por autor, fecha o contenido. Por ejemplo, para ver los commits realizados por un autor específico:
git log --author="nombre_del_autor"
Para limitar los commits a los realizados en los últimos siete días:
git log --since="7 days ago"
También se puede buscar commits que contengan una palabra clave en el mensaje:
git log --grep="palabra_clave"
Otra opción muy utilizada es la representación gráfica del historial. Con el parámetro --graph
, Git muestra una representación visual de las ramas y fusiones:
git log --oneline --graph --all
Esta combinación permite visualizar de forma gráfica la estructura del proyecto, mostrando cómo se relacionan los commits entre sí.
El comando git show
se emplea para mostrar información detallada de objetos específicos, como commits, etiquetas o árboles. Al ejecutar git show
sin argumentos, Git muestra información del commit más reciente:
git show
Para inspeccionar un commit particular, se proporciona su identificador:
git show abc1234
Este comando muestra el contenido del commit, incluyendo las diferencias introducidas, el mensaje del commit y metadatos como el autor y la fecha. Es útil sobre todo para revisar cambios realizados en un commit específico.
Además de commits, git show
puede usarse para visualizar el contenido de etiquetas o ramas. Por ejemplo, para ver el último commit en la rama desarrollo
:
git show desarrollo
Para enfocarse en un archivo en particular dentro de un commit:
git show abc1234:ruta/al/archivo.txt
Esto muestra el contenido del archivo en el estado que tenía en el commit especificado, lo cual sirve para comparar versiones de un archivo a lo largo del tiempo.
Para diferencias más enfocadas, se puede utilizar git log
con el parámetro -p
para incluir los parches (diferencias) entre cada commit:
git log -p
Esto proporciona una visión completa de las modificaciones realizadas en cada commit.
Conexión con remotos: git remote
, git push
, git pull
Es necesario saber manejar repositorios remotos para colaborar en proyectos utilizando Git. Los comandos git remote
, git push
y git pull
permiten gestionar y sincronizar los cambios entre el repositorio local y uno o más repositorios remotos.
Para empezar, el comando git remote
se utiliza para administrar las conexiones a repositorios remotos. Al ejecutar:
git remote
Se obtiene una lista de los nombres de los remotos configurados en el repositorio actual. Por lo general, al clonar un repositorio, Git añade automáticamente un remoto llamado origin
, que apunta al repositorio del cual se hizo la clonación.
Para visualizar las URLs asociadas a los remotos existentes, se puede utilizar:
git remote -v
Este comando muestra los remotos configurados junto con sus URLs para fetch y push. Es imporatnte saber con qué remotos se está trabajando para evitar errores al sincronizar los cambios.
Para añadir un nuevo remoto, se utiliza:
git remote add <nombre> <url_del_repositorio>
Por ejemplo:
git remote add upstream https://github.com/otro-usuario/proyecto.git
Esto añade un remoto llamado upstream
, útil cuando se trabaja con proyectos forkeados o con múltiples repositorios remotos. Así, se puede consultar y obtener cambios de diferentes fuentes.
Si es necesario cambiar la URL de un remoto existente, el comando es:
git remote set-url <nombre> <nueva_url>
Para eliminar un remoto que ya no sea necesario:
git remote remove <nombre>
Una vez establecidos los remotos, los comandos git push
y git pull
permiten sincronizar los cambios entre el repositorio local y los remotos.
El comando git push
se utiliza para enviar los commits locales al repositorio remoto. La sintaxis básica es:
git push <remoto> <rama>
Por ejemplo, para enviar los cambios de la rama main
al remoto origin
:
git push origin main
Si el repositorio remoto es nuevo o la rama no existe en el remoto, puede ser necesario utilizar la opción -u
para establecer un seguimiento entre la rama local y la remota:
git push -u origin main
De esta forma, en futuras ocasiones, se podrá usar simplemente git push
sin especificar el remoto y la rama porque Git recordará la configuración.
Si otros colaboradores han realizado cambios en el repositorio remoto, es posible que git push
falle debido a divergencias entre el historial local y el remoto. En tal caso, es necesario primero integrar los cambios remotos en el repositorio local.
El comando git pull
es una combinación de git fetch
y git merge
, y se utiliza para actualizar el repositorio local con los cambios del remoto. Al ejecutar:
git pull <remoto> <rama>
Git obtiene los commits del remoto especificado y luego los integra en la rama local actual. Por ejemplo:
git pull origin main
Este comando traerá los cambios de la rama main
en el remoto origin
y tratará de fusionarlos con la rama local activa. Se recomienda ejecutar git pull
antes de iniciar tareas nuevas para asegurarse de trabajar con la versión más actualizada del código.
En ocasiones, al ejecutar git pull
, pueden surgir conflictos si las modificaciones locales y remotas afectan a las mismas partes del código. Cuando ocurra eso, Git indicará los archivos en conflicto y será necesario resolverlos manualmente antes de continuar.
Para tener mayor control sobre el proceso, se pueden separar las operaciones de git pull
en git fetch
y git merge
. El comando git fetch
descarga los commits remotos sin fusionarlos automáticamente:
git fetch <remoto>
Luego, se puede revisar y fusionar los cambios manualmente:
git merge <remoto>/<rama>
Por ejemplo:
git fetch origin
git merge origin/main
Esta es una estrategia que permite examinar los cambios antes de integrarlos, lo cual es una buena práctica para mantener el historial más limpio.
Además, es posible utilizar git pull --rebase
en lugar de git pull
estándar. Esto reescribe los commits locales sobre los cambios remotos, evitando commits de merge adicionales y manteniendo el historial más lineal:
git pull --rebase origin main
No obstante, hay que tener cuidado al utilizar rebase
, porque modifica el historial local y puede complicar la colaboración si no se usa bien.
Ejercicios de esta lección Comandos básicos
Evalúa tus conocimientos de esta lección Comandos básicos con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Comandos básicos
GitHub como remoto
Comandos básicos
Comandos avanzados
Git con GitHub Desktop
Ramas
Instalación y configuración
Introducción a Git
Comandos avanzados
Resolución de conflictos
Git con Intellij IDEA
Git con Visual Studio Code
Todas las lecciones de Git
Accede a todas las lecciones de Git y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Git
Introducción Y Entorno
Instalación Y Configuración
Introducción Y Entorno
Primeros Pasos Con Git
Introducción Y Entorno
Ciclo De Vida De Los Archivos
Comandos
Comandos Básicos
Comandos
Comandos Avanzados
Comandos
Gitignore Y Archivos Temporales
Comandos
Visualización Y Navegación De Cambios
Comandos
Etiquetas Tags Y Releases
Comandos
Ramas
Ramas
Merge Vs Rebase
Ramas
Stash De Cambios Entre Ramas
Ramas
Cherry Pick De Cambios
Ramas
Deshacer Cambios
Ramas
Gitflow
Ramas
Resolución De Conflictos
Trabajo Remoto Y Colaboración
Github Como Remoto
Trabajo Remoto Y Colaboración
Git Con Visual Studio Code
Trabajo Remoto Y Colaboración
Git Con Intellij Idea
Trabajo Remoto Y Colaboración
Git Con Github Desktop
Trabajo Remoto Y Colaboración
Crear Y Organizar Issues En Github
Trabajo Remoto Y Colaboración
Github Pages Para Crear Sitios Web
Trabajo Remoto Y Colaboración
Repositorio Especial Username Github
Trabajo Remoto Y Colaboración
Pull Requests (Pr) En Github
Integración Continua Ci
Ci Con Github Actions
Integración Continua Ci
Análisis Estático Con Sonarcloud
Integración Continua Ci
Desplegar En Vercel Desde Github
Integración Continua Ci
Certificados de superación de Git
Supera todos los ejercicios de programación del curso de Git y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender cómo inicializar Git en un proyecto.
- Adquirir conocimiento sobre cómo clonar un repositorio remoto
- Aprender a añadir archivos al área de preparación (staging area).
- Dominar la realización de commits y la gestión del historial de versiones.
- Conocer las interacciones básicas con repositorios remotos.