20 comandos básicos de Git que todo ingeniero QA debe conocer

En este artículo hablaremos de Git. Git es un sistema de control de versiones, una herramienta que rastrea los cambios en tu código y comparte esos cambios con otros. Enumeraremos los comandos más básicos que un QA/desarrollador debe conocer para dominar la gestión de los repositorios de GitHub a un alto nivel. Será útil tanto para principiantes como para usuarios experimentados para repasar de nuevo los comandos básicos del día a día.

Establecer el nombre de usuario en Git

El nombre de usuario es necesario para vincular los commits a tu nombre. No es el mismo que el nombre de usuario de la cuenta de GitHub que se utiliza para acceder al perfil de GitHub. Puedes establecer o cambiar el nombre de usuario utilizando el comando git config.El nuevo nombre aparecerá automáticamente en las siguientes confirmaciones enviadas a través de la línea de comandos.

git config --global user.name "Michael Scott"

También puedes cambiar la dirección de correo electrónico asociada a tus commits de git con el comando git config.La nueva dirección de correo electrónico aparecerá automáticamente en todas las futuras confirmaciones enviadas a GitHub a través de la línea de comandos.

git config --global user.email "[email protected]"

Caché de credenciales

Las credenciales pueden almacenarse en la caché mediante la opción config con el --global flag. Esto te ayuda a no tener que introducir manualmente un nombre de usuario y una contraseña al crear un nuevo commit. Ayuda a almacenar temporalmente las contraseñas en la memoria.

git config --global credential.helper cache

Creación de un repositorio

Crear un repositorio Git vacío o reiniciar uno existente. Ejecutar git init crea un subdirectorio .git en el directorio de trabajo actual, que contiene todos los metadatos Git necesarios para el nuevo repositorio. Estos metadatos incluyen subdirectorios para objetos, referencias y archivos de plantilla.

git init

Añadir archivos a la zona de escalonamiento

El comando git add command añade los archivos nuevos o modificados en tu directorio de trabajo al área de preparación de Git.
Añade algún archivo:

git add somefile.js

Añade todos los archivos:

git add .

Comprobación del estado repo

El comando git status muestra el estado del directorio de trabajo y del área de preparación. Te permite ver qué cambios han sido puestos en escena, cuáles no, y qué archivos no están siendo rastreados por Git.

git status

Tomar una captura de los cambios

Grabar los cambios en el repositorio. Este comando se utiliza para guardar los cambios en el repositorio local. Se puede utilizar con algunas claves de git, como:

• - m para añadir un mensaje a su confirmación
• - a para poner en escena todos los archivos en su commit
• --amend para reescribir la última confirmación con los cambios que se estén realizando o con un nuevo mensaje de confirmación

git commit -m "Commit message"
git commit --amend
git commit --amend -m "New message"

Comprobar el historial de git

Mostrar los registros de confirmación. También como usuario de git puedes usar el comando git log de forma más avanzada, simplemente añadiendo algunas claves a tu comando git log

git log

Oneline flag, muestra cada confirmación en una sola línea:

git log --oneline

Shortlog agrupa cada confirmación por autor y muestra la primera línea de cada mensaje de confirmación:

git shortlog

La opción --graph dibuja un gráfico ASCII que representa la estructura de ramas del historial de confirmaciones. Se suele utilizar junto con los comando –oneline y –decorate para que sea más fácil ver qué confirmación pertenece a qué rama:

git log --graph --oneline --decorate

