Skip to content

git.md

Latest commit

 

History

History
1096 lines (721 loc) · 34.4 KB

git.md

File metadata and controls

1096 lines (721 loc) · 34.4 KB
Raw

Git tips

Estándar commits

commits-standard.png

  • Estructura general: commits-structure.jpg

Repositorio temporal

Clonar a un repositorio temporal para luego extraer en la carpeta raiz e eliminar la carpeta original(copiada de github con el seguimiento)

Sirve para copiar repos sin permiso del autor y dejar de seguir Para ejecutar correctamente se debe lanzar los codigos en la carpeta donde se va a crear el proyecto

  • 1 Clona el repositorio en una carpeta temporal.
  • 2 Mueve los archivos del repositorio clonado a la ubicación deseada.
  • 3 Elimina la carpeta temporal.
git clone URL_del_repositorio tmp_repo
mv tmp_repo/* .
rm -rf tmp_repo

Git pull especial

Comando para cuando tenemos un repositorio que no tiene un seguimiento y lo queremos subir a continuacion de un repositiorio ya existente Ojo, hay que tener commit los archivos

Después de ejecutar este comando, Git intentará fusionar las historias de las dos ramas. Sin embargo, ten en cuenta que es posible que tengas que resolver conflictos si existen diferencias significativas entre las ramas.

git pull origin main --allow-unrelated-histories

Git restore losed Github remote

git remote add origin nombre_de_tu_repositorio

Git push NEW "rama"

Hacer el add y commit, despues:

git checkout -b nombre_de_tu_rama
git push origin nombre_de_tu_rama

Unfollow a Github

Dejar de seguir al repositorio actual en la nube

git remote -v
git remote remove nombre_de_tu_repo(origin ...)

Git pull

Traer los cambios del remoto (repositorio nube Github) al local (maquina)

  • Abre tu terminal o línea de comandos.
  • Navega hasta el directorio de tu repositorio local utilizando el comando cd.
  • Asegúrate de que estás en la rama correcta utilizando el comando git branch. Si no estás en la rama correcta, cambia a la rama adecuada usando git checkout <nombre_de_rama>.
  • Una vez estés en la rama correcta, utiliza el comando git pull para traer los cambios del repositorio remoto a tu repositorio local.

Eliminar git

Borrando todo el interior de la carpeta

  • Abre la terminal o el símbolo del sistema en tu sistema operativo.
  • Navega al directorio que contiene el repositorio local que deseas dejar de seguir.
  • Utiliza el comando rm -rf <nombre_del_repositorio> para eliminar el directorio del repositorio local y todos sus contenidos.

Borrando solo el git

Eliminando el archivo . git

  • Navega al directorio raíz del repositorio local que deseas dejar de seguir.
  • Utiliza el comando rm -rf .git para eliminar el directorio .git y todos sus contenidos.

Git branch merge

Traerte los cambios de una branch a otra rama ("principal"). Para traer los cambios de una rama a otra en Git usando Bash, puedes seguir estos pasos:

Opción 1: Usando merge

  1. Cambia a la rama de destino:

    git checkout nombre-de-la-rama-destino

  2. Haz el merge con la rama de origen:

    git merge nombre-de-la-rama-origen

  3. Envía los cambios al repositorio remoto:

    git push origin nombre-de-la-rama-destino

Opción 2: Usando rebase

  1. Cambia a la rama de destino:

    git checkout nombre-de-la-rama-destino

  2. Rebase con la rama de origen:

    git rebase nombre-de-la-rama-origen

  3. Envía los cambios al repositorio remoto:

    git push origin nombre-de-la-rama-destino

Ejemplo práctico

Supongamos que tienes dos ramas, main y feature-branch, y quieres traer los cambios de feature-branch a main.

Usando merge:

  1. Cambia a la rama main:

    git checkout main

  2. Haz el merge con feature-branch:

    git merge feature-branch

  3. Envía los cambios al repositorio remoto:

    git push origin main

Usando rebase:

  1. Cambia a la rama main:

    git checkout main

  2. Rebase con feature-branch:

    git rebase feature-branch

  3. Envía los cambios al repositorio remoto:

    git push origin main

Recuerda que, en el caso de rebase, si el rebase crea conflictos, necesitarás resolverlos y continuar el rebase con:

git rebase --continue

Y luego hacer el push de los cambios.

Eliminar rama en Github(remoto)

Para eliminar una rama existente en tu repositorio de GitHub (remoto), puedes usar el siguiente comando desde Bash:

  1. Elimina la rama remota:

    git push origin --delete nombre-de-la-rama

Ejemplo práctico

Supongamos que deseas eliminar la rama llamada feature-branch del repositorio remoto en GitHub:

git push origin --delete feature-branch

Pasos adicionales (opcional)

Eliminar rama en Git(local)

Para eliminar la rama localmente (en tu máquina), puedes usar:

  1. Cambia a otra rama (para no estar en la rama que deseas eliminar):

    git checkout main

  2. Elimina la rama local:

    git branch -d nombre-de-la-rama

    Si la rama tiene cambios que no se han fusionado, puedes usar -D (mayúscula) para forzar la eliminación:

    git branch -D nombre-de-la-rama

Ejemplo práctico

Para eliminar feature-branch localmente:

  1. Cambia a otra rama:

    git checkout main

  2. Elimina la rama localmente:

    git branch -d feature-branch

    O forzar la eliminación si tiene cambios no fusionados:

    git branch -D feature-branch

De esta manera, habrás eliminado la rama tanto del repositorio remoto en GitHub como localmente en tu máquina.

Eliminar varias ramas en Git(local)

Claro, aquí tienes la explicación corregida para eliminar todas las ramas locales excepto v01 y v01.03:

Cómo eliminar todas las ramas locales excepto v01 y v01.03

Para eliminar todas las ramas locales excepto v01 y v01.03, puedes usar un script en Bash que lista todas las ramas y luego elimina las que no coinciden con v01 y v01.03.

Comando

git branch | grep -v "^\* \| v01$ \| v01.03$" | xargs git branch -d

Explicación del comando

  1. Listar todas las ramas locales:

    git branch

    Esto muestra todas las ramas locales. La salida se verá algo así:

      main
  v01
  v01.01
  v01.01.01
  v01.02
  v01.02.00
  v01.02.1
  v01.02.2
  v01.02.3
* v01.03

  2. Filtrar las ramas para excluir v01 y v01.03:

    grep -v "^\* \| v01$ \| v01.03$"

    Este filtro excluye:

    • La rama actual (indicada por *).
    • La rama v01.
    • La rama v01.03.

  3. Eliminar las ramas filtradas:

    xargs git branch -d

    Este comando toma la salida del filtro anterior y pasa cada nombre de rama al comando git branch -d para eliminarla.

Paso a paso detallado

  1. Listar todas las ramas:

    Ejecuta el siguiente comando para listar todas las ramas locales:

    git branch

  2. Filtrar y eliminar las ramas no deseadas:

    Ejecuta el siguiente comando para filtrar y eliminar todas las ramas excepto v01 y v01.03:

    git branch | grep -v "^\* \| v01$ \| v01.03$" | xargs git branch -d

    Este comando eliminará todas las ramas locales excepto v01 y v01.03.

Nota adicional

  • Si algunas de las ramas tienen cambios no fusionados y necesitas forzar la eliminación, puedes usar -D en lugar de -d:

    git branch | grep -v "^\* \| v01$ \| v01.03$" | xargs git branch -D

    Ten cuidado con este comando, ya que eliminará las ramas sin preguntar si tienen cambios no fusionados.

Esto asegura que las ramas v01 y v01.03 no se eliminen y todas las demás ramas locales sean eliminadas.

Git fetch

Actualizar rama de Git con la rama de Github Para traer los cambios que han ocurrido en una rama de un repositorio remoto de GitHub a tu repositorio local, puedes seguir estos pasos:

Paso 1: Configurar el repositorio remoto

Primero, asegúrate de que tu repositorio local esté configurado para rastrear el repositorio remoto de GitHub.

Si no lo has hecho, añade el repositorio remoto:

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

Paso 2: Actualizar las referencias remotas

Actualiza la información de las ramas remotas:

git fetch origin

Paso 3: Integrar los cambios

Dependiendo de si quieres integrar los cambios en tu rama actual o en una rama específica, puedes usar merge o rebase.

Opción 1: Usar merge

  1. Cambiar a la rama en la que deseas integrar los cambios (por ejemplo, main):

    git checkout main

  2. Hacer el merge de los cambios de la rama remota:

    git merge origin/nombre-de-la-rama

Opción 2: Usar rebase

  1. Cambiar a la rama en la que deseas integrar los cambios (por ejemplo, main):

    git checkout main

  2. Hacer el rebase de los cambios de la rama remota:

    git rebase origin/nombre-de-la-rama

Ejemplo práctico

Supongamos que tienes una rama llamada feature-branch en tu repositorio remoto en GitHub, y quieres traer esos cambios a tu rama local main.

Usar merge

  1. Cambia a la rama main:

    git checkout main

  2. Trae los cambios de la rama remota feature-branch:

    git fetch origin
git merge origin/feature-branch

Usar rebase

  1. Cambia a la rama main:

    git checkout main

  2. Trae los cambios de la rama remota feature-branch:

    git fetch origin
git rebase origin/feature-branch

Nota

  • Si no tienes la rama local correspondiente, puedes crearla directamente desde la rama remota:

    git checkout -b nombre-de-la-rama-local origin/nombre-de-la-rama-remota

  • Después de hacer merge o rebase, si deseas actualizar el repositorio remoto con tus cambios locales (en caso de que haya nuevos commits), usa:

    git push origin nombre-de-la-rama

Siguiendo estos pasos, podrás traer los cambios de una rama de tu repositorio de GitHub a tu repositorio local de manera eficiente.

Git fetch vs git pull

Diferencias entre git fetch y git pull

  • git fetch:

    • git fetch actualiza tu repositorio local con los cambios más recientes del repositorio remoto. No fusiona esos cambios en tu rama actual; simplemente actualiza las referencias remotas.
    • Esto te permite revisar los cambios antes de integrarlos.

  • git pull:

    • git pull es equivalente a ejecutar git fetch seguido de git merge. Trae los cambios del repositorio remoto y los fusiona directamente en tu rama actual.

Cuándo usar git fetch

Usar git fetch seguido de un comando como git merge o git rebase te da más control sobre cómo y cuándo integras los cambios. Este enfoque es útil cuando deseas revisar los cambios antes de aplicarlos.

Ejemplo práctico usando git fetch

  1. Actualizar las referencias remotas:

    git fetch origin

  2. Revisar los cambios (opcional):

    Puedes revisar los cambios que se han traído con fetch antes de fusionarlos.

    git log origin/nombre-de-la-rama

  3. Integrar los cambios:

    • Usando merge:

      Cambia a la rama en la que deseas integrar los cambios (por ejemplo, main):

      git checkout main

      Haz el merge con la rama remota:

      git merge origin/nombre-de-la-rama

    • Usando rebase:

      Cambia a la rama en la que deseas integrar los cambios (por ejemplo, main):

      git checkout main

      Haz el rebase con la rama remota:

      git rebase origin/nombre-de-la-rama

Ejemplo práctico usando git pull

Si deseas traer y fusionar los cambios en un solo paso, puedes usar git pull.

  1. Cambiar a la rama en la que deseas integrar los cambios (por ejemplo, main):

    git checkout main

  2. Traer y fusionar los cambios de la rama remota:

    git pull origin nombre-de-la-rama

¿Cuál usar?

  • git fetch seguido de merge o rebase:

    • Más control sobre la integración de cambios.
    • Puedes revisar los cambios antes de integrarlos.
    • Útil en entornos de desarrollo colaborativos donde deseas evitar conflictos de integración inesperados.

  • git pull:

    • Más rápido y conveniente si confías en los cambios y deseas fusionarlos directamente.
    • Útil para mantener ramas de desarrollo sincronizadas rápidamente.

Ambos métodos son válidos, y la elección depende de tu flujo de trabajo y necesidades específicas.

Revertir commit en Git (local)

Para revertir un commit en Git y volver el HEAD a un commit anterior, puedes seguir estos pasos:

1. Verificar el commit que deseas deshacer

Primero, asegúrate de cuál es el commit al que quieres regresar el HEAD. En este ejemplo vamos a revertir el commit más reciente _ "anterior al actual" ef1794f.

2. Usar git reset para mover el HEAD

Abre tu terminal y navega hasta el directorio de tu repositorio local. Luego, ejecuta el siguiente comando:

git reset --hard HEAD^

Este comando hará lo siguiente:

  • git reset --hard: Revertirá el HEAD y el índice al commit especificado.
  • HEAD^: Este es un atajo para referirse al commit anterior al actual.

Después de ejecutar este comando, el commit ef1794f y todos los cambios realizados en él serán eliminados del árbol de confirmaciones y el HEAD se moverá al commit anterior (e61d56b en tu caso).

3. Verificar el estado del repositorio

Puedes usar git log para verificar que el HEAD esté ahora en el commit correcto:

git log --oneline

Esto mostrará los últimos commits en una línea cada uno, para que puedas asegurarte de que el HEAD esté donde quieres que esté.

4. Ajustar la rama remota (si es necesario)

Si ya has empujado el commit ef1794f a la rama remota y necesitas ajustarla también, puedes usar git push --force para forzar la actualización de la rama remota:

git push origin v01.03 --force

Nota de precaución: Ten cuidado al usar git push --force ya que sobrescribirá la historia del repositorio remoto. Esto puede causar problemas si otros colaboradores ya tienen copias del repositorio con el commit que estás eliminando.

Resumen

  • git reset --hard HEAD^: Revierte el HEAD al commit anterior y elimina todos los cambios hechos en el commit que quieres deshacer.
  • Después de esto, verifica el estado del repositorio local y decide si necesitas ajustar la rama remota.

Siguiendo estos pasos, podrás deshacer el commit no deseado y regresar el HEAD a su estado anterior en tu rama local.

Git fork

Realizar un "fork" en Git es una acción común cuando deseas copiar un repositorio existente a tu cuenta personal en una plataforma de alojamiento como GitHub, GitLab o Bitbucket. Esto te permite trabajar en tu propia versión del proyecto sin afectar el repositorio original. Aquí te explico cómo hacerlo:

Pasos para hacer un "fork":

  1. Accede al repositorio original: Ve al sitio web donde está alojado el repositorio que deseas forkear. Por ejemplo, si es GitHub, navega a la página del repositorio en tu navegador.

  2. Haz clic en el botón "Fork": En la página del repositorio original, busca y haz clic en el botón "Fork" en la esquina superior derecha de la página. Esto iniciará el proceso de copia del repositorio a tu cuenta.

  3. Selecciona la cuenta o la organización: Si tienes varias cuentas u organizaciones bajo las cuales quieres realizar el fork, selecciona la adecuada.

  4. Espera a que se complete el proceso: La plataforma copiará automáticamente el repositorio a tu cuenta. Dependiendo del tamaño del repositorio y la velocidad del servidor, esto puede tomar algunos segundos o minutos.

Clonar el repositorio forked localmente:

Una vez que hayas hecho el fork, puedes clonar tu repositorio forked localmente en tu máquina usando Git. Aquí está cómo hacerlo:

  1. Obtén la URL del repositorio forked: En la página del repositorio forked en la plataforma (por ejemplo, GitHub), haz clic en el botón verde "Code" y copia la URL proporcionada.

  2. Abre tu terminal: Navega al directorio donde deseas clonar el repositorio y abre tu terminal.

  3. Clona el repositorio: Ejecuta el siguiente comando en tu terminal, reemplazando <URL> con la URL que copiaste:

    git clone <URL>

    Por ejemplo:

    git clone https://github.com/tu-usuario/repo-forked.git

  4. Accede al repositorio clonado: Una vez que el comando haya completado la descarga, puedes acceder al directorio del repositorio clonado usando cd repo-forked.

Realizar cambios y trabajar en tu repositorio forked:

Ahora que tienes el repositorio forked en tu cuenta y clonado en tu máquina, puedes trabajar en él como lo harías con cualquier otro repositorio Git:

  • Crea, modifica y elimina archivos según sea necesario.
  • Usa git add, git commit y git push para gestionar tus cambios localmente y luego enviarlos a tu repositorio forked en la plataforma.

Mantener tu repositorio forked actualizado:

Es posible que desees mantener tu repositorio forked actualizado con respecto al repositorio original del que hiciste el fork. Para hacer esto, puedes agregar el repositorio original como un "remote" en tu repositorio forked y fusionar los cambios cuando sea necesario. Aquí está cómo hacerlo:

  1. Agregar el repositorio original como un remote:

    git remote add upstream <URL-del-repositorio-original>

    Por ejemplo:

    git remote add upstream https://github.com/usuario-original/repo-original.git

  2. Actualizar y fusionar los cambios desde el repositorio original:

    git fetch upstream
git merge upstream/main  # o la rama principal que esté usando el repositorio original

    Esto traerá los cambios más recientes del repositorio original a tu repositorio forked local.

Siguiendo estos pasos, podrás hacer un "fork" de un repositorio existente a tu cuenta personal y trabajar en tu propia versión del proyecto.

Git "fork" con git clone

Clonar un repositorio del cual no tienes permisos y realizar cambios en un repositorio de tu github

Para hacer el git clone de un repositorio del cual no tenemos permisos para subir cambios, primero:

  • Clonamos, haciendo uso de git clone, el repositorio con el cual queremos trabajar.
  • Creamos un repositorio o buscamos su url de acceso remoto, en nuestro Github, Gitlab, etc..

Después de hacer el "fork"(clone) de un repositorio en plataformas como GitHub, GitLab, etc., el remote origin por defecto seguirá apuntando al repositorio original del cual hiciste el fork, no a tu cuenta personal automáticamente. Para configurarlo correctamente:

  1. Verifica los remotes actuales:

    git remote -v

    Esto muestra los remotes configurados, donde origin apunta al repositorio original.

  2. Cambia origin a tu repositorio forked:

    git remote set-url origin https://github.com/tu-usuario/repo-forked.git

    Reemplaza https://github.com/tu-usuario/repo-forked.git con la URL de tu repositorio forked en la plataforma correspondiente.

  3. Verifica el cambio:

    git remote -v

    Debe mostrar que origin ahora apunta a tu repositorio forked en tu cuenta personal.

Con estos pasos, origin estará configurado correctamente para reflejar tu repositorio forked, permitiéndote trabajar y empujar cambios a tu propia versión del proyecto sin afectar el repositorio original.

Git cherry-pick

Para mover los cambios que has guardado en una rama incorrecta a la rama correspondiente, puedes seguir estos pasos:

  1. Identificar el commit: Primero, asegúrate de conocer el hash del commit que quieres mover. En tu caso, es eb1307f.

  2. Cambiar a la rama correcta: Ve a la rama donde deberían estar los cambios.

  3. Cherry-pick el commit: Aplica el commit a la rama correcta usando git cherry-pick.

  4. Revertir el commit en la rama incorrecta: Si deseas eliminar el commit de la rama incorrecta, puedes hacerlo usando git reset o git revert.

A continuación, los pasos detallados:

Paso 1: Identificar el commit

Ya tienes el hash del commit eb1307f.

Paso 2: Cambiar a la rama correcta

Supongamos que la rama correcta es feature/correct-branch. Cambia a esa rama:

git checkout feature/correct-branch

Paso 3: Cherry-pick el commit

Aplica el commit específico a la rama correcta:

git cherry-pick eb1307f

Paso 4: Revertir el commit en la rama incorrecta

Vuelve a la rama donde hiciste el commit original:

git checkout v01

Opción 1: Usar git reset (si no has compartido la rama con otros)

Si nadie más ha trabajado en esta rama y es seguro cambiar el historial, puedes usar git reset para eliminar el commit:

git reset --hard HEAD~1

Opción 2: Usar git revert (si ya has compartido la rama)

Si ya has compartido esta rama con otros y necesitas mantener el historial, usa git revert para deshacer el commit sin cambiar el historial:

git revert eb1307f

Esto creará un nuevo commit que deshace los cambios introducidos por eb1307f.

Configuración usuarios

Ver configuracion usuario

Para ver la configuración de tu Git como usuario, puedes utilizar el siguiente comando en la línea de comandos (terminal):

git config --list

Este comando muestra todas las configuraciones de Git, tanto globales como locales. Si deseas ver solo la configuración global (la que se aplica a todos tus repositorios), puedes usar:

git config --global --list

Para ver la configuración específica de un repositorio en el que estés trabajando, puedes utilizar:

git config --local --list

Si deseas ver una configuración específica, como tu nombre de usuario o correo electrónico, puedes usar:

git config user.name
git config user.email

Estos comandos te mostrarán el nombre de usuario y el correo electrónico configurados, respectivamente.

Eliminar configuracion global y poner local

Forma tradicional

Si deseas trabajar con varios usuarios de GitHub en la misma máquina, puedes eliminar la configuración global del usuario y configurar el usuario correspondiente de manera local en cada repositorio. Aquí tienes los pasos detallados para hacerlo:

  1. Eliminar la configuración global de usuario:

    Para eliminar la configuración global del usuario, puedes usar los siguientes comandos:

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

  2. Configurar el usuario a nivel local en cada repositorio:

    Luego, puedes configurar el usuario correspondiente para cada proyecto de manera local. Ve al directorio del proyecto y usa los siguientes comandos para establecer el nombre y el correo electrónico:

    cd /ruta/a/tu/proyecto
git config user.name "Tu Nombre"
git config user.email "tu_email@example.com"

  3. Verificar la configuración local:

    Para asegurarte de que la configuración local se ha aplicado correctamente, puedes listar la configuración local del repositorio:

    git config --local --list
Ejemplo

Supongamos que tienes dos proyectos: proyectoA y proyectoB. Quieres usar el usuario usuario1 para proyectoA y usuario2 para proyectoB.

Para proyectoA:

cd /ruta/a/proyectoA
git config user.name "Usuario1"
git config user.email "usuario1@example.com"

Para proyectoB:

cd /ruta/a/proyectoB
git config user.name "Usuario2"
git config user.email "usuario2@example.com"
Github credentials

Es posible que las credenciales almacenadas en tu sistema sean incorrectas o estén desactualizadas. Puedes actualizar o eliminar las credenciales almacenadas:

Verificar y actualizar las credenciales almacenadas:

  • En Windows, ves a "Administrador de credenciales" y elimina las credenciales relacionadas con GitHub.
  • En macOS y Linux, puedes usar git credential-cache o git credential-store.

Ahora ya no tienes credentials y deberas dar permisos con el nuevo github. Para dar credenciales a un proyecto y no a todo el sistema, puedes seguir los "tips" Credenciales especificas para un repositorio

Alternativa: Usar múltiples SSH keys

Otra opción avanzada es configurar múltiples claves SSH para cada cuenta de GitHub y usar el archivo ~/.ssh/config para manejar estas claves. Aquí tienes un resumen de los pasos:

  1. Generar claves SSH para cada cuenta:

    ssh-keygen -t rsa -C "tu_email1@example.com" -f ~/.ssh/id_rsa_usuario1
ssh-keygen -t rsa -C "tu_email2@example.com" -f ~/.ssh/id_rsa_usuario2

  2. Agregar las claves SSH a tu agente SSH:

    ssh-add ~/.ssh/id_rsa_usuario1
ssh-add ~/.ssh/id_rsa_usuario2

  3. Configurar el archivo ~/.ssh/config:

    Abre (o crea) el archivo ~/.ssh/config y añade la configuración para cada cuenta:

    Host github-usuario1
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_usuario1

Host github-usuario2
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_usuario2

  4. Configurar el origen remoto en cada repositorio para usar el host adecuado:

    En proyectoA:

    cd /ruta/a/proyectoA
git remote set-url origin git@github-usuario1:usuario1/proyectoA.git

    En proyectoB:

    cd /ruta/a/proyectoB
git remote set-url origin git@github-usuario2:usuario2/proyectoB.git

Con estos pasos, puedes manejar múltiples cuentas de GitHub en la misma máquina de manera eficiente.

Credenciales especificas para un repositorio

Para configurar las credenciales de Git para un solo proyecto en lugar de todo el sistema, puedes usar el almacenamiento de credenciales específico para ese repositorio. Aquí tienes una guía paso a paso:

Configurar credenciales específicas para un repositorio

  1. Elimina las credenciales globales de GitHub:

    • En Windows, ve a "Administrador de credenciales" y elimina las credenciales relacionadas con GitHub.
    • En macOS y Linux, puedes usar git credential-cache o git credential-store para eliminar las credenciales almacenadas.

  2. Configura el almacenamiento de credenciales en tu repositorio específico:

    • Navega al directorio de tu repositorio:

      cd /ruta/a/tu/proyecto

    • Configura Git para usar un archivo de credenciales específico en este repositorio:

      git config credential.helper store

  3. Configura la URL remota para usar el token:

    • Configura la URL remota para incluir tu token de acceso personal. Esto almacenará el token solo para este repositorio:

      git remote set-url origin https://<your_token>@github.com/Study-JavaScript/markdowns.git

  4. Realiza una operación que requiera autenticación:

    • Realiza una operación que requiera autenticación, como un git push. Esto te pedirá las credenciales y las almacenará en el archivo de credenciales específico de este repositorio.

      git push origin study-javascript

Alternativa: Usar un archivo de configuración local para almacenar las credenciales

Otra opción es crear un archivo .git-credentials en el directorio del repositorio específico para almacenar las credenciales de manera local.

  1. Navega al directorio de tu repositorio:

    cd /ruta/a/tu/proyecto

  2. Crea un archivo .git-credentials en el directorio del repositorio:

    echo "https://<your_token>@github.com" > .git-credentials

  3. Configura Git para usar este archivo de credenciales:

    git config --local credential.helper 'store --file=.git-credentials'

Verifica que las credenciales están configuradas correctamente

Para asegurarte de que las credenciales están configuradas correctamente solo para este repositorio, puedes verificar la configuración local:

git config --local --list

Deberías ver algo como esto:

credential.helper=store --file=.git-credentials

Con estos pasos, las credenciales estarán configuradas únicamente para este repositorio específico y no afectarán a otros repositorios en tu sistema.

Cambiar un commit (descripcion) ya pusheado

Sí, es posible cambiar el mensaje de un commit que ya ha sido pushado a GitHub. Sin embargo, hay que tener en cuenta que modificar el historial de commits puede causar problemas para otros desarrolladores que estén trabajando en el mismo repositorio. Aquí tienes los pasos para cambiar el mensaje de un commit que ya has pushado:

  1. Modificar el mensaje del commit: Usa git rebase para modificar el mensaje del commit en cuestión. Por ejemplo, si quieres cambiar el mensaje del último commit, puedes usar:

    git commit --amend -m "Nuevo mensaje del commit"

    Si quieres cambiar el mensaje de un commit más antiguo, puedes iniciar una rebase interactiva:

    git rebase -i HEAD~n

    Donde n es el número de commits hacia atrás que quieres rebasar. En el editor que se abre, cambia pick a reword en el commit que quieres modificar. Guarda y cierra el editor, y luego cambia el mensaje en el siguiente editor que se abre.

  2. Forzar el push al repositorio remoto: Después de modificar el mensaje del commit, necesitarás forzar el push al repositorio remoto para actualizar el historial de commits:

    git push --force origin nombre_de_la_rama

    Ten en cuenta que el --force sobrescribirá el historial en el repositorio remoto, lo cual puede causar problemas para otros colaboradores. Si varios desarrolladores están trabajando en la misma rama, es mejor comunicarles antes de hacer este cambio.

Ejemplo paso a paso:

  1. Modificar el mensaje del último commit:

    git commit --amend -m "Nuevo mensaje del commit"

  2. Forzar el push:

    git push --force origin nombre_de_la_rama

Consideraciones adicionales:

  • Notificar a tus compañeros de equipo: Si estás trabajando en una rama compartida, asegúrate de notificar a tus compañeros de equipo sobre el cambio, ya que tendrán que sincronizar sus repositorios locales con el nuevo historial.
  • Evitar problemas de rebase: Si no estás familiarizado con el rebase, asegúrate de revisar la documentación y realizar estos cambios en una rama de prueba primero para evitar problemas.

Modificar commits que ya han sido pushados debe hacerse con cuidado para evitar conflictos y problemas de sincronización en el equipo.

Nueva rama sin commits anteriores

Para crear una nueva rama que no mantenga los commits de las ramas actuales y que pase a ser la principal, puedes seguir estos pasos. Este proceso implica crear una nueva rama a partir del estado actual de tu repositorio y luego cambiar la rama principal a esta nueva rama. Aquí tienes un paso a paso para hacerlo:

1. Crear una nueva rama desde el estado deseado

Primero, decide desde qué punto del historial quieres que parta tu nueva rama. Puedes hacer esto desde un commit específico, desde un estado limpio del repositorio, o simplemente desde un nuevo inicio sin ningún commit previo.

Opción A: Crear una rama desde el estado actual

Si quieres crear la nueva rama desde el estado actual del repositorio (y por lo tanto, sin ningún commit anterior):

  1. Asegúrate de estar en la rama principal actual (por ejemplo, main o master):

    git checkout main

  2. Crear una nueva rama:

    git checkout --orphan nueva-rama

    El flag --orphan crea una nueva rama sin historial, lo que significa que la nueva rama no tendrá ninguna historia previa. Estarás en un estado limpio.

  3. Eliminar todos los archivos del directorio de trabajo (si deseas empezar desde cero):

    git rm -rf .

  4. Agregar nuevos archivos y hacer un commit inicial (si es necesario):

    touch README.md
git add README.md
git commit -m "Primer commit en nueva rama"

Opción B: Crear una rama desde un commit específico

Si prefieres crear la nueva rama desde un commit específico (por ejemplo, desde el commit más reciente o desde otro commit):

  1. Encuentra el hash del commit desde el cual quieres empezar la nueva rama:

    git log

  2. Crear una nueva rama desde ese commit:

    git checkout -b nueva-rama <hash-del-commit>

    Cambia <hash-del-commit> por el hash del commit deseado.

2. Hacer que la nueva rama sea la principal

Para hacer que la nueva rama se convierta en la principal (por ejemplo, main):

  1. Sube la nueva rama al repositorio remoto:

    git push -u origin nueva-rama

  2. Cambiar la rama principal en el repositorio remoto:

    Ve a la configuración del repositorio en GitHub (o en tu plataforma de control de versiones) y cambia la rama predeterminada a nueva-rama.

    • En GitHub, ve a Settings > Branches y selecciona la nueva rama como la predeterminada.

  3. Eliminar la antigua rama principal (opcional):

    Si quieres eliminar la antigua rama principal (main o master), hazlo con:

    git push origin --delete main

    Nota: Asegúrate de que nadie esté trabajando en esa rama antes de eliminarla.

  4. Actualizar tu repositorio local para reflejar los cambios:

    Cambia a la nueva rama principal en tu repositorio local:

    git checkout nueva-rama

    Elimina la referencia local a la antigua rama principal:

    git branch -D main

    Sincroniza los cambios:

    git fetch --all --prune

    Esto debería actualizar tu repositorio local para reflejar la nueva configuración.

Resumen

  • Crear una nueva rama a partir del estado deseado.
  • Hacer la nueva rama la principal tanto en el repositorio local como en el remoto.
  • Eliminar la antigua rama principal si es necesario.

Estos pasos te permitirán iniciar con una nueva rama limpia y convertirla en la rama principal de tu proyecto.