05.Comandos básicos de Git.md

Comandos básicos de Git

Inicio, configuración y creación de repositorio: git init, git config

Para comenzar a utilizar Git en un proyecto, se debe inicializar un repositorio en el directorio donde se encuentra el código.

Esto se realiza con el comando git init, el cual crea un subdirectorio oculto .git que contiene todos los archivos necesarios para el control de versiones.

git init

Una vez inicializado el repositorio, se necesitan configurar los detalles de usuario para que Git pueda registrar quién realiza los cambios.

Esto se configura con el comando git config, especificando el nombre y el correo electrónico del usuario.

git config user.name "Nombre Apellido"
git config user.email "correo@ejemplo.com"

Si se quiere que la configuración se aplique a todos los repositorios del usuario en el sistema, se utiliza la opción --global.

git config --global user.name "Nombre Global"
git config --global user.email "correo@ejemplo.com"

Y si se quiere que se aplique a todos los repositorios del sistema, se utiliza la opción --system.

Además de los datos de usuario, también se puede definir el editor de texto predeterminado que se utilizará para los mensajes de commit:

git config core.editor "code --wait"

Aquí, se configura Visual Studio Code como editor predeterminado. La opción --wait sirve para que Git espere a que se cierre el editor antes de continuar.

Otra configuración es establecer el nombre de la rama principal. A partir de Git 2.28, se puede definir main como nombre predeterminado para la rama principal en lugar de master.

git config --global init.defaultBranch main

Se puede verificar la configuración actual de Git utilizando:

git config --list

Este comando muestra una lista de todas las propiedades configuradas, tanto globales como locales.

Creación y confirmación de cambios: git add, git commit

Tras hacer cambios, se necesitan registrar esos cambios.

El primer paso es agregar los archivos modificados al área de preparación o staging area utilizando git add.

Este comando indica a Git que se quieren incluir determinados archivos en el próximo commit.

git add nombre_del_archivo.txt

Si se quieren agregar todos los archivos modificados, se puede utilizar:

git add .

El punto . representa el directorio actual y, por tanto, se agregan todos los cambios en él y en sus subdirectorios.

Después de agregar los cambios al área de preparación, se confirma el registro de estos cambios con git commit.

Este comando crea un nuevo commit que almacena el estado actual de los archivos agregados.

git commit -m "Mensaje descriptivo del commit"

El flag -m permite especificar un mensaje al commit.

El mensaje debe ser claro y conciso.

Si no se pone el flag -m, Git abrirá el editor de texto predeterminado para que se escriba el mensaje del commit.

Se pueden combinar git add y git commit en un solo paso con el flag -a en git commit. Pero así sólo se agregan los archivos que ya estaban siendo rastreados por Git.

git commit -a -m "Actualiza estilos de la interfaz"

Este comando agrega automáticamente todos los archivos modificados y realiza el commit con el mensaje que se ponga.

No es necesario ejecutar git add antes, pero hay que tener en cuenta que no incluirá archivos nuevos que aún no han sido rastreados.

Si se quiere modificar el último commit en lugar de crear uno nuevo, se puede utilizar:

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

Sirve, por ejemplo, para corregir el mensaje o agregar más cambios.

Estado e historial: git status, git log

El comando git status sirve para ver el estado de los archivos en el working directory y en el área de preparación.

Al ejecutarlo, se obtiene información sobre los archivos que han sido modificados, agregados o eliminados, y que están pendientes de ser confirmados en un commit.

git status

Este comando mostrará una lista de archivos en diferentes estados:

• Archivos que han sido añadidos al staging area y están listos para ser confirmados.
• Archivos modificados pero no añadidos al área de preparación.
• Archivos no rastreados (untracked): los que Git aún no controla.

Un ejemplo de output puede ser:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   bye.py

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   hello.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        login.py

Si se quiere ver un resumen breve del estado, se puede utilizar la opción -s o --short:

git status -s

Esto mostrará una salida más concisa, donde los cambios se indican con símbolos:

A  bye.py
 M hello.py
?? login.py

• A: archivo añadido al staging.
• M: archivo modificado.
• ??: archivo no rastreado.

Por otra parte, para revisar el historial de commits del repositorio, se utiliza git log. Este comando muestra una lista detallada de los commits realizados, incluyendo información como el identificador del commit, autor, fecha y mensaje asociado.

