git – comandos básicos

Aquí tienes algunos comandos básicos de Git que pueden ser útiles:

1. git init: Inicializa un repositorio Git en un directorio local.
2. git clone [url]: Clona un repositorio remoto en tu directorio local.
3. git status: Muestra el estado actual del repositorio.
4. git add [file]: Añade un archivo al área de preparación (staging).
5. git commit -m «[message]»: Guarda los cambios en el repositorio.
6. git push: Sube los cambios locales al repositorio remoto.
7. git pull: Obtiene y fusiona los cambios remotos en tu repositorio local.
8. git branch: Muestra las ramas locales.
9. git checkout [branch]: Cambia a una rama específica.
10. git merge [branch]: Fusiona una rama especificada con la rama actual.
11. git remote -v: Muestra los repositorios remotos configurados.
12. git log: Muestra el historial de commits.
13. git diff: Muestra las diferencias entre commits, el área de preparación y el directorio de trabajo.
14. git reset [file]: Quita un archivo del área de preparación, pero conserva los cambios en el directorio de trabajo.
15. git rm [file]: Elimina un archivo del repositorio.

Ejemplos

Para mostrar todas las ramas de un repositorio, puedes usar el siguiente comando:

git branch -a

Este comando mostrará tanto las ramas locales como las ramas remotas del repositorio. Las ramas locales se mostrarán con un asterisco (*) antes del nombre de la rama actual, y las ramas remotas se mostrarán con el prefijo «remotes/».

Para traer todas las ramas del repositorio remoto a tu repositorio local, puedes utilizar el siguiente comando:

git fetch --all

Este comando descargará todas las ramas del repositorio remoto a tu repositorio local, pero no las fusionará automáticamente con tus ramas locales existentes.

Para fusionar una rama remota específica en tu rama local, puedes usar el comando git checkout seguido del nombre de la rama remota:

git checkout nombre_rama_remota

Si deseas fusionar todas las ramas remotas (traerlas a local) que has descargado con git fetch --all, puedes utilizar el siguiente comando:

git pull --all

Esto fusionará todas las ramas remotas que has descargado con tus ramas locales existentes.

Para traer una rama específica del repositorio original a tu fork, primero necesitas agregar el repositorio original como un remoto en tu repositorio local si aún no lo has hecho. Puedes hacerlo con el siguiente comando, reemplazando [url_repositorio_original] con la URL del repositorio original:

git remote add upstream [url_repositorio_original]

Una vez que hayas agregado el repositorio original como un remoto, puedes traer la rama específica del repositorio original a tu fork con los siguientes pasos:

1. Actualiza la información sobre las ramas remotas ejecutando:

git fetch upstream

2. Cambia a la rama que deseas traer del repositorio original. Por ejemplo, si la rama se llama nueva_funcionalidad:

git checkout -b nueva_funcionalidad upstream/nueva_funcionalidad

3. Sube la nueva rama a tu fork en GitHub (si lo deseas):

git push origin nueva_funcionalidad

Estos pasos te permitirán traer una rama específica del repositorio original a tu fork y trabajar en ella desde tu repositorio local.

Para actualizar tu rama original con los cambios y mejoras de un fork específico, puedes seguir estos pasos:

Agrega el fork como un remoto en tu repositorio local. Reemplaza [url_fork] con la URL del fork:

git remote add fork [url_fork]

Actualiza la información sobre las ramas remotas ejecutando:

git fetch fork

Revisa las diferencias entre tu rama original y la rama del fork. Puedes usar git diff para ver las diferencias antes de fusionar los cambios:

git diff origin/tu_rama_original fork/rama_del_fork

Si estás satisfecho con los cambios y deseas fusionarlos en tu rama original, puedes hacerlo con el comando git merge. Asegúrate de estar en tu rama original antes de fusionar:

git checkout tu_rama_original git merge fork/rama_del_fork

Resuelve cualquier conflicto que pueda surgir durante la fusión.

Una vez resueltos los conflictos y fusionados los cambios, puedes subir los cambios a tu repositorio original si lo deseas:bashCopy code

