Curso Acelerado de Git para principiantes
June 29, 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]()
- [Instalar Git no teu equipo]()
- [Configuración (Login)]()
- [Clonar un repositorio]()
- [Comandos útiles]()
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.
- O Espacio de Traballo e o directorio no teu ordenador. É donde sucede todo o traballo.
- A área Staging é donde están os arquivos modificados antes de facer un commit. Permite, esencialmente, seleccionar solo os arquivos que queres «commitear».
- O Local é a túa copia do repositorio. Non o ve naide máis que tí.
- O Remoto é o repositorio público. Todos ven o mesmo remoto.
Así, evidentemente, mover cambios de un Espacio de Traballo a outro implicará pasar de workspace1 > staging1 > remote > local2 > staging2 > workspace2. É importante ter en conta qeu 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.
Git non ven instalado no Windows (sorpresón...), así que tes que instalalo.
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
Esto 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 branch new-branch-name`: Crea unha rama a partir da actual chamada `new-branch-name`
- `-d ou --delete`: Borra unha rama. Ex.: `git branch -d garamallo`
- `-D`: Borra forzosamente unha rama. Esto úsase cando queres borrar unha rama que ten cambios que non se enviaron ó servidor. Ex.: `git branch -D garamallo`
- `-a ou --all`: Mostra todas as ramas remotas e locáis.
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 checkout develop`: esto valo usar moito. Vai cambiar a rama na que estés coa rama `develop`.
- `git checkout rama-no-servidor`: Si queres traballar na rama de outra persoa (asumindo qeu el xa «pusheou» a súa rama hacia o repositorio remoto), podes usar este comando para facer unha copia local na túa máquina. Terás que facer un `git fetch` primeiro para coller a información sobre a rama.
- `git checkout -b nova-rama`: crea unha nova rama a partir da actual e cambia a esa rama. Si estás en `develop`, creará unha nova rama copia de develop. Este comando é sinónimo a `git branch nova-rama && git checkout nova-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 add /ruta/arquivo.foo`: agrega solo o arquivo indicado.
- `git add .`: esto agregará todos os arquivos modificados. Ten coidado con esto, asegúrate de que non estás agregando cambios que non queres. Revísao con `git status`. Si accidentalmente agregas algún arquivo que non queiras, bota un ollo a `git reset` descrito abaixo.
git commit
Queres facer un commit! Molas! Así é como o podes facer:
- `git commit`: Esto fará un commit dos arquivos preparados con `git add`, e abrirá un editor para que escribas unha mesaxe para o commit.
- `git commit -a`: Esto fará un commit e engadirá todos os arquivos modificados, e abrirá un editor para escribir unha mensaxe. É o mesmo que facer `git add . && git commit`.
- `git commit -m "mensaxe do commit"`: Evita o editor e colle o mensaxe da opción "-m".
- `git commit -a -m "mensaxe do commit"`: Combina as anteriores! wiii!
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 push nome-rama` ou `git push origin HEAD`: Envía a rama ó servidor. Podes usar calquera version, usar origin HEAD é simplemente unha maneira máis verbosa de facelo. Significa que estás enviando a punta (HEAD) da túa rama co mesmo nome ó `origin` remoto.
- `git push origin -f nome-rama` ou `git push origin +nome-rama`: MOITO OLLO!! Este comando é potencialmente peligroso, solo deberías usalo si realmente sabes o que estás facendo. Sobrescribirá a rama especificada no repositorio remoto coa túa copia local!!!
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 log`: Mostra todos os commits de esta rama, co seu hash, autor, fecha e mensaxe.
- `git log --oneline`: Mostra unha versión simplificada do comando anterior, mostrando solo o hash e a mensaxe.
- `git log --graph`: Mostra un gráfico do histórico de comandos da rama.
- `git log --max-count
`: Limita o número de commits a mostrar.
- `git log --oneline --graph --max-count 50`: Todos combinados! Fuck yeah!
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 stash`: aparca os cambios non aplicados.
- `git stash pop`: desaparca os cambios.
- `git stash push
`: aparca un arquivo.
- `git stash -m
`: agrega unha mensaxe ós aparcados.
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:
- HEAD: a punta da túa rama.
- Index: a área de aparcado, que é como un commit prosposto
- Directorio de Traballo: os arquivos que se almacenan no teu disco
Hai tres modos de facer o reset: `--soft`, `--mixed` (por defecto), e `--hard`:
- Desfacer `git add`:
- `git add .`
- `git reset -- file.html` (desaparca solo un arquivo, ou)
- `git reset` (desaparca todo)
- Desfacer o commit mais reciente:
- `git commit -a -m "mensaxe"`
- `git reset --soft HEAD^` (desfai o commit que está na punta da rama)
- `git commit -a -m "novo mensaxe"`
- Desfai un commit permanemtemente:
- `git reset --hard HEAD~2` (destrue os dous últimos commits, HEAD e HEAD^)