git log

La salida típica de git log es:

commit 2f3c4d2e5b6a7c8d9e0f1a2b3c4d5e6f7a8b9c0d
Author: Nombre Apellido <correo@ejemplo.com>
Date:   Wed Sep 15 14:35:29 2024 +0200

    Agrega funcionalidad de autenticación

Para personalizar la información mostrada, se pueden utilizar diversas opciones:

• --oneline: muestra cada commit en una sola línea, mostrando únicamente el identificador corto y el mensaje.

git log --oneline

• --graph: representa gráficamente la rama y la fusión de commits.

git log --oneline --graph

• --stat: muestra estadísticas de los archivos modificados en cada commit. Esta opción da un resumen de los cambios en cada archivo, como el número de líneas añadidas o eliminadas.

git log --stat

• --grep: sirve para buscar commits que contienen una palabra clave específica en el mensaje, se utiliza --grep:

git log --grep="autenticación"

Si se necesitan visualizar los cambios introducidos en cada commit, se puede usar la opción -p:

git log -p

Si se quiere limitar el número de commits que se muestran, se puede añadir -n, donde n es el número de commits que se quieren ver:

git log -5

También se puede filtrar el historial por autor con --author o por fecha con --since y --until:

git log --author="Nombre Apellido"
git log --since="2 weeks ago"
git log --until="2025-02-28"

Exploración y recuperación de versiones: git checkout, git reset

El comando git checkout sirve para cambiar entre ramas o restaurar archivos a un estado específico. Aunque para cambiar entre ramas se suele recomendar usar git switch.

Por ejemplo, si se quiere cambiar a una rama llamada feature/nueva-funcionalidad, se usa:

git checkout feature/nueva-funcionalidad

git checkout permite restaurar archivos a una versión anterior.

Si se necesitan revertir los cambios en archivo.txt al último commit, se realiza:

git checkout -- archivo.txt

Este comando sobrescribe los cambios locales en archivo.txt con el contenido del último commit, por lo que hay que tener cuidado para no perder trabajo sin querer.

Por otra parte, git reset sirve para revertir cambios en el historial de commits.

Existen tres modos principales de git reset: --soft, --mixed y --hard, cada uno afectando diferentes áreas del repositorio.

El modo --soft mueve el puntero de la rama actual al commit especificado, pero mantiene los cambios en el área de preparación. Por ejemplo:

git reset --soft HEAD~1

Este comando deshace el último commit, pero conserva los cambios en el staging area, permitiendo modificar el commit anterior y volverlo a confirmar.

El modo por defecto, --mixed, restablece el puntero de la rama y el área de preparación, pero mantiene los cambios en el directorio de trabajo.

Se usa cuando se quiere rehacer el staging de los cambios:

git reset HEAD~1

El modo --hard restablece el puntero de la rama, el área de preparación y el directorio de trabajo.

Esto significa que se perderán todos los cambios locales no confirmados:

git reset --hard HEAD~1

Se utiliza git reset --hard cuando se necesita revertir completamente el repositorio a un estado anterior, eliminando cualquier modificación posterior

git checkout también sirve para ir a versiones anteriores del repositorio sin alterar el historial.

Si se quiere inspeccionar el estado del proyecto en un commit específico, se puede obtener el identificador SHA del commit con git log --oneline y luego ejecutar:

git checkout 2f3c4d2

Esto coloca al repositorio en un estado detached HEAD, donde se está en un commit específico sin estar en ninguna rama. Para volver a la rama principal, se utiliza:

git checkout main

Si se han cometido errores al modificar archivos, se recomienda usar git restore.

Por ejemplo, para descartar cambios en archivo.txt:

git restore archivo.txt

Aunque git checkout sigue siendo funcionando, se recomienda usar git switch y git restore en su lugar.

Si se necesita mover el HEAD a un commit específicocon git reset, se usa su identificador SHA. Por ejemplo:

git reset --hard 2f3c4d2

Esto restablece el repositorio al estado exacto de ese commit, eliminando cualquier cambio posterior. Pero cuidado con usar --hard porque los cambios descartados no se pueden recuperar fácilmente.

En caso de haber perdido cambios que se quieren recuperar, se usa git reflog para ver referencias a commits recientes que ya no están en el historial normal.

Personalización y comparación de cambios: git alias, git diff