git push origin tu_rama_original

Con estos pasos, habrás actualizado tu rama original con los cambios y mejoras del fork específico.

Si deseas reemplazar completamente el contenido de tu rama original con el contenido de una rama específica de un fork, puedes hacerlo de la siguiente manera:

Asegúrate de tener guardados todos los cambios importantes en un commit o en otra rama para no perderlos.

Agrega el fork como un remoto en tu repositorio local. Reemplaza [url_fork] con la URL del fork:

git remote add fork [url_fork]

Actualiza la información sobre las ramas remotas ejecutando:bashCopy codegit fetch fork

Reemplaza el contenido de tu rama original con el contenido de la rama del fork. Asegúrate de estar en tu rama original antes de hacer esto:

git checkout tu_rama_original 

git reset --hard fork/rama_del_fork

Una vez reemplazado el contenido, puedes subir los cambios a tu repositorio original si lo deseas:

git push origin tu_rama_original --force

El uso de --force es necesario porque estás reescribiendo la historia de la rama, lo cual puede ser peligroso si otros colaboradores también están trabajando en esa rama. Asegúrate de comunicar claramente tus acciones si hay otros colaboradores involucrados.

Para reflejar el cambio de nombre de una rama local en el repositorio remoto, puedes seguir estos pasos:

Por ejemplo, si quieres cambiar el nombre de la rama mi_rama_antigua a mi_rama_nueva, ejecuta el siguiente comando:

git branch -m mi_rama_antigua mi_rama_nueva

Elimina la rama antigua del repositorio remoto y sube la nueva rama con el nuevo nombre. Utiliza el siguiente comando para eliminar la rama antigua del repositorio remoto:

git push origin --delete mi_rama_antigua 

Y luego sube la nueva rama con el nuevo nombre:

git push origin mi_rama_nueva

Con estos pasos, habrás cambiado el nombre de la rama local y reflejado ese cambio en el repositorio remoto.

Para actualizar la rama master con los cambios de la rama develop, puedes hacerlo mediante un merge o un rebase, dependiendo de tu flujo de trabajo preferido. Aquí te muestro cómo hacerlo con ambos métodos:

Usando Merge:

1. Asegúrate de estar en la rama master: checkout master
2. Realiza un merge de la rama develop en master:
   git merge develop
   Esto fusionará los cambios de develop en master.

Usando Rebase:

1. Asegúrate de estar en la rama master:
   git checkout master
2. Haz un rebase de la rama develop en master:
   git rebase develop
   Esto moverá los commits de develop encima de master, reorganizando la historia.

Es importante tener en cuenta que si trabajas en un proyecto compartido, es posible que desees discutir estos cambios con tu equipo, ya que un rebase puede alterar la historia del repositorio de una manera que no sea compatible con el flujo de trabajo de tu equipo.

Si al querer actualizar la rama maste con la rama develop obtienes el mensaje «fatal: rehusando fusionar historias no relacionadas» en Git indica que Git no puede realizar el merge porque las historias de las ramas que estás intentando fusionar no tienen un ancestro común. Esto generalmente ocurre cuando las ramas han divergido significativamente y no se pueden fusionar automáticamente.

Para resolver este problema, puedes optar por realizar un merge con estrategia recursiva y resolver manualmente las diferencias o puedes hacer un rebase de develop sobre master si quieres mantener una historia lineal. Aquí te muestro cómo hacerlo:

Usando Merge con Estrategia Recursiva:

1. Asegúrate de estar en la rama master:
   git checkout master
2. Realiza un merge con la estrategia recursiva, que te permitirá resolver manualmente las diferencias:
   git merge --allow-unrelated-histories develop Git te guiará a través de la resolución de conflictos si los hay. Una vez resueltos, el merge se completará.

Usando Rebase:

1. Asegúrate de estar en la rama develop:
   git checkout develop
2. Haz un rebase de develop sobre master:
   git rebase master
   Esto moverá los commits de develop encima de master, reorganizando la historia.

