~sergio

ARTIGOS

Curso acelerado de Git para principiantes

29-06-2022

Prefacio

Un bo conocemento de Git é unha ferramenta increíble para calquera colaborando con un grupo en un proxecto. Ó principio aprender a usar Git parece complicado e dificil de entender, pero de feito é bastante sinxelo.

Git é un sistema de control de versiós que permite a múltiples programadores contribuir a un proxecto simultáneamente. É unha aplicación de liña de comandos con un conxunto de órdes para manipular os «commits» e as ramas (como se explica máis abaixo). Este tutorial axudarache a empezar, e en breves serás un Ninja do Git!

Contido:

Cómo funciona Git

Ramas e confirmaciós de cambios (commits)

Unha das maiores ventaxas do Git é a súa capacidade para crear ramas. Esto permitelle a alguén facer unha rama da rama master (normalmente donde se garda o código de producción) e traballar en unha característica nova ou correxir un bug independientemente do resto do proxecto. Unha vez remata o seu traballo, pode mezclar a rama de volta na rama master con un simple click. 

CARACTERÍSTICA       o-----o-o---------o-----o
                    /                          \
MASTER    <---o----o------o--o-------------------o------>

As ramas para características novas proveen un entorno aislado para que o programador poida traballar. Tamén son útiles para organizar diferentes niveles de granularidade. Por exemplo, no que se conoce como o Fluxo Git, hai tres ramas importantes: master, staging e develop. Master é a rama pai, representando o estado no que o proxecto se mostra ó público (desplegado). A rama staging é donde se fan as probas de calidade antes de entregar o código. E develop é donde os programadores traballan no proxecto. Todas as ramas de características se separan desde develop. 

CARACTERÍSTICA1      o-----o-o---------o-----o
                    /                          \
DEVELOP   <-------o-----o---o-----------o-------o------>
                         \               \
STAGING   <---------------o---------------o----o-------->
                           \                    \
MASTER    <------------------o-------------------o------>

No diagrama de arriba, as confirmaciós de cambios (commits) represéntanse con «o» nas ramas. Un commit é unha peza individual de traballo. É como unha meta que marca cando unha pequena peza da tarea se completou.

Espacio de Traballo, Staging, Local e Remoto

Un repositorio Git está dividido en catro niveles. Cada nivel representa un estado da base de código. Cada estado está aíslado dos demáis, pero os comandos git permiten transferir datos entre eles.

Así, evidentemente, mover cambios de un Espacio de Traballo a outro implicará pasar de workspace1 > staging1 > remote > local2 > staging2 > workspace2. É importante ter en conta que toda a comunicación debe pasar a través do respositorio remoto.

Instalar Git no teu equipo

Si estás usando UNIX estás de sorte! Git ven preinstalado na maioría de distribuciós Linux, BSD e en macOS. Executa `git --version` en un terminal para comprobar si xa o tes instalado.

Si non está instalado fixo que figura no repositorio do sistema que uses. Por exemplo en un Debian, instalaríase así: 

apt install git

Configuración (Login)

Vamos a configurarlo para que o poidas usar. Primeiro, é necesario que te identifiques. A primeira vez que instalas Git, é importante configurar o teu nome de usuario e o email, xa que cada commit vai firmado con esta información. En unha terminal: 

$ git config --global user.name "Manolo Expósito"
$ git config --global user.email manolo.exposito@exemplo.com

Clonar un repositorio

Si tes un IDE que soporte Git e xa fixeches algo como «Comprobar desde Control de Versiones» podes saltar esta sección. Si non, necesitas clonar o repositorio remoto na túa máquina local. Afortunadamente, é un proceso sinxelo.

Abre un terminal e navega ó directorio donde queres clonar o repositorio. Ahora executa: 

git clone

Esta url de clonado proporcionaracha o xestor de git remoto que uses.

Este último comando debería crear un novo directorio fillo co código do proxecto. Ahora no novo directorio poderás executar os teus comandos git.

Comandos útiles

git status

Mostra o estado da rama actual. Informará sobre que arquivos foron modificados, cales están preparados para commit e cales non. Tamén che dirá si a túa rama local está por detráis, ou non está actualizada, coa correspondente rama remota. Este comando é particularmente útil en conxunto con `git add` cando solo queres commitear certos arquivos.

git branch

Crea unha rama, ou mostra unha lista das ramas locáis ou remotas. A git branch podes pasarlle opciós para executar acciós relativas ás ramas:

git fetch

Recolle ramas do servidor, así como o seu histórico e información. Tamén podes usar `git fetch origin` para actualizar o seguimento das ramas remotas.

git pull

Actualiza o teu directorio do espacio de traballo facendo un git fetch, seguido de un git merge. Esto é útil si queres actualizar a túa rama ó punto do seguimento da rama remota.

Tamén podes usar a opción `--rebase` para facer un rebase en lugar de un merge.

git checkout

Este comando ten unhas cantas opciós. Pódese usar para crear unha rama nova a partir da actual, pódese usar para traer unha rama do servidor ou tamén para cambiar a outra rama.

git add

Fixeches cambios na tua rama, e queres preparar os cambios antes de envialos.

Primeiro necesitas agregalos ó que se chama `index`. Hai dúas maneiras:

git commit

Queres facer un commit! Molas! Así é como o podes facer:

git push

Unha vez que fas un commit, necesitas enviar os cambios ó servidor para facelos visibles para o resto de colaboradores. Unha vez que fas o push, a túa rama e os commits serán visibles ós demáis.

git log

Mostrará o histórico de todas as ramas e os seus commits. É útil para ver os commits máis recientes e conseguir os seus hashes.

git rebase

Rebasing é un pouco máis avanzado, pero increíblemente útil cando o necesitas. Cando fas un rebase, estás cambiando a base da túa rama. En esencia, un rebase vai comprobar cada commit da túa rama e actualizar o código para facer que pareza como si estiveses traballando sobre a nova base. A veces, un rebase protestará si se encontra con unha situación na cal intente actualizar unha peza de código que acabas de modificar. En este caso, non saberá que versión do código usar, así que deixaracho a ti para que o resolvas manualmente. Aínda que ten uso similares, un rebase diferénciase dun merge en que un rebase actualiza a túa rama modificando cada commit, e o merge actualizará a rama creando un solo commit na punta da rama. Normalmente, hai estándares e boas prácticas a empregar en un proxecto sobre cal das dúas maneiras usar. Fala co teu equipo sobre cal é o fluxo a seguir.

git stash

Facer stash (reservar, aparcar...) permíteche gardar os cambios que non tiveras aplicados e levar a rama de volta a un estado "non-modificado". Cando fas stash, os cambios lévanse a unha pila. Esto é especialmente útil si necesitas cambiar rápidamente a outra rama sin «commitear» os cambios incompletos.

git reset

Git reset úsase para desaparcar arquivos ou borrar commits. Faino cambiando a donde indica a punta da rama (HEAD). Tres `árbores` se modifican durante un reset:

Hai tres modos de facer o reset: `--soft`, `--mixed` (por defecto), e `--hard`:

Lectura adicional

7.7 Herramientas de Git - Reiniciar Desmitificado