Se pueden definir alias personalizados para simplificar comandos largos con git config.

Por ejemplo, si se quiere crear un alias para el comando git status, se utiliza:

git config alias.st status

Ahora se puede utilizar git st en lugar de git status.

git st

Se pueden crear alias que incluyen varias opciones. Por ejemplo, para crear un alias que muestre el historial en una sola línea y con grafo, se puede hacer:

git config alias.hist "log --oneline --graph"

Ahora, se puede usar git hist para ver un historial simplificado y visual:

git hist

Los alias se guardan en el archivo de configuración que se encuentra en .git/config. Para ver todos los alias definidos, se puede utilizar:

git config --get-regexp alias

Por otro lado, para analizar las diferencias entre estados del repositorio, se utiliza el comando git diff.

git diff compara cambios entre diferentes commits, ramas o el área de trabajo y el repositorio.

Por ejemplo, para ver las diferencias entre el directorio de trabajo y el último commit confirmado, se utiliza:

git diff

Este comando muestra línea por línea lo que ha sido añadido o eliminado.

Si se quieren comparar los cambios que están en el área de preparación con el último commit, se utiliza:

git diff --staged

Para comparar dos commits específicos, se necesitan los identificadores SHA de los commits. Por ejemplo:

git diff commit1 commit2

También se pueden comparar ramas diferentes. Si se quieren ver las diferencias entre la rama actual y otra rama llamada develop, se usa:

git diff develop

Si se quiere comparar dos ramas distintas, se especifican ambas:

git diff rama1 rama2

Usar git diff con la opción --stat muestra un resumen de los cambios:

git diff --stat

Esta opción muestra el número de inserciones y eliminaciones en cada archivo modificado.

Manejo de ramas: git branch, git switch

git branch sirve para hacer operaciones relacionadas con las ramas.

Para listar todas las ramas existentes en el repositorio, se utiliza:

git branch

Este comando muestra una lista de las ramas locales, marcando con un asterisco (*) la rama activa en ese momento.

Si se quiere crear una nueva rama llamada feature/nueva-funcionalidad, se utiliza:

git branch feature/nueva-funcionalidad

Este comando crea una nueva rama a partir de la rama actual, sin cambiar a ella.

Para cambiar a la una rama, se usa el comando git switch:

git switch feature/nueva-funcionalidad

Con git switch, se realiza el cambio de la rama activa a feature/nueva-funcionalidad.

Si se prefiere crear y cambiar a la nueva rama en un solo paso, se puede utilizar la opción -c de git switch:

git switch -c hotfix/login

Este comando combina la creación y el cambio de rama, facilitando el flujo de trabajo. Para eliminar una rama que ya no es necesaria, se emplea:

git branch -d feature/nueva-funcionalidad

La opción -d elimina la rama especificada, siempre y cuando los cambios en ella hayan sido integrados en otra rama.

Si se necesita forzar la eliminación sin verificar la integración, se puede utilizar -D:

git branch -D feature/nueva-funcionalidad

Hay que tener cuidado al usar -D no perder cambios indeseados.

Anteriormente, el comando git checkout se utilizaba tanto para cambiar entre ramas como para restaurar archivos. Pero a partir de las versiones más recientes de Git, se recomienda utilizar git switch para cambiar de rama y git restore para restaurar archivos.

Cuando se necesita crear y cambiar a una nueva rama basada en un commit específico o en otra rama, se puede especificar la referencia correspondiente:

git switch -c fix/bug-1234 develop

Este comando crea una nueva rama fix/bug-1234 basada en develop y cambia a ella inmediatamente.

Para renombrar una rama, se utiliza:

git branch -m nombre_antiguo nombre_nuevo

Este comando cambia el nombre de la rama nombre_antiguo a nombre_nuevo. Si se está en la rama que se quiere renombrar, se puede usar:

git branch -m nombre_nuevo

Para listar las ramas remotas, se utiliza:

git branch -r

Si se quieren listar tanto las ramas locales como las remotas, se usa:

git branch -a

Cuando una rama local tiene que sincronizarse con su parte remota, se usa:

git fetch

Con este comando, se actualiza la información de las ramas remotas.

Para cambiar a una rama remota y crear una rama local de seguimiento, se utiliza:

git switch -t origin/feature/remota

La opción -t crea una rama local que rastrea automáticamente la rama remota origin/feature/remota.