Es importante recordar que, al reorganizar la historia con un rebase, estás alterando la historia del repositorio, lo cual puede ser problemático si estás trabajando en un proyecto compartido. Si no estás seguro de cuál método es más adecuado para tu situación, es recomendable consultar con tu equipo antes de proceder.

Para traer una rama específica del repositorio origin (que es el repositorio remoto original del cual has hecho un fork) a tu fork en GitHub, puedes seguir estos pasos:

1. Agrega el repositorio origin como un nuevo remoto en tu repositorio local si aún no lo has hecho. Sustituye <url_repositorio_original> por la URL del repositorio origin:
   git remote add upstream <url_repositorio_original>
2. Obtiene las últimas actualizaciones del repositorio origin:
   git fetch upstream
3. Crea y cambia a una nueva rama local basada en la rama que deseas traer de origin. Sustituye <nombre_rama_origin> por el nombre de la rama en origin y <nombre_nueva_rama_local> por el nombre que deseas darle a la nueva rama local:
   git checkout -b <nombre_nueva_rama_local> upstream/<nombre_rama_origin>
4. Sube la nueva rama local a tu fork en GitHub:
   git push origin <nombre_nueva_rama_local>

Con estos pasos, habrás traído una rama específica del repositorio origin a tu fork en GitHub. Ahora puedes trabajar en la nueva rama localmente y, si lo deseas, hacer un pull request desde esta rama en tu fork hacia la rama correspondiente en origin.

Para reemplazar el contenido de la rama develop con el de feature/login-basev2, puedes seguir estos pasos. Antes de continuar, ten en cuenta que esto reescribirá la historia de la rama develop con la de feature/login-basev2, por lo que es importante asegurarte de que esto es lo que deseas hacer y de que tienes una copia de seguridad de la rama develop en caso de que necesites recuperarla más tarde.

1. Asegúrate de estar en la rama develop:b
   git checkout develop
2. Haz un reset de la rama develop al commit de feature/login-basev2:
   git reset --hard feature/login-basev2
   Con este comando, la rama develop se moverá al commit de feature/login-basev2 y el contenido de feature/login-basev2 se aplicará a develop.
3. Actualiza el repositorio remoto con los cambios. Esto reemplazará la historia de la rama develop en el repositorio remoto con la nueva historia:
   git push origin develop --force

Con estos pasos, habrás reemplazado el contenido de la rama develop con el de feature/login-basev2. Asegúrate de entender las implicaciones de este proceso y de tener una copia de seguridad de la rama develop antes de continuar.

En local estoy en develop, modifiqué archivos e hice commit, pero debería haberlo hecho en la rama feature/login-basev2 ¿cómo soluciono el error?

# Asegúrate de estar en la rama develop 
    git checkout develop 

# Crea una nueva rama temporal a partir de develop con tus cambios 
    git checkout -b temp-branch 

# Rebasea temp-branch sobre feature/login-basev2 
    git rebase feature/login-basev2 

# Cambia a la rama feature/login-basev2 
    git checkout feature/login-basev2 

# Fusiona temp-branch en feature/login-basev2 
    git merge temp-branch 

# Borra la rama temporal 
    git branch -d temp-branch 

# Si es necesario, actualiza el repositorio remoto 
    git push origin feature/login-basev2

1. Asegúrate de que tus cambios estén correctamente fusionados en feature/login-basev2 y de que esta rama esté actualizada con la última versión de origin:
   git checkout feature/login-basev2
git pull origin feature/login-basev2
2. Sube tus cambios a tu repositorio remoto:
   git push origin feature/login-basev2
3. Ve a la página de GitHub de tu repositorio y deberías ver un mensaje que te permite crear un pull request desde feature/login-basev2 a la rama develop de origin.
4. Haz clic en el botón para crear un pull request y sigue las instrucciones en la página para completar la solicitud. Asegúrate de proporcionar información relevante sobre tus cambios en el cuerpo del pull request.
5. Espera a que el propietario del repositorio origin revise tu pull request y decida si aceptarlo, rechazarlo o solicitar cambios adicionales.

Recuerda que el proceso exacto puede variar ligeramente dependiendo de la configuración específica del repositorio y de tu flujo de trabajo.