`
También puedes limitar el número de commits a la salida del registro:

git log -5

Soportar el filtrado del historial de git, por ejemplo por fecha, por autor, por archivo, por mensaje:

git log --after="yesterday" --before="2022-10-10"
git log --author="Michael"
git log -- somefile.js
git log -S "fix"

Cambios en la pantalla

git diff muestra los cambios entre commits, commit y árbol de trabajo.

git diff

Especifique el nombre del archivo para mostrar los cambios en curso de su archivo:

git diff somefile.js

Muestra los cambios entre las ramas master y develop:

git diff master..develop

Cambio de nombre de los archivos

Puedes cambiar el nombre de un archivo o carpeta con el comandomv. Debes especificar una ruta de origen y otra de destino. El origen es un archivo o carpeta real, y el destino es una carpeta existente.

git mv directory1/somefile.js directory

Función de ramificación

Una rama representa una línea de desarrollo independiente. Las ramas sirven como una abstracción para el proceso de edición/etapa/compromiso. El comando git branch te permite crear, listar, renombrar y eliminar ramas.
Para crear una nueva rama:

git branch branch_name

También puedes pasar algunas claves al comando git branch:

• git branch -m <branch> para renombrar la rama actual
• git branch -d <branch> para eliminar la rama localmente
• git push origin --delete <branch> para empujar los cambios a remoto informando de la eliminación de la rama al repositorio de origen remoto (requiere su uso con el comando anterior)
• git branch -a para mostrar la lista de todas las ramas

Deshacer cambios en los archivos

El comando git restore ayuda a deshacer o incluso descartar los cambios locales no comprometidos. El comando puede ser utilizado para deshacer los efectos de git add y deshacer los cambios que ha añadido previamente, también puede ser utilizado para descartar los cambios locales en un archivo, restaurando así su último estado comprometido.

git restore somefile.js
git restore --staged index.js

Trabajar con comandos remotos

git remote gestionar un conjunto de repositorios remotos rastreados.
Para mostrar la lista de todas las conexiones remotas:

git remote -v

Para cambiar la url remota:

git remote set-url <url> <new_url>

Para renombrar las conexiones actuales, se puede utilizar el siguiente comando:

git remote rename <old_name> <new_name>

Para eliminar la conexión:

git remote remove <remote_name>

Guardar los cambios en el portapapeles

git stash Guarda los cambios en un directorio de trabajo sucio. Este comando toma los cambios no comprometidos (tanto staged y unstaged) y los guarda para su uso posterior.

git stash

Se pueden añadir varias teclas al comando:

• git stash para guardar los archivos rastreados
• git stash -u para almacenar los archivos sin seguimiento
• git stash -a para almacenar todos los archivos (incluidos los ignorados)

El comando Stash guarda tus cambios en una especie de lista de cambios, a la que puedes acceder simplemente usando:

git stash list

Además, puedes añadir mensajes a tu stash, anotándolos con el comando:git stash save "message"

git stash save "some comment"

También admite la visualización de los diferenciales del stash:

git stash show

Para aplicar los cambios guardados en el stash (se aplicará el último stash de la lista de stash):

git stash apply

Y poder limpiar todos los stash:

git stash clear

Etiquetado

git tag etiqueta puntos específicos en la historia de un repositorio.

git tag v1.1

Para acceder a la lista de etiquetas utilice git tag -l. Para borrar sólo hay que pasar una clave específica git tag -d v1.0. Para listar las etiquetas remotas: git ls-remote --tags. Para reetiquetar Para reetiquetar (cambiar el nombre de la etiqueta existente) sólo tienes que enviar con la tecla de fuerza: git tag -f v1 v1.1 , en este caso renombrando v1 con el nuevo v.1.1.

Obtén los últimos cambios remotos

Para obtener los últimos cambios en su local hay 2 comandos git: git pull y git fetch. La principal diferencia entre ellos es que git fetch descargará el contenido remoto pero no actualizará el estado de trabajo de su repo local, dejando su trabajo actual intacto. Personalmente utilizo un comando git fetch con una llave --prune, que es la mejor utilidad para limpiar las ramas obsoletas. Antes de la obtención, elimina cualquier referencia de seguimiento remoto que ya no exista en el remoto. git pull en cambio, descargará el contenido remoto de la rama local activa y ejecutará inmediatamente la fusión en sus archivos. También git pull se puede utilizar con la clave común rebase: git pull -r para tirar y volver a basar.

Deshacer los cambios y restaurar los commits perdidos

git cherry-pick se utiliza para este propósito. Cherry-picking en git significa que eliges un commit de una rama y lo aplicas a otra. Normalmente en los equipos de desarrollo se utiliza para la corrección rápida de errores (hotfixes) en las etapas de lanzamiento, o cuando hay necesidad de aplicar commits no fusionados. Para usar este comando debes pasar el commit sha.

Deshacer los últimos commits

En git existen dos formas de deshacer los últimos cambios: git revert y git reset. El comando git revert crea una nueva confirmación que deshace los cambios de una confirmación anterior. Este comando añade un nuevo historial al proyecto. git reset se utiliza para deshacer los cambios en tu directorio de trabajo que aún no han sido cometidos. El comando Reset se puede utilizar con argumentos --soft, --mixed, --hard. Por defecto git utiliza reset con --mixedkey (anular el compromiso + anular los cambios). Los desarrolladores utilizan con frecuencia la opción --hard (anular el compromiso + anular la etapa + eliminar los cambios). Cuando se le pasa --hard los punteros del historial de confirmaciones se actualizan a la confirmación especificada. Y --soft es una forma más precisa si se desea descomprometer los cambios, en este caso los cambios se dejan escalonados.
Por ejemplo, para restablecer los archivos a HEAD en git:

git reset --hard HEAD 

Cambio entre commits o ramas

El comando git checkout es usado. Puedes cambiar entre commits y ramas, simplemente pasando branch_name/commit_sha a el comando git checkout. También puedes crear una nueva rama no existente utilizando el comando checkout, se creará una nueva rama y se cambiará a ella:

git checkout -b new_branch

Para comprobar algún commit, donde 5939515 es el commit sha:

git checkout 5939515

Encuentra el commit que rompió algo

git bisect es tu amigo. Es un comando muy potente en git que ayuda mucho. Se utiliza para señalar dos commits cómo casos límite y luego repasar todo el historial de commits entre estos dos puntos (y marcar commit por commit si hubo algún fallo específico). Para utilizarlo, primero hay que empezar a inicializar con la herramienta:

git bisect start

Entonces deberíamos marcar dos casos límite como puntos malos y buenos:

git bisect bad
git checkout commit
git bisect good

Revisando los commits se puede encontrar fácilmente un commit malo, que posiblemente haya introducido algún error/bug.

Mostrar quién hizo cambios en el archivo seleccionado

El comando git blame se utiliza para esto. El propósito principal es mostrar el registro del archivo seleccionado, mostrando quién y cuándo hizo cambios en este archivo.

git blame somefile.js 

Mostrará una lista de confirmaciones hechas a este archivo, autores, fecha y mensajes de confirmación. El comando se puede utilizar pasando algunas claves como -e para mostrar la dirección de correo electrónico de los autores en el registro, -L 1-7 para limitar y mostrar sólo 7 líneas de salida. La diferencia principal entre git blame y git log es que blame puede decir quién fue la última persona que modificó cada línea de código y cuándo.

Referencias

Me gustaría mencionar algunos enlaces útiles, libros relacionados con el mundo Git:

• Libro Pro Git
• Página oficial de Git
• Tutoriales Git atlassian
• Artículo de Apiumhub Git Bisect
• Artículo de Apiumhub sobre datos sensibles Git
• Artículo de Apiumhub sobre GitTip: Saltar el artículo de WorkTree