02. Git & GitHub

Control de versiones: GIT

Git es un sistema de control de versiones que permite realizar un seguimiento de los cambios en el código fuente u otros archivos de texto.

El sistema de control de Git está estructurado en tres áreas clave:

• Working Directory (Directorio de trabajo),
• Staging Area (Área de Preparación)
• “Local” Repository (Repositorio local).

Git workflow

Es un conjunto de prácticas recomendadas para trabajar de manera eficiente y productiva. Este flujo define cómo añadir, probar y fusionar nuevas funcionalidades de forma que se eviten conflictos y problemas.

Un buen flujo de trabajo ofrece:

• Facilidad para deshacer cambios y corregir errores.
• Escalabilidad, adaptándose tanto a equipos pequeños como grandes.
• Claridad y simplicidad, permitiendo que todo el equipo trabaje de manera coherente.

¿Que es GitHub?

GitHub es una plataforma en línea donde se pueden guardar y manejar los proyectos de software.

GitHub proporciona una serie de herramientas y características adicionales que mejoran el flujo de trabajo, tales como:

• Reportar y seguir problemas.
• Revisar cambios.
• Automatizar tareas.
• Wiki y Páginas de GitHub.

Las características más relevantes son:

• Creación de repositorios
• Utiliza Git para el control de versiones.
• Facilita la colaboración en proyectos.
• Se pueden hacer pull requests (PR) para sugerir cambios a un repositorio.
• Los colaboradores de un proyecto pueden revisar los cambios de la PR.
• Proporciona herramientas para el seguimiento de problemas y tareas.
• Es conocido por ser un centro para proyectos de código abierto.

¿Qué es una pull request?

Es una solicitud para integrar cambios (commits) de una rama de desarrollo a otra, comúnmente de una rama de un fork o de una rama secundaria a la rama principal o main.

Proceso para subir cambios de una rama

1. Crear una nueva rama
2. Realizar cambios y commits en la rama
3. Asegurarse de que la rama local esté actualizada con la rama principal.
4. Subir los cambios a Github
5. Crear una PR hacia el repositorio o rama objetiva.
6. Revisión por el equipo
7. Hacer merge en la rama principal o de desarrollo.

Definiciones Claves

Repositorio: Es un espacio centralizado donde se almacena, organiza y mantiene la información.

Commit: Capturas instantáneas de los archivos en momentos específicos.

Markdown: Es un lenguaje de marcado ligero diseñado para facilitar la lectura y escritura.

README.md: Es la primera página de documentación del proyecto. Sirve para:

• Describir el proyecto.
• Instrucciones de instalación.
• Uso y ejemplos.
• Enlaces a documentación adicional.
• Información para contribuyentes.
• Licencia.
• Contacto y reconocimientos.
• Badges

HEAD: Commit más reciente en la rama activa

Ramas: Permiten crear "caminos paralelos" para experimentar, desarrollar nuevas características o solucionar errores sin alterar la rama principal.

origin: Es un alias que apunta a la URL del repositorio remoto donde está almacenado el proyecto.

Comandos

git init -> Inicializa un nuevo repositorio (proyecto) y si ya existe, se reinicia.

git status -> Muestra los archivos que han cambiado desde el último commit y los cambios preparados para el próximo commit.

git add . -> Mueve todos los archivos del working area al staging area.

git add [nombre_del_archivo] -> Agrega un archivo específico

git commit -m [mensaje_descriptivo] -> Toma los cambios del staging area y los añade al local repository

git log -> Permite ver el historial de commits.

git log --oneline -> Lista condensada con cada commit en una sola línea.

git log --graph -> Representación de las ramificaciones y fusiones en el historial de commits.

touch <nombre_del_archivo> -> Crea un nuevo archivo con el nombre especificado.

Para configurar GIT

La configuración inicial consiste en establecer nombre de usuario y dirección de correo:

git config --global user.name [user]
git config --global user.email [user@mail.com]

Para verificar el nombre de usuario y el correo configurado:

git config --global user.name
git config --global user.email

Marco de colores para los comandos:

git config --global color.ui true

Iniciando repositorio

Inicializa un nuevo repositorio (proyecto) y si ya existe, se reinicia.

git init

Clona el repositorio de GitHub o BitBucket

git clone <url>

git add

Mueve todos los archivos del working area al staging area:

git add .

Agrega un archivo específico:

git add <nombre_del_archivo>

Añade todos los archivos nuevos, modificados y eliminados

git add --all

Añade todos los archivos con una extensión específica:

git add *.txt

Añade todos los archivos dentro de un directorio:

git add docs/

Añade todos los archivos de una extensión específica dentro de un directorio:

