¿Qué es Git?

Git es un sistema de control de versiones distribuido diseñado para rastrear los cambios realizados en los archivos de un proyecto. Fue creado por Linus Torvalds en 2005 para gestionar el desarrollo del núcleo de Linux.

Con Git, los desarrolladores pueden:

• Colaborar en equipo sin pisar el trabajo de otros.
• Mantener un historial completo de cambios en el proyecto.
• Restaurar versiones anteriores en caso de errores.

¿Por qué usar Git?

Git se ha convertido en el estándar de facto en el desarrollo de software por las siguientes razones:

1. Colaboración eficiente: Permite que varios desarrolladores trabajen simultáneamente en diferentes partes de un proyecto.
2. Historial completo: Conserva todos los cambios realizados, junto con quién los hizo y por qué.
3. Seguridad: Los datos en Git son difíciles de corromper gracias a su diseño.
4. Distribución: Cada copia del repositorio contiene todo el historial del proyecto, no depende de un servidor central.
5. Flexibilidad: Funciona para proyectos de cualquier tamaño y complejidad.

Instalación de Git

Para comenzar a usar Git, primero necesitas instalarlo en tu ordenador. Veamos cómo hacerlo dependiendo de tu sistema operativo.

1. Windows

   • Descarga el instalador desde https://git-scm.com.
   • Ejecuta el archivo descargado y sigue las instrucciones del asistente.
   • Durante la instalación, se te pedirá que elijas configuraciones como el editor predeterminado. Puedes mantener las opciones recomendadas.

2. MacOS

   • Si tienes Homebrew instalado, puedes instalar Git con:

   brew install git

   • También puedes descargarlo directamente desde https://git-scm.com.

3. Linux

   Usa el gestor de paquetes de tu distribución para instalar Git. Algunos ejemplos:

   • Ubuntu/Debian:

   sudo apt-get install git

   • CentOS/Fedora:

   sudo yum install git

   Para verificar que Git está instalado correctamente, ejecuta:

   git --version

Configuración inicial de Git

Una vez instalado, es importante realizar una configuración inicial para personalizar Git según tu identidad y preferencias.

1. Configuración de nombre de usuario y correo electrónico

   Estos valores se usarán para identificarte en los commits que realices.

   • Configura tu nombre:

     git config --global user.name "TuNombre"

   • Configura tu correo electrónico:

     git config --global user.email "TuCorreo@example.com"

   • Para verificar tu configuración, utiliza:

     git config --global --list

2. Configuración de editor predeterminado

   Git utiliza un editor de texto para tareas como escribir mensajes de commit largos. Por defecto, suele usar vim, pero puedes cambiarlo al que prefieras. Por ejemplo:

   • Para configurar Visual Studio Code como editor predeterminado:

   git config --global core.editor "code --wait"

   • Para configurar Nano como editor predeterminado:

   git config --global core.editor "nano"

Repositorios

Un repositorio en Git es el espacio donde se almacenan los archivos de un proyecto junto con su historial de cambios. Puede ser local (en tu máquina) o remoto (en una plataforma como GitHub o GitLab).

Crear un repositorio

Para crear un repositorio local, usa el comando:

git init

Este comando inicializa un nuevo repositorio vacío en el directorio actual.

Clonar un repositorio

Para obtener una copia de un repositorio remoto en tu máquina local, usa:

git clone URL_DEL_REPOSITORIO

Por ejemplo:

git clone https://github.com/usuario/repositorio.git

Esto descargará todos los archivos y el historial del repositorio remoto.

Ramas

Las ramas son versiones independientes de tu proyecto que puedes desarrollar en paralelo. El uso de ramas facilita trabajar en nuevas características sin afectar la rama principal.

Crear una rama

Para crear una nueva rama, usa:

git branch nombre_de_la_rama

Por ejemplo, para crear una rama llamada nueva-funcionalidad:

git branch nueva-funcionalidad

Cambiar de rama

Para cambiar a una rama existente, usa:

git checkout nombre_de_la_rama

Por ejemplo:

git checkout nueva-funcionalidad

