Inicializar 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.