git add docs/*.txt

git rm

Borra un archivo del repositorio y lo prepara para el próximo commit:

git rm <archivo>

Para este caso no se usaría git add

git commit

Toma los cambios del staging area y los añade al local repository:

git commit -m "[mensaje_descriptivo]"

Agrega y carga en el HEAD los cambios realizados, en lugar de hacer git add <archivo> y luego git commit:

git commit -a -m "[mensaje_descriptivo]"

-a: Indica que Git debe incluir todos los archivos que han sido modificados y rastreados (No incluye archivos nuevos que no han sido rastreados).

Modifica el último commit:

git commit --amend -m "[mensaje_descriptivo]"

Remplaza el último commit con un nuevo commit que incluye todos los cambios que ya estaban en el commit original, más cualquier cambio adicional que se haya añadido

Quita del HEAD un archivo y le pone el estado untracked:

git checkout -- <file>
# También se puede usar: 
# git restore --staged <file>  

git log

Permite ver el historial de commits:

git log

Lista condensada con cada commit en una sola línea.

git log --oneline

Representación de las ramificaciones y fusiones en el historial de commits.

git log --oneline --graph

Para trabajar con ramas

Lista todas las ramas locales del repositorio local actual:

git branch

Crear una nueva rama local:

git branch <nombre_de_la_rama>

Elimina localmente la rama indicada solo si ha sido fusionada con la rama actual:

git branch -d <nombre_de_la_rama>

Elimina localmente la rama sin verificar si ha sido fusionada con la rama actual:

git branch -D <nombre_de_la_rama>

Cambia de rama:

git checkout <nombre_de_la_rama>
# Más reciente: 
git switch <nombre_de_la_rama>

Crea una nueva rama y cambia a ella inmediatamente:

git checkout -b <nombre_de_la_rama>

Crea un rama en base a una branch del repositorio remoto:

git switch -c <nuevo_nombre_de_la_rama> origin/branch-name  
# Antes git checkout -b

Para trabajar con el repositorio remoto

Clona un repositorio desde GitHub u otro servicio de alojamiento de Git:

git clone <url>

Clona un repositorio y le da un nombre específico al directorio clonado:

git clone <url> git-demo

Vincula un repositorio local con un repositorio remoto:

git remote add origin <url>:

origin es un nombre convencional que se da al repositorio remoto principal.

git push

Envía los cambios locales de la rama al repositorio remoto en la rama especificada:

git push origin <nombre_de_la_rama>

Si la rama remota no existe, el comando creará una nueva rama remota con el nombre especificado.

Sube los cambios al repositorio remoto y establece una rama de seguimiento upstream para la rama local actual:

git push -u origin <nombre_de_la_rama>

De este modo no se necesitará especificar el nombre del repositorio remoto y la rama, ya que quedará por defecto.

git fetch

Descarga los cambios del repositorio remoto pero no los fusiona en la rama.

git fetch

Se puede revisar los cambios antes de decidir integrarlos en la rama de trabajo local.

git merge

Une el branch actual con el especificado:

git merge <nombre_de_la_rama>  

Si no hay conflictos, Git realiza la fusión automáticamente. Si hay conflictos, se debe resolver manualmente para completar la fusión.

git pull

Trae los cambios de otra rama, y los fusiona con la rama actual:

git pull origin <nombre_de_la_rama>
# Para asegurar que los cambios estén sincronizados con los últimos cambios en main:
git pull origin main 

Note

En Visual Studio Code:

• Accept Current Change: para aceptar la versión del repositorio local como la versión correcta y más actual.
• Accept Incoming Change: para aceptar la versión que viene del repositorio remoto como la versión correcta y más actual.
• Accept Both Changes: para aceptar ambos cambios.
• Compare Changes: para comparar los campos.

---

Cuando deseamos integrar una rama con otra podemos hacer pull desde la rama que vamos a integrar. Por ejemplo si vamos a hacer pull de "languages", hacia develop debemos:

# 1.Cambiar a la rama de comparación
git checkout languages
# 2. Traer los cambios desde el repositorio remoto de la rama a la que le vamos a hacer PR
git pull origin develop
# 3. Resolver conflictos
# 4. Adicionar los cambios
git add <nombre_del_archivo>
# 5. Hacer commit
git commit -m [mensaje]
# 6. Enviar los cambios al repositorio remoto
git push origin languages
# 7. Desde GitHub hacer PR e integrar los cambios
# 8. Moverse a la rama develop y hacer pull para traer los cambios al repositorio local
git pull origin develop

git remote

Muestra la lista de los repositorios remotos a los que se le está haciendo fetch y push:

git remote -v

Cambia la URL del repositorio remoto asociado al nombre origin:

git remote set-url origin <url>

Otros Comandos

git reset

Saca un archivo del commit:

git reset HEAD <archivo>

El archivo queda en estado unstaged.

Devuelve el último commit que se hizo y pone los cambios en staging:

git reset --soft HEAD^

Devuelve el último commit, restableciendo los archivos al estado de ese commit anterior:

git reset --hard HEAD^

Devuelve los 2 últimos commits y todos los cambios al estado del commit anterior:

git reset --hard HEAD^^

Restablece el estado del repositorio al commit especificado:

git log
git reset --hard <commit_sha>

Todos los cambios que se hicieron en los commits posteriores al commit seleccionado se eliminarán.

git rebase

Une el branch actual con el master:

git rebase

git rebase altera el historial de commits.

Continúa la secuencia del rebase donde se pausó (si hay conflicto):

git rebase --continue

Omite el conflicto y sigue adelante:

git rebase --skip

Devuelve todo al principio del rebase:

git rebase --abort

Hace un rebase a un branch específico:

git rebase <nameBranch>