También puedes crear una nueva rama y cambiar a ella de inmediato con:

git checkout -b nombre_de_la_rama

El flujo de trabajo básico con ramas

Un flujo de trabajo típico con ramas es:

1. Crear una nueva rama para la característica en la que deseas trabajar.
2. Realizar cambios y commits en esa rama.
3. Fusionar la rama de características con la rama principal una vez completado el trabajo.

Commits

Los commits son "instantáneas" del estado de los archivos en un momento dado. Cada commit incluye un mensaje que describe los cambios realizados.

Crear un commit

Después de realizar cambios en los archivos, usa los siguientes comandos:

1. Añade los archivos al área de preparación:

git add archivo_o_carpeta

Para añadir todos los archivos, usa:

git add .

2. Crea el commit con un mensaje descriptivo:

git commit -m "Mensaje que describe los cambios"

Mensajes de commit efectivos

Un buen mensaje de commit debe ser claro y descriptivo. Sigue estas pautas:

• Usa el modo imperativo (ej. "Añadir función de búsqueda").
• Mantén los mensajes cortos y precisos.
• Explica el porqué del cambio si es necesario.

Visualizar historial de commits

Para ver el historial de commits de un repositorio, usa:

git log

Esto mostrará información detallada de cada commit, como su autor, fecha y mensaje.

Para un historial más compacto, usa:

git log --oneline

Remotos

Los remotos son repositorios alojados en plataformas como GitHub, GitLab o Bitbucket. Permiten colaborar con otros desarrolladores al sincronizar cambios entre el repositorio local y el remoto.

Añadir un remoto

Para vincular tu repositorio local con un repositorio remoto, usa:

git remote add origin URL_DEL_REPOSITORIO

Por ejemplo:

git remote add origin https://github.com/usuario/repositorio.git

Para verificar los remotos configurados, usa:

git remote -v

Obtener cambios del remoto (pull y fetch)

Para traer los cambios más recientes desde el remoto a tu repositorio local, puedes usar:

• git fetch: Obtiene los cambios remotos pero no los combina con tu rama local.
• git pull: Obtiene los cambios remotos y los combina automáticamente con tu rama actual.

Comando para hacer un pull:

git pull origin rama

Por ejemplo:

git pull origin main

Subir cambios al remoto (push)

Para enviar los cambios desde tu repositorio local al remoto, usa:

git push origin rama

Por ejemplo, para subir los cambios a la rama main:

git push origin main

Resolución de conflictos

¿Qué son los conflictos?

Un conflicto ocurre cuando Git no puede combinar automáticamente los cambios realizados en las mismas líneas de un archivo por diferentes colaboradores. Esto suele ocurrir al hacer un merge o un pull.

Estrategias para resolver conflictos

1. Cuando ocurre un conflicto, Git marcará las áreas en conflicto en los archivos afectados.
2. Edita el archivo para seleccionar qué cambios mantener.
3. Guarda el archivo y marca el conflicto como resuelto con:

git add archivo_afectado

4. Finaliza el merge con:

git commit

Para evitar conflictos:

• Haz pull frecuentemente para mantener tu rama actualizada.
• Comunica cambios importantes con tu equipo.

Pull requests y merge requests

¿Qué son y cuándo usarlas?

Un pull request (en GitHub) o merge request (en GitLab) es una solicitud para fusionar cambios desde una rama a otra. Estas herramientas facilitan la revisión de código antes de combinar los cambios.

Proceso típico:

1. Sube tus cambios a una rama en el repositorio remoto.
2. Crea una pull request desde la interfaz de la plataforma.
3. Espera la revisión y aprobación de otros miembros del equipo.
4. Una vez aprobado, realiza el merge.

Beneficios:

• Permite una revisión colaborativa de código.
• Facilita la discusión sobre cambios específicos.
• Ayuda a mantener un historial claro y organizado del proyecto.

Rebases

¿Qué es un rebase?

El rebase es una alternativa al merge que reescribe el historial de commits para aplicar los cambios de una rama sobre otra como si se hubieran realizado en secuencia. Esto da como resultado un historial más lineal y fácil de leer.

Comando básico:

git rebase rama_base

Por ejemplo, para aplicar los cambios de tu rama actual sobre la rama main:

git rebase main

Rebase interactivo

El rebase interactivo te permite modificar, combinar o eliminar commits durante el proceso de rebase. Es útil para limpiar el historial antes de subir los cambios.

Comando para iniciar un rebase interactivo:

git rebase -i HEAD~n

Donde n es el número de commits recientes que quieres modificar.

Durante el proceso, puedes realizar acciones como:

• pick: Mantener el commit tal como está.
• reword: Cambiar el mensaje del commit.
• edit: Pausar para modificar el contenido del commit.
• squash: Combinar varios commits en uno.
• drop: Eliminar un commit.

Stashing

Guardar cambios temporalmente

El comando git stash guarda tus cambios actuales de forma temporal para que puedas cambiar de rama o realizar otras acciones sin perder tu trabajo no comprometido.

Comando para guardar cambios:

git stash

Para agregar una descripción al stash:

git stash save "Descripción"

Recuperar cambios guardados

Para recuperar los cambios guardados más recientemente:

git stash apply

Para recuperar y eliminar el stash de la lista:

git stash pop

Para listar todos los stashes guardados:

git stash list

Cherry-picking

Aplicar commits específicos a otra rama

El cherry-picking permite aplicar un commit específico de una rama a otra, sin realizar un merge completo.

Comando básico:

git cherry-pick ID_DEL_COMMIT

Para obtener el ID del commit, puedes usar:

git log

Ejemplo:

git cherry-pick a1b2c3d4

Git hooks

Los hooks de Git son scripts que se ejecutan automáticamente antes o después de eventos clave, como commits, merges o pushes. Son útiles para automatizar tareas como verificar el código o desplegar aplicaciones.

Personalización y automatización con hooks

Los hooks se encuentran en el directorio .git/hooks de tu repositorio. Algunos hooks comunes son:

• pre-commit: Se ejecuta antes de realizar un commit. Útil para verificar el formato del código.
• pre-push: Se ejecuta antes de enviar los cambios al remoto. Puedes usarlo para correr pruebas automatizadas.
• post-merge: Se ejecuta después de un merge. Puede ser útil para actualizar dependencias.

Para habilitar un hook, crea o edita el archivo correspondiente, por ejemplo:

nano .git/hooks/pre-commit

Asegúrate de que el archivo sea ejecutable:

chmod +x .git/hooks/pre-commit

Deshacer cambios

En Git, es común cometer errores o necesitar deshacer ciertos cambios. Dependiendo de la situación, puedes usar diferentes comandos:

Deshacer cambios en archivos no añadidos al área de preparación

Si modificaste un archivo pero aún no usaste git add, puedes revertirlo a su última versión confirmada con:

git checkout -- NOMBRE_ARCHIVO

Por ejemplo:

git checkout -- index.html

Eliminar archivos añadidos al área de preparación

Si añadiste un archivo con git add pero no quieres incluirlo en el próximo commit:

git reset NOMBRE_ARCHIVO

Ejemplo:

git reset index.html

Revertir un commit

Si ya realizaste un commit pero deseas revertirlo, puedes crear un nuevo commit que deshaga los cambios realizados:

git revert ID_DEL_COMMIT

El ID_DEL_COMMIT puede obtenerse con el comando:

git log

Por ejemplo:

git revert a1b2c3d4

Esto abrirá un editor para confirmar el nuevo commit que deshace los cambios del anterior.

Restablecer al estado anterior

Si quieres deshacer cambios de forma más drástica y no necesitas conservar el historial, puedes usar git reset.

Restablecer al último commit confirmado

Para deshacer todos los cambios desde el último commit:

git reset --hard

Nota: Esto eliminará cualquier cambio no confirmado.

Restablecer a un commit específico

Para volver a un estado anterior en el historial:

git reset --hard ID_DEL_COMMIT

Ejemplo:

git reset --hard a1b2c3d4

Advertencia: Esto reescribirá el historial, así que úsalo con precaución, especialmente si ya compartiste los commits con otros.

Recuperar archivos eliminados

Si eliminaste un archivo accidentalmente pero aún no confirmaste el cambio, puedes recuperarlo:

git checkout -- NOMBRE_ARCHIVO

Por ejemplo:

git checkout -- styles.css

Si ya confirmaste la eliminación pero deseas recuperarlo, utiliza:

git checkout ID_DEL_COMMIT -- NOMBRE_ARCHIVO

Por ejemplo:

git checkout a1b2c3d4 -- styles.css

Esto restaurará el archivo desde el commit especificado.

Submódulos

¿Qué son los submódulos?

Un submódulo en Git es un repositorio anidado dentro de otro repositorio. Se utilizan para incluir dependencias o proyectos relacionados que necesitan mantenerse separados pero que forman parte del proyecto principal.

Por ejemplo, si un proyecto utiliza una biblioteca que está en su propio repositorio, puedes incluirla como un submódulo en lugar de copiar el código.

Añadir y gestionar submódulos

Para añadir un submódulo, utiliza el comando:

git submodule add URL_DEL_REPOSITORIO RUTA_DESTINO

Ejemplo:

git submodule add https://github.com/usuario/biblioteca.git libs/biblioteca

Para inicializar y clonar todos los submódulos en un repositorio:

git submodule update --init --recursive

Si deseas actualizar un submódulo a su última versión:

git submodule update --remote

Git y servicios de CI/CD

Integración continua

La integración continua (CI) es una práctica en la que cada cambio en el código se prueba automáticamente para detectar problemas. Con Git, puedes integrarlo fácilmente con servicios de CI como GitHub Actions, Travis CI o GitLab CI.

Un ejemplo de configuración en GitHub Actions sería crear un archivo .github/workflows/ci.yml:

name: CI
        on:
          push:
            branches:
              - main
        jobs:
          build:
            runs-on: ubuntu-latest
            steps:
              - uses: actions/checkout@v3
              - name: Configurar entorno
                run: npm install
              - name: Ejecutar pruebas
                run: npm test

Deploy automático con Git

El deploy automático implica enviar cambios automáticamente a un servidor de producción o un entorno de prueba después de confirmarlos en una rama específica. Esto puede configurarse con herramientas como:

• GitHub Actions: Automatiza el despliegue a plataformas como Heroku, AWS o servidores personalizados.
• GitLab CI/CD: Configura un .gitlab-ci.yml para definir etapas de prueba y despliegue.

Por ejemplo, para un despliegue a Heroku:

deploy:
          provider: heroku
          api_key: $HEROKU_API_KEY
          app: nombre-de-tu-app

Buenas prácticas con Git

Convenciones de nombres

Es importante seguir convenciones claras para los nombres de ramas, commits y etiquetas:

• Nombres de ramas: Usa nombres descriptivos, como feature/nueva-funcionalidad, bugfix/arreglo-de-error.
• Nombres de etiquetas: Usa etiquetas semánticas para releases, como v1.0.0.

Ramas principales y de características

Adopta un flujo de trabajo con ramas bien definido, como:

• main: Rama estable, lista para producción.
• develop: Rama de desarrollo, donde se integran nuevas características antes de pasarlas a main.
• feature/*: Ramas para desarrollar nuevas funcionalidades.
• hotfix/*: Ramas para corregir errores críticos en producción.

Este enfoque ayuda a mantener el control y la organización en proyectos complejos.

Git en la terminal

Trabajar con Git desde la terminal es la forma más directa y potente de utilizarlo. Con comandos bien estructurados, puedes realizar todas las operaciones necesarias. Algunas ventajas de usar Git en la terminal son:

• Control total sobre las operaciones de Git.
• Velocidad y eficiencia al no depender de interfaces gráficas.
• Aprendizaje profundo de cómo funciona Git internamente.

Para empezar, asegúrate de tener un terminal configurado con acceso a Git. Si usas Windows, Git Bash es una excelente opción. En macOS y Linux, el terminal nativo ya incluye soporte para Git después de instalarlo.

Interfaz gráfica de Git

Si prefieres una experiencia más visual, existen muchas herramientas gráficas para trabajar con Git. Algunas opciones populares incluyen:

• GitHub Desktop: Ideal para usuarios de GitHub, con una interfaz sencilla y útil para principiantes.
• Sourcetree: Ofrece funciones avanzadas como visualización de ramas y resolución de conflictos, ideal para proyectos complejos.
• GitKraken: Una herramienta moderna y amigable para usuarios con cualquier nivel de experiencia.
• Visual Studio Code: Con extensiones integradas como GitLens, puedes trabajar con Git directamente desde tu editor de código.

Estas herramientas son útiles para tareas como visualización del historial, resolución de conflictos y manejo de ramas, especialmente si estás empezando con Git.

Recursos para aprender más sobre Git

El aprendizaje continuo es clave para dominar Git. Aquí tienes una selección de recursos recomendados:

Documentación oficial

La documentación oficial de Git es una referencia completa y detallada sobre todas sus características. Puedes encontrarla en:

• https://git-scm.com/doc

Tutoriales recomendados

Algunos tutoriales y cursos en línea te pueden ayudar a aprender Git de manera práctica:

• Atlassian Git Tutorials: Una guía detallada desde conceptos básicos hasta avanzados.
• FreeCodeCamp: Git and GitHub for Beginners: Un excelente punto de partida para principiantes.
• Pro Git Book: Un libro gratuito en línea para profundizar en Git.

Foros y comunidades

Únete a comunidades activas para resolver dudas, compartir conocimientos y estar al día con las mejores prácticas:

• Stack Overflow: Una comunidad global de desarrolladores donde puedes hacer preguntas específicas sobre Git.
• GitHub Community: El foro oficial de GitHub para desarrolladores de todos los niveles.
• Reddit: r/git: Un espacio para discutir temas relacionados con Git.

Con estos recursos, tendrás una base sólida para convertirte en un experto en Git.

Comandos más comunes

A continuación, se presenta una lista de los comandos de Git más utilizados, con una breve descripción de su función:

• git init: Inicializa un nuevo repositorio de Git en la carpeta actual.
• git clone [URL]: Clona un repositorio remoto en tu sistema local.
• git status: Muestra el estado actual del repositorio, incluyendo cambios sin añadir y sin confirmar.
• git add [archivo]: Añade un archivo específico al área de preparación.
• git add .: Añade todos los archivos modificados al área de preparación.
• git commit -m "mensaje": Guarda los cambios en el repositorio con un mensaje explicativo.
• git push origin [rama]: Sube los cambios al repositorio remoto en la rama especificada.
• git pull: Obtiene y fusiona los cambios del repositorio remoto.
• git branch: Muestra la lista de ramas existentes y resalta la rama actual.
• git checkout [rama]: Cambia a la rama especificada.
• git merge [rama]: Fusiona los cambios de una rama específica en la rama actual.
• git log: Muestra el historial de commits del repositorio.
• git reset [archivo]: Elimina un archivo del área de preparación.
• git revert [commit]: Crea un nuevo commit que revierte los cambios de un commit anterior.

Tabla de comandos rápidos

Una tabla compacta para consultar rápidamente los comandos esenciales:

Glosario de términos de Git

Algunos términos clave que te ayudarán a entender Git:

Repositorio

El lugar donde Git almacena el historial de cambios y los archivos del proyecto.

Commit

Un punto de guardado en el historial del proyecto que incluye los cambios realizados en los archivos.

Rama

Una línea de desarrollo independiente dentro del repositorio.

Remoto

Un repositorio alojado en un servidor externo, como GitHub o GitLab.

Staging (Área de preparación)

Una etapa intermedia donde seleccionas los cambios que deseas incluir en el próximo commit.

Merge

La acción de combinar los cambios de una rama en otra.

Rebase

Un método para mover o combinar commits en una nueva base en el historial.

Conflicto

Ocurre cuando dos ramas tienen cambios incompatibles en el mismo archivo.

Tag

Un marcador para identificar puntos específicos en el historial, como versiones